feat: add token counter and pricing usage, added --version flag

ekaone · ekaone · commit bc9f548e497b · 2026-03-30T17:03:07.000+07:00
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@ekaone/json-cli",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "AI-powered CLI task runner with JSON command plans",
   "keywords": ["ai", "agent", "cli", "task-runner", "llm"],
   "author": {
diff --git a/src/cli.ts b/src/cli.ts
@@ -1,7 +1,9 @@
 import * as p from "@clack/prompts";
+import { createRequire } from "module";
 import { resolveProvider, type ProviderName } from "./providers/index.js";
 import { generatePlan } from "./planner.js";
 import { runPlan } from "./runner.js";
+import { calculateCost, formatCost } from "./providers/pricing.js";
 import type { Step } from "./catalog.js";
 
 // ---------------------------------------------------------------------------
@@ -16,7 +18,8 @@ function showHelp(): void {
   --yes               Skip confirmation prompt
   --dry-run           Show plan without executing
   --debug             Show system prompt and raw AI response
-  --help              Show this help message`,
+  --help              Show this help message
+  --version, -v       Show version`,
   );
   p.log.message(
     `Examples
@@ -45,6 +48,14 @@ function parseArgs(): {
   debug: boolean;
 } {
   const args = process.argv.slice(2);
+  const require = createRequire(import.meta.url);
+  const { version, name } = require("../package.json");
+
+  // show version
+  if (args.includes("--version") || args.includes("-v")) {
+    console.log(`${name}@${version}`);
+    process.exit(0);
+  }
 
   // show help if no args or --help flag
   if (args.length === 0 || args.includes("--help")) {
@@ -101,28 +112,28 @@ async function main() {
   const spinner = p.spinner();
   spinner.start("Thinking...");
 
-  let plan;
+  let planResult;
   try {
     const provider = resolveProvider(providerName);
-    plan = await generatePlan(prompt, provider, debug);
-    spinner.stop("Plan ready");
+    planResult = await generatePlan(prompt, provider, debug);
+    spinner.stop(debug ? "" : "Plan ready");
   } catch (err) {
     spinner.stop("Failed to generate plan");
     p.log.error(err instanceof Error ? err.message : String(err));
     process.exit(1);
   }
 
   // Step 2: Show plan
-  p.log.info(`Goal: ${plan.goal}\n`);
-  plan.steps.forEach((step, i) => {
+  p.log.info(`Goal: ${planResult.plan.goal}\n`);
+  planResult.plan.steps.forEach((step, i) => {
     const isShell = step.type === "shell";
     p.log.message(
       `  ${i + 1}. ${formatStep(step)}${isShell ? "  ⚠ shell" : ""}`,
     );
   });
 
   // Step 3: Extra warning if any shell steps
-  const hasShell = plan.steps.some((s) => s.type === "shell");
+  const hasShell = planResult.plan.steps.some((s) => s.type === "shell");
   if (hasShell) {
     p.log.warn(
       "Plan contains shell commands — review carefully before proceeding.",
@@ -131,38 +142,54 @@ async function main() {
 
   // Step 4: Dry run — show plan and exit
   if (dryRun) {
-    p.outro("Dry run complete — no commands were executed.");
-    setTimeout(() => process.exit(0), 50);
-    return;
+    const { input, output } = planResult.usage;
+    const cost = calculateCost(providerName, input, output);
+    const costStr = formatCost(cost);
+    const usageStr =
+      input > 0 || output > 0
+        ? `  |  tokens: ${input} in / ${output} out${costStr ? `  |  ${costStr}` : ""}`
+        : "";
+
+    p.outro(`Dry run complete — no commands were executed.${usageStr}`);
+    await new Promise((r) => setTimeout(r, 100));
+    process.exit(0);
   }
 
   // Step 5: Confirm — skip if --yes
   if (!yes) {
     const confirmed = await p.confirm({ message: "Proceed?" });
     if (p.isCancel(confirmed) || !confirmed) {
       p.cancel("Aborted.");
-      setTimeout(() => process.exit(0), 50);
-      return;
+      await new Promise((r) => setTimeout(r, 100));
+      process.exit(0);
     }
   } else {
     p.log.info("Skipping confirmation (--yes)");
   }
 
   // Step 6: Execute
   console.log("");
-  const result = await runPlan(plan, (step, i, total) => {
+  const result = await runPlan(planResult.plan, (step, i, total) => {
     p.log.step(`Step ${i + 1}/${total}: ${formatStep(step)}`);
   });
 
   // Step 7: Result
   if (result.success) {
-    p.outro("✅ All steps completed successfully.");
+    const { input, output } = planResult.usage;
+    const cost = calculateCost(providerName, input, output);
+    const costStr = formatCost(cost);
+    const usageStr =
+      input > 0 || output > 0
+        ? `  |  tokens: ${input} in / ${output} out${costStr ? `  |  ${costStr}` : ""}`
+        : "";
+
+    p.outro(`✅ All steps completed successfully.${usageStr}`);
   } else {
     p.log.error(
       `❌ Failed at step ${result.failedStep?.id}: ${result.failedStep?.description}\n${result.error ?? ""}`,
     );
-    setTimeout(() => process.exit(1), 50);
-    return;
+    await new Promise((r) => setTimeout(r, 100));
+    process.exit(1);
   }
 }
 
diff --git a/src/planner.ts b/src/planner.ts
@@ -1,5 +1,5 @@
 import { buildCatalogPrompt, PlanSchema, validateStep } from "./catalog.js";
-import type { AIProvider } from "./providers/types.js";
+import type { AIProvider, TokenUsage } from "./providers/types.js";
 import type { Plan } from "./catalog.js";
 
 // ---------------------------------------------------------------------------
@@ -51,7 +51,7 @@ export async function generatePlan(
   userPrompt: string,
   provider: AIProvider,
   debug: boolean = false,
-): Promise<Plan> {
+): Promise<{ plan: Plan; usage: TokenUsage }> {
   const systemPrompt = buildSystemPrompt();
 
   if (debug) {
@@ -64,25 +64,25 @@ export async function generatePlan(
     console.log("│");
   }
 
-  const raw = await provider.generate(userPrompt, systemPrompt);
+  const response = await provider.generate(userPrompt, systemPrompt);
 
   if (debug) {
     console.log("●  Raw AI response:");
     try {
-      const parsed = JSON.parse(raw);
+      const parsed = JSON.parse(response.content);
       console.log(
         "│  " + JSON.stringify(parsed, null, 2).split("\n").join("\n│  "),
       );
     } catch {
-      console.log("│  " + raw);
+      console.log("│  " + response.content);
     }
     console.log("│");
     console.log("◇  Plan ready");
     console.log("");
   }
 
   // Strip markdown fences if any provider wraps output
-  const cleaned = raw.replace(/```json|```/g, "").trim();
+  const cleaned = response.content.replace(/```json|```/g, "").trim();
 
   let parsed: unknown;
   try {
@@ -110,5 +110,8 @@ export async function generatePlan(
     }
   }
 
-  return result.data;
+  return {
+    plan: result.data,
+    usage: response.usage,
+  };
 }
diff --git a/src/providers/claude.ts b/src/providers/claude.ts
@@ -1,5 +1,5 @@
 import Anthropic from "@anthropic-ai/sdk";
-import type { AIProvider } from "./types.js";
+import type { AIProvider, TokenUsage } from "./types.js";
 
 export function createClaudeProvider(apiKey?: string): AIProvider {
   const client = new Anthropic({
@@ -19,7 +19,16 @@ export function createClaudeProvider(apiKey?: string): AIProvider {
       const block = message.content[0];
       if (block.type !== "text")
         throw new Error("Unexpected response type from Claude");
-      return block.text;
+
+      const usage: TokenUsage = {
+        input: message.usage?.input_tokens ?? 0,
+        output: message.usage?.output_tokens ?? 0,
+      };
+
+      return {
+        content: block.text,
+        usage,
+      };
     },
   };
 }
diff --git a/src/providers/ollama.ts b/src/providers/ollama.ts
@@ -1,28 +1,42 @@
-import type { AIProvider } from "./types.js";
+import type { AIProvider, TokenUsage } from "./types.js";
 
-export function createOllamaProvider(model = "llama3.2", baseUrl = "http://localhost:11434"): AIProvider {
+export function createOllamaProvider(
+  model = "llama3.2",
+  baseUrl = "http://localhost:11434",
+): AIProvider {
   return {
     name: `ollama/${model}`,
     async generate(userPrompt, systemPrompt) {
       const response = await fetch(`${baseUrl}/api/chat`, {
-        method:  "POST",
+        method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
           model,
           stream: false,
           messages: [
             { role: "system", content: systemPrompt },
-            { role: "user",   content: userPrompt },
+            { role: "user", content: userPrompt },
           ],
         }),
       });
 
       if (!response.ok) throw new Error(`Ollama error: ${response.statusText}`);
 
-      const data = await response.json() as { message?: { content?: string } };
+      const data = (await response.json()) as {
+        message?: { content?: string };
+      };
       const content = data?.message?.content;
       if (!content) throw new Error("Empty response from Ollama");
-      return content;
+
+      const usage: TokenUsage = {
+        input: 0,
+        output: 0,
+      };
+
+      return {
+        content,
+        usage,
+      };
     },
   };
 }
diff --git a/src/providers/openai.ts b/src/providers/openai.ts
@@ -1,5 +1,5 @@
 import OpenAI from "openai";
-import type { AIProvider } from "./types.js";
+import type { AIProvider, TokenUsage } from "./types.js";
 
 export function createOpenAIProvider(apiKey?: string): AIProvider {
   const client = new OpenAI({ apiKey: apiKey ?? process.env.OPENAI_API_KEY });
@@ -8,18 +8,27 @@ export function createOpenAIProvider(apiKey?: string): AIProvider {
     name: "openai",
     async generate(userPrompt, systemPrompt) {
       const response = await client.chat.completions.create({
-        model:    "gpt-4o",
+        model: "gpt-4o",
         messages: [
           { role: "system", content: systemPrompt },
-          { role: "user",   content: userPrompt },
+          { role: "user", content: userPrompt },
         ],
-        max_tokens:      1024,
+        max_tokens: 1024,
         response_format: { type: "json_object" }, // enforces JSON output
       });
 
       const content = response.choices[0]?.message.content;
       if (!content) throw new Error("Empty response from OpenAI");
-      return content;
+
+      const usage: TokenUsage = {
+        input: response.usage?.prompt_tokens ?? 0,
+        output: response.usage?.completion_tokens ?? 0,
+      };
+
+      return {
+        content,
+        usage,
+      };
     },
   };
 }
diff --git a/src/providers/pricing.ts b/src/providers/pricing.ts
@@ -0,0 +1,23 @@
+import type { ProviderName } from "./index.js";
+
+export const PRICING = {
+  claude: { input: 3.0, output: 15.0 }, // per 1M tokens
+  openai: { input: 2.5, output: 10.0 },
+  ollama: { input: 0, output: 0 }, // local, free
+} as const;
+
+export function calculateCost(
+  provider: ProviderName,
+  inputTokens: number,
+  outputTokens: number,
+): number {
+  const rates = PRICING[provider];
+  const inputCost = (inputTokens / 1_000_000) * rates.input;
+  const outputCost = (outputTokens / 1_000_000) * rates.output;
+  return inputCost + outputCost;
+}
+
+export function formatCost(cost: number): string {
+  if (cost === 0) return "";
+  return `~$${cost.toFixed(4)}`;
+}
diff --git a/src/providers/types.ts b/src/providers/types.ts
@@ -1,4 +1,15 @@
+export interface TokenUsage {
+  input: number;
+  output: number;
+}
+
 export interface AIProvider {
   name: string;
-  generate(userPrompt: string, systemPrompt: string): Promise<string>;
+  generate(
+    userPrompt: string,
+    systemPrompt: string,
+  ): Promise<{
+    content: string;
+    usage: TokenUsage;
+  }>;
 }
diff --git a/tests/planner.test.ts b/tests/planner.test.ts

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "@ekaone/json-cli",`
`3`		`- "version": "0.1.5",`
	`3`	`+ "version": "0.1.6",`
`4`	`4`	`"description": "AI-powered CLI task runner with JSON command plans",`
`5`	`5`	`"keywords": ["ai", "agent", "cli", "task-runner", "llm"],`
`6`	`6`	`"author": {`