@polka-codes/cli 0.9.101 → 0.9.102

package/dist/index.js

@@ -16767,6 +16767,184 @@ var init_fs = __esm(() => {
 // ../core/src/memory/index.ts
 var init_memory2 = () => {};
 
+// ../core/src/pricing/converter.ts
+function convertPortkeyToModelInfo(portkey) {
+  return {
+    inputPrice: (portkey.request_token?.price ?? 0) * 10,
+    outputPrice: (portkey.response_token?.price ?? 0) * 10,
+    cacheWritesPrice: (portkey.cache_write_input_token?.price ?? 0) * 10,
+    cacheReadsPrice: (portkey.cache_read_input_token?.price ?? 0) * 10
+  };
+}
+
+// ../core/src/pricing/portkey-client.ts
+async function fetchWithTimeout(url2, timeoutMs) {
+  const controller = new AbortController;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url2, { signal: controller.signal });
+    return response;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function shouldRetry(response, error48) {
+  if (error48)
+    return true;
+  if (response.status >= 500)
+    return true;
+  return false;
+}
+async function fetchPricing(provider, model) {
+  const url2 = `${PORTKEY_BASE_URL}/${provider}/${model}`;
+  for (let attempt = 0;attempt <= MAX_RETRIES; attempt++) {
+    try {
+      const response = await fetchWithTimeout(url2, TIMEOUT_MS);
+      if (!response.ok) {
+        if (!shouldRetry(response, null)) {
+          return null;
+        }
+        if (attempt < MAX_RETRIES) {
+          await sleep(2 ** attempt * 1000);
+          continue;
+        }
+        return null;
+      }
+      const data = await response.json();
+      return data;
+    } catch (error48) {
+      if (attempt < MAX_RETRIES && shouldRetry(new Response(null, { status: 500 }), error48)) {
+        await sleep(2 ** attempt * 1000);
+        continue;
+      }
+      return null;
+    }
+  }
+  return null;
+}
+var PORTKEY_BASE_URL = "https://api.portkey.ai/model-configs/pricing", TIMEOUT_MS = 5000, MAX_RETRIES = 2;
+
+// ../core/src/pricing/pricing-service.ts
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile as readFile2, rename, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join as join2 } from "node:path";
+
+class PricingService {
+  #fallbackPrices;
+  #cacheFile;
+  #cache = null;
+  #loadPromise = null;
+  constructor(fallbackPrices = {}) {
+    const normalized = {};
+    for (const [provider, providerInfo] of Object.entries(fallbackPrices)) {
+      const normalizedProvider = provider.split("-")[0];
+      normalized[normalizedProvider] = {};
+      for (const [model, modelInfo] of Object.entries(providerInfo)) {
+        const normalizedModel = model.replace(/[.-]/g, "");
+        normalized[normalizedProvider][normalizedModel] = {
+          inputPrice: modelInfo.inputPrice ?? 0,
+          outputPrice: modelInfo.outputPrice ?? 0,
+          cacheWritesPrice: modelInfo.cacheWritesPrice ?? 0,
+          cacheReadsPrice: modelInfo.cacheReadsPrice ?? 0
+        };
+      }
+    }
+    this.#fallbackPrices = normalized;
+    this.#cacheFile = join2(homedir(), ".config", "polkacodes", "pricing-cache.json");
+  }
+  async#load() {
+    if (this.#loadPromise) {
+      return this.#loadPromise;
+    }
+    this.#loadPromise = (async () => {
+      this.#cache = new Map;
+      try {
+        const content = await readFile2(this.#cacheFile, "utf-8");
+        const data = JSON.parse(content);
+        for (const [key, value] of Object.entries(data)) {
+          this.#cache.set(key, value);
+        }
+      } catch {}
+    })();
+    return this.#loadPromise;
+  }
+  async#get(provider, model) {
+    await this.#load();
+    const key = `${provider}:${model}`;
+    const entry = this.#cache?.get(key);
+    if (!entry) {
+      return null;
+    }
+    if (Date.now() - entry.timestamp > CACHE_TTL_MS) {
+      this.#cache?.delete(key);
+      return null;
+    }
+    return entry.pricing;
+  }
+  async#set(provider, model, pricing) {
+    await this.#load();
+    const key = `${provider}:${model}`;
+    this.#cache?.set(key, {
+      pricing,
+      timestamp: Date.now()
+    });
+    await this.#save();
+  }
+  async#save() {
+    if (!this.#cache) {
+      return;
+    }
+    try {
+      const dir = dirname(this.#cacheFile);
+      await mkdir(dir, { recursive: true });
+      const data = {};
+      for (const [key, value] of this.#cache.entries()) {
+        data[key] = value;
+      }
+      const tempFile = `${this.#cacheFile}.${randomUUID()}.tmp`;
+      await writeFile(tempFile, JSON.stringify(data, null, 2), "utf-8");
+      await rename(tempFile, this.#cacheFile);
+    } catch {}
+  }
+  async getPricing(provider, model) {
+    const normalizedProvider = provider.split("-")[0];
+    const normalizedModel = model.replace(/[.-]/g, "");
+    const cached2 = await this.#get(normalizedProvider, normalizedModel);
+    if (cached2) {
+      return cached2;
+    }
+    const fallbackPrice = this.#fallbackPrices[normalizedProvider]?.[normalizedModel];
+    if (fallbackPrice) {
+      return fallbackPrice;
+    }
+    const portkeyPricing = await fetchPricing(normalizedProvider, model);
+    if (portkeyPricing) {
+      const modelInfo = convertPortkeyToModelInfo(portkeyPricing);
+      await this.#set(normalizedProvider, normalizedModel, modelInfo);
+      return modelInfo;
+    }
+    return {
+      inputPrice: 0,
+      outputPrice: 0,
+      cacheWritesPrice: 0,
+      cacheReadsPrice: 0
+    };
+  }
+}
+var CACHE_TTL_MS;
+var init_pricing_service = __esm(() => {
+  CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+});
+
+// ../core/src/pricing/index.ts
+var init_pricing = __esm(() => {
+  init_pricing_service();
+});
+
 // ../core/src/skills/constants.ts
 var SKILL_LIMITS, IGNORED_DIRECTORIES, SUSPICIOUS_PATTERNS, SKILL_ERROR_MESSAGES, SOURCE_ICONS;
 var init_constants = __esm(() => {
@@ -23791,7 +23969,7 @@ var init_types = __esm(() => {
 });
 
 // ../core/src/skills/discovery.ts
-import { homedir } from "node:os";
+import { homedir as homedir2 } from "node:os";
 function isBinaryFile(filename) {
   const ext = filename.toLowerCase().slice(filename.lastIndexOf("."));
   return BINARY_EXTENSIONS.includes(ext);
@@ -23831,7 +24009,7 @@ class SkillDiscoveryService {
   pluginSkillsDirs;
   constructor(options) {
     this.fs = options.fs ?? new NodeFileSystemProvider;
-    this.personalSkillsDir = options.personalSkillsDir ?? this.fs.join(homedir(), ".claude", "skills");
+    this.personalSkillsDir = options.personalSkillsDir ?? this.fs.join(homedir2(), ".claude", "skills");
     this.projectSkillsDir = this.fs.join(options.cwd, ".claude", "skills");
     this.pluginSkillsDirs = options.pluginSkillsDirs ?? [];
   }
@@ -24075,19 +24253,19 @@ var init_discovery = __esm(() => {
 });
 
 // ../core/src/skills/validation.ts
-import { join as join2, normalize as normalize2 } from "node:path";
+import { join as join3, normalize as normalize2 } from "node:path";
 function validateSkillSecurity(skill) {
   const { MAX_FILE_SIZE, MAX_SKILL_SIZE } = SKILL_LIMITS;
   let totalSize = 0;
   const contentSize = Buffer.byteLength(skill.content, "utf8");
   if (contentSize > MAX_FILE_SIZE) {
-    throw new SkillValidationError(`SKILL.md content exceeds size limit (${contentSize} > ${MAX_FILE_SIZE})`, join2(skill.path, "SKILL.md"));
+    throw new SkillValidationError(`SKILL.md content exceeds size limit (${contentSize} > ${MAX_FILE_SIZE})`, join3(skill.path, "SKILL.md"));
   }
   totalSize += contentSize;
   for (const [filename, content] of skill.files) {
     const fileSize = Buffer.byteLength(content, "utf8");
     if (fileSize > MAX_FILE_SIZE) {
-      throw new SkillValidationError(`File ${filename} exceeds size limit (${fileSize} > ${MAX_FILE_SIZE})`, join2(skill.path, filename));
+      throw new SkillValidationError(`File ${filename} exceeds size limit (${fileSize} > ${MAX_FILE_SIZE})`, join3(skill.path, filename));
     }
     totalSize += fileSize;
   }
@@ -24096,7 +24274,7 @@ function validateSkillSecurity(skill) {
   }
   validateContentSecurity(skill.content, skill.path);
   for (const [filename, content] of skill.files) {
-    validateContentSecurity(content, join2(skill.path, filename));
+    validateContentSecurity(content, join3(skill.path, filename));
   }
 }
 function validateContentSecurity(content, path) {
@@ -25519,9 +25697,11 @@ var init_tools2 = __esm(() => {
 class UsageMeter {
   #totals = { input: 0, output: 0, cachedRead: 0, cost: 0, messageCount: 0 };
   #providerMetadataEntries = [];
+  #pendingUpdates = new Set;
   #modelInfos;
   #maxMessages;
   #maxCost;
+  #pricingService;
   constructor(modelInfos = {}, opts = {}) {
     const infos = {};
     for (const [provider2, providerInfo] of Object.entries(modelInfos)) {
@@ -25537,6 +25717,7 @@ class UsageMeter {
     this.#modelInfos = infos;
     this.#maxMessages = opts.maxMessages ?? 1000;
     this.#maxCost = opts.maxCost ?? 100;
+    this.#pricingService = opts.pricingService;
   }
   #calculateUsage(usage, providerMetadata, modelInfo) {
     const providerMetadataKey = Object.keys(providerMetadata ?? {})[0];
@@ -25587,28 +25768,52 @@ class UsageMeter {
     }
   }
   addUsage(llm, resp, options = {}) {
-    const modelInfo = options.modelInfo ?? this.#modelInfos[`${llm.provider.split(".")[0]}:${llm.modelId.replace(/[.-]/g, "")}`] ?? {
-      inputPrice: 0,
-      outputPrice: 0,
-      cacheWritesPrice: 0,
-      cacheReadsPrice: 0
-    };
-    const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
-    const result = this.#calculateUsage(usage, resp.providerMetadata, modelInfo);
-    this.#totals.input += result.input || 0;
-    this.#totals.output += result.output || 0;
-    this.#totals.cachedRead += result.cachedRead || 0;
-    this.#totals.cost += result.cost || 0;
-    this.#totals.messageCount += 1;
-    if (resp.providerMetadata && Object.keys(resp.providerMetadata).length > 0) {
-      const providerKey = Object.keys(resp.providerMetadata)[0];
-      this.#providerMetadataEntries.push({
-        provider: providerKey || llm.provider,
-        model: llm.modelId,
-        metadata: resp.providerMetadata[providerKey] || resp.providerMetadata,
-        timestamp: Date.now()
-      });
-    }
+    const provider2 = llm.provider.split(".")[0];
+    const normalizedModel = llm.modelId.replace(/[.-]/g, "");
+    const key = `${provider2}:${normalizedModel}`;
+    let modelInfo = options.modelInfo ?? this.#modelInfos[key];
+    const updatePromise = (async () => {
+      try {
+        if (!modelInfo && this.#pricingService) {
+          modelInfo = await this.#pricingService.getPricing(provider2, llm.modelId);
+          this.#modelInfos[key] = modelInfo;
+        }
+      } catch {
+        modelInfo = {
+          inputPrice: 0,
+          outputPrice: 0,
+          cacheWritesPrice: 0,
+          cacheReadsPrice: 0
+        };
+      }
+      modelInfo = modelInfo ?? {
+        inputPrice: 0,
+        outputPrice: 0,
+        cacheWritesPrice: 0,
+        cacheReadsPrice: 0
+      };
+      const usage = "totalUsage" in resp ? resp.totalUsage : resp.usage;
+      const result = this.#calculateUsage(usage, resp.providerMetadata, modelInfo);
+      this.#totals.input += result.input || 0;
+      this.#totals.output += result.output || 0;
+      this.#totals.cachedRead += result.cachedRead || 0;
+      this.#totals.cost += result.cost || 0;
+      this.#totals.messageCount += 1;
+      if (resp.providerMetadata && Object.keys(resp.providerMetadata).length > 0) {
+        const providerKey = Object.keys(resp.providerMetadata)[0];
+        this.#providerMetadataEntries.push({
+          provider: providerKey || llm.provider,
+          model: llm.modelId,
+          metadata: resp.providerMetadata[providerKey] || resp.providerMetadata,
+          timestamp: Date.now()
+        });
+      }
+    })();
+    this.#pendingUpdates.add(updatePromise);
+    updatePromise.finally(() => {
+      this.#pendingUpdates.delete(updatePromise);
+    });
+    return updatePromise;
   }
   setUsage(newUsage, options = {}) {
     if (newUsage.input != null)
@@ -25692,13 +25897,17 @@ class UsageMeter {
     this.#totals.messageCount += otherUsage.messageCount;
     this.#providerMetadataEntries.push(...other.providerMetadata);
   }
+  async waitForPending() {
+    const pending = Array.from(this.#pendingUpdates);
+    await Promise.allSettled(pending);
+  }
   getUsageText() {
     const u = this.usage;
     return `Usage - messages: ${u.messageCount}, input: ${u.input}, cached: ${u.cachedRead}, output: ${u.output}, cost: $${u.cost.toFixed(4)}`;
   }
   onFinishHandler(llm) {
-    return (evt) => {
-      this.addUsage(llm, evt);
+    return async (evt) => {
+      await this.addUsage(llm, evt);
     };
   }
 }
@@ -40926,6 +41135,7 @@ var init_src = __esm(() => {
   init_errors3();
   init_fs();
   init_memory2();
+  init_pricing();
   init_skills();
   init_tools();
   init_tools2();
@@ -43311,11 +43521,11 @@ var init_lodash = __esm(() => {
 
 // ../cli-shared/src/config.ts
 import { existsSync as existsSync2, readFileSync } from "node:fs";
-import { readFile as readFile2 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join3 } from "node:path";
-function getGlobalConfigPath(home = homedir2()) {
-  return join3(home, ".config", "polkacodes", "config.yml");
+import { readFile as readFile3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { join as join4 } from "node:path";
+function getGlobalConfigPath(home = homedir3()) {
+  return join4(home, ".config", "polkacodes", "config.yml");
 }
 function loadConfigAtPath(path) {
   try {
@@ -43390,7 +43600,7 @@ async function resolveRules(rules) {
       }
     } else if ("path" in rule) {
       if (existsSync2(rule.path)) {
-        return await readFile2(rule.path, "utf-8");
+        return await readFile3(rule.path, "utf-8");
       }
       console.warn(`Rule file not found: ${rule.path}`);
     }
@@ -43400,7 +43610,7 @@ async function resolveRules(rules) {
 
 `);
 }
-async function loadConfig2(paths, cwd = process.cwd(), home = homedir2()) {
+async function loadConfig2(paths, cwd = process.cwd(), home = homedir3()) {
   const configs = [];
   const globalConfigPath = getGlobalConfigPath(home);
   if (existsSync2(globalConfigPath)) {
@@ -43429,7 +43639,7 @@ ${error48}`);
       }
     }
   } else {
-    const configPath = join3(cwd, localConfigFileName);
+    const configPath = join4(cwd, localConfigFileName);
     try {
       const projectConfig = readConfig(configPath);
       configs.push(projectConfig);
@@ -43520,7 +43730,7 @@ class MemoryManager {
 
 // ../cli-shared/src/project-scope.ts
 import { existsSync as existsSync3 } from "node:fs";
-import { dirname, normalize as normalize3, resolve as resolve2, sep } from "node:path";
+import { dirname as dirname2, normalize as normalize3, resolve as resolve2, sep } from "node:path";
 function detectProjectScope(cwd) {
   const projectPath = findProjectRoot(cwd);
   if (!projectPath) {
@@ -43554,7 +43764,7 @@ function findProjectRoot(dir) {
       return dir;
     }
   }
-  const parent = dirname(dir);
+  const parent = dirname2(dir);
   if (parent === dir) {
     return null;
   }
@@ -51317,7 +51527,7 @@ var require_gaxios = __commonJS((exports) => {
   var retry_js_1 = require_retry();
   var stream_1 = __require("stream");
   var interceptor_js_1 = require_interceptor();
-  var randomUUID = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
+  var randomUUID2 = async () => globalThis.crypto?.randomUUID() || (await import("crypto")).randomUUID();
   var HTTP_STATUS_NO_CONTENT = 204;
 
   class Gaxios {
@@ -51407,8 +51617,8 @@ var require_gaxios = __commonJS((exports) => {
         } else {
           err = new common_js_1.GaxiosError("Unexpected Gaxios Error", opts, undefined, e2);
         }
-        const { shouldRetry, config: config3 } = await (0, retry_js_1.getRetryConfig)(err);
-        if (shouldRetry && config3) {
+        const { shouldRetry: shouldRetry2, config: config3 } = await (0, retry_js_1.getRetryConfig)(err);
+        if (shouldRetry2 && config3) {
           err.config.retryConfig.currentRetryAttempt = config3.retryConfig.currentRetryAttempt;
           opts.retryConfig = err.config?.retryConfig;
           this.#appendTimeoutToSignal(opts);
@@ -51528,7 +51738,7 @@ var require_gaxios = __commonJS((exports) => {
       }
       const shouldDirectlyPassData = typeof opts.data === "string" || opts.data instanceof ArrayBuffer || opts.data instanceof Blob || globalThis.File && opts.data instanceof File || opts.data instanceof FormData || opts.data instanceof stream_1.Readable || opts.data instanceof ReadableStream || opts.data instanceof String || opts.data instanceof URLSearchParams || ArrayBuffer.isView(opts.data) || ["Blob", "File", "FormData"].includes(opts.data?.constructor?.name || "");
       if (opts.multipart?.length) {
-        const boundary = await randomUUID();
+        const boundary = await randomUUID2();
         preparedHeaders.set("content-type", `multipart/related; boundary=${boundary}`);
         opts.body = stream_1.Readable.from(this.getMultipartRequest(opts.multipart, boundary));
       } else if (shouldDirectlyPassData) {
@@ -56668,7 +56878,7 @@ var require_src6 = __commonJS((exports) => {
       });
     };
   }
-  var readFile3 = fs3.readFile ? (0, _util.promisify)(fs3.readFile) : /* @__PURE__ */ _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee() {
+  var readFile4 = fs3.readFile ? (0, _util.promisify)(fs3.readFile) : /* @__PURE__ */ _asyncToGenerator(/* @__PURE__ */ _regenerator().m(function _callee() {
     return _regenerator().w(function(_context) {
       while (true)
         switch (_context.n) {
@@ -56795,7 +57005,7 @@ var require_src6 = __commonJS((exports) => {
                   break;
                 case 1:
                   _context2.n = 2;
-                  return readFile3(keyFile, "utf8");
+                  return readFile4(keyFile, "utf8");
                 case 2:
                   key = _context2.v;
                   body = JSON.parse(key);
@@ -56813,7 +57023,7 @@ var require_src6 = __commonJS((exports) => {
                   });
                 case 4:
                   _context2.n = 5;
-                  return readFile3(keyFile, "utf8");
+                  return readFile4(keyFile, "utf8");
                 case 5:
                   _privateKey = _context2.v;
                   return _context2.a(2, {
@@ -58051,7 +58261,7 @@ var require_filesubjecttokensupplier = __commonJS((exports) => {
   exports.FileSubjectTokenSupplier = undefined;
   var util_1 = __require("util");
   var fs3 = __require("fs");
-  var readFile3 = (0, util_1.promisify)(fs3.readFile ?? (() => {}));
+  var readFile4 = (0, util_1.promisify)(fs3.readFile ?? (() => {}));
   var realpath = (0, util_1.promisify)(fs3.realpath ?? (() => {}));
   var lstat = (0, util_1.promisify)(fs3.lstat ?? (() => {}));
 
@@ -58078,7 +58288,7 @@ var require_filesubjecttokensupplier = __commonJS((exports) => {
         throw err;
       }
       let subjectToken;
-      const rawText = await readFile3(parsedFilePath, { encoding: "utf8" });
+      const rawText = await readFile4(parsedFilePath, { encoding: "utf8" });
       if (this.formatType === "text") {
         subjectToken = rawText;
       } else if (this.formatType === "json" && this.subjectTokenFieldName) {
@@ -73731,10 +73941,10 @@ var init_checkRipgrep = __esm(() => {
 
 // ../cli-shared/src/utils/listFiles.ts
 import { promises as fs3 } from "node:fs";
-import { join as join4, relative, resolve as resolve3 } from "node:path";
+import { join as join5, relative, resolve as resolve3 } from "node:path";
 async function extendPatterns(basePatterns, dirPath) {
   try {
-    const gitignorePath = join4(dirPath, ".gitignore");
+    const gitignorePath = join5(dirPath, ".gitignore");
     const content = await fs3.readFile(gitignorePath, "utf8");
     const lines = content.split(/\r?\n/).filter(Boolean);
     return [...basePatterns, ...lines];
@@ -73750,7 +73960,7 @@ async function listFiles(dirPath, recursive, maxCount, cwd, excludeFiles, includ
   if (!includeIgnored) {
     rootPatterns.push(...DEFAULT_IGNORES);
     try {
-      const rootGitignore = await fs3.readFile(join4(cwd, ".gitignore"), "utf8");
+      const rootGitignore = await fs3.readFile(join5(cwd, ".gitignore"), "utf8");
       const lines = rootGitignore.split(/\r?\n/).filter(Boolean);
       rootPatterns = [...rootPatterns, ...lines];
     } catch {}
@@ -73772,7 +73982,7 @@ async function listFiles(dirPath, recursive, maxCount, cwd, excludeFiles, includ
     const entries = await fs3.readdir(currentPath, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
-      const fullPath = join4(currentPath, entry.name);
+      const fullPath = join5(currentPath, entry.name);
       const relPath = relative(cwd, fullPath).replace(/\\/g, "/");
       if (folderIg.ignores(relPath)) {
         continue;
@@ -73789,7 +73999,7 @@ async function listFiles(dirPath, recursive, maxCount, cwd, excludeFiles, includ
         results.push(relPath);
         if (results.length >= maxCount) {
           const remainingEntries = entries.slice(entries.indexOf(entry) + 1);
-          const hasRemainingFiles = remainingEntries.some((e2) => !e2.isDirectory() && !folderIg.ignores(relative(cwd, join4(currentPath, e2.name)).replace(/\\/g, "/")));
+          const hasRemainingFiles = remainingEntries.some((e2) => !e2.isDirectory() && !folderIg.ignores(relative(cwd, join5(currentPath, e2.name)).replace(/\\/g, "/")));
           if (hasRemainingFiles) {
             const marker16 = `${currentRelPath}/(files omitted)`;
             results.push(marker16);
@@ -73891,8 +74101,8 @@ var init_searchFiles2 = __esm(() => {
 
 // ../cli-shared/src/provider.ts
 import { spawn as spawn2 } from "node:child_process";
-import { mkdir, readFile as readFile3, rename, unlink, writeFile } from "node:fs/promises";
-import { dirname as dirname2, normalize as normalize4, resolve as resolve4 } from "node:path";
+import { mkdir as mkdir2, readFile as readFile4, rename as rename2, unlink, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname3, normalize as normalize4, resolve as resolve4 } from "node:path";
 
 class InMemoryStore {
   #data;
@@ -74068,7 +74278,7 @@ ${content}`;
         throw new Error(`Not allow to access file ${path}`);
       }
       try {
-        return await readFile3(path, "utf8");
+        return await readFile4(path, "utf8");
       } catch (_e) {
         return;
       }
@@ -74077,8 +74287,8 @@ ${content}`;
       if (ig.ignores(path)) {
         throw new Error(`Not allow to access file ${path}`);
       }
-      await mkdir(dirname2(path), { recursive: true });
-      return await writeFile(path, content, "utf8");
+      await mkdir2(dirname3(path), { recursive: true });
+      return await writeFile2(path, content, "utf8");
     },
     removeFile: async (path) => {
       if (ig.ignores(path)) {
@@ -74090,7 +74300,7 @@ ${content}`;
       if (ig.ignores(sourcePath) || ig.ignores(targetPath)) {
         throw new Error(`Not allow to access file ${sourcePath} or ${targetPath}`);
       }
-      return await rename(sourcePath, targetPath);
+      return await rename2(sourcePath, targetPath);
     },
     listFiles: async (path, recursive, maxCount, includeIgnored) => {
       return await listFiles(path, recursive, maxCount, process.cwd(), options.excludeFiles, includeIgnored);
@@ -74102,7 +74312,7 @@ ${content}`;
         if (!resolvedPath.startsWith(process.cwd())) {
           throw new Error(`Access to file path "${filePath}" is restricted.`);
         }
-        const data2 = await readFile3(resolvedPath);
+        const data2 = await readFile4(resolvedPath);
         const mediaType2 = $lookup(resolvedPath) || "application/octet-stream";
         return {
           base64Data: data2.toString("base64"),
@@ -76525,10 +76735,10 @@ var require_sql_wasm = __commonJS((exports, module) => {
 
 // ../cli-shared/src/sqlite-memory-store.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-import { randomUUID } from "node:crypto";
+import { randomUUID as randomUUID2 } from "node:crypto";
 import { existsSync as existsSync4 } from "node:fs";
-import { mkdir as mkdir2, readdir as readdir2, readFile as readFile4, rename as rename2, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname3, resolve as resolve5 } from "node:path";
+import { mkdir as mkdir3, readdir as readdir2, readFile as readFile5, rename as rename3, unlink as unlink2, writeFile as writeFile3 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname4, resolve as resolve5 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 class FileLock {
@@ -76550,7 +76760,7 @@ class FileLock {
     }
     FileLock.lastCleanupTime = now2;
     try {
-      const lockDir = dirname3(dbPath);
+      const lockDir = dirname4(dbPath);
       const dbBaseName = basename2(dbPath);
       const files = await readdir2(lockDir);
       const now3 = Date.now();
@@ -76587,7 +76797,7 @@ class FileLock {
           pid: process.pid,
           acquiredAt: Date.now()
         });
-        await writeFile2(this.lockfilePath, lockData, {
+        await writeFile3(this.lockfilePath, lockData, {
           flag: "wx",
           mode: 384
         });
@@ -76596,23 +76806,23 @@ class FileLock {
         const errorCode = error48?.code;
         if (errorCode === "EEXIST") {
           try {
-            const lockContent = await readFile4(this.lockfilePath, "utf-8");
+            const lockContent = await readFile5(this.lockfilePath, "utf-8");
             const lockData = JSON.parse(lockContent);
             if (!lockData || typeof lockData.acquiredAt !== "number" || lockData.acquiredAt <= 0) {
               console.warn(`[FileLock] Lock file has invalid acquiredAt, treating as stale`);
-              await rename2(this.lockfilePath, `${this.lockfilePath}.invalid.${Date.now()}`);
+              await rename3(this.lockfilePath, `${this.lockfilePath}.invalid.${Date.now()}`);
               continue;
             }
             const lockAge = Date.now() - lockData.acquiredAt;
             if (lockAge > FileLock.LOCK_TIMEOUT) {
               console.warn(`[FileLock] Breaking stale lock (age: ${lockAge}ms)`);
-              await rename2(this.lockfilePath, `${this.lockfilePath}.stale.${Date.now()}`);
+              await rename3(this.lockfilePath, `${this.lockfilePath}.stale.${Date.now()}`);
               continue;
             }
           } catch (readError) {
             if (readError instanceof SyntaxError) {
               console.warn(`[FileLock] Lock file contains invalid JSON, treating as stale`);
-              await rename2(this.lockfilePath, `${this.lockfilePath}.corrupt.${Date.now()}`);
+              await rename3(this.lockfilePath, `${this.lockfilePath}.corrupt.${Date.now()}`);
               continue;
             }
           }
@@ -76629,7 +76839,7 @@ class FileLock {
   }
   async release() {
     try {
-      await rename2(this.lockfilePath, `${this.lockfilePath}.released.${Date.now()}`);
+      await rename3(this.lockfilePath, `${this.lockfilePath}.released.${Date.now()}`);
       const dbPath = this.lockfilePath.slice(0, -5);
       FileLock.cleanupOldLockFiles(dbPath).catch(() => {});
     } catch (error48) {
@@ -76681,7 +76891,7 @@ async function getSqlJs() {
   if (SqlJsInitPromise) {
     return SqlJsInitPromise;
   }
-  const moduleDir = dirname3(fileURLToPath(import.meta.url));
+  const moduleDir = dirname4(fileURLToPath(import.meta.url));
   const candidates = [
     resolve5(moduleDir, "sql-wasm.wasm"),
     resolve5(moduleDir, "..", "dist", "sql-wasm.wasm"),
@@ -76750,9 +76960,9 @@ var init_sqlite_memory_store = __esm(() => {
         }
         const dbPath = this.resolvePath(this.getDbPath());
         try {
-          const dir = dirname3(dbPath);
+          const dir = dirname4(dbPath);
           if (!existsSync4(dir)) {
-            await mkdir2(dir, { recursive: true, mode: 448 });
+            await mkdir3(dir, { recursive: true, mode: 448 });
           }
           FileLock.cleanupOldLockFiles(dbPath).catch(() => {});
           let dbData;
@@ -76761,7 +76971,7 @@ var init_sqlite_memory_store = __esm(() => {
             await lock.acquire();
             try {
               try {
-                dbData = await readFile4(dbPath);
+                dbData = await readFile5(dbPath);
                 if (dbData.length >= 16) {
                   const header = String.fromCharCode(...dbData.subarray(0, 15));
                   if (header !== "SQLite format 3") {
@@ -76794,7 +77004,7 @@ var init_sqlite_memory_store = __esm(() => {
             const backupPath = `${dbPath}.corrupted.${Date.now()}`;
             console.warn(`[SQLiteMemoryStore] Backing up corrupted database to: ${backupPath}`);
             try {
-              await rename2(dbPath, backupPath);
+              await rename3(dbPath, backupPath);
             } catch (backupError) {
               console.error("[SQLiteMemoryStore] Failed to backup corrupted database:", backupError);
               this.dbPromise = null;
@@ -76819,8 +77029,8 @@ var init_sqlite_memory_store = __esm(() => {
         const dbPath = this.resolvePath(this.getDbPath());
         const tempPath = `${dbPath}.tmp`;
         const data = this.db.export();
-        await writeFile2(tempPath, data, { mode: 384 });
-        await rename2(tempPath, dbPath);
+        await writeFile3(tempPath, data, { mode: 384 });
+        await rename3(tempPath, dbPath);
       } finally {
         await lock.release();
       }
@@ -76874,7 +77084,7 @@ var init_sqlite_memory_store = __esm(() => {
       return resolve5(resolved);
     }
     generateUUID() {
-      return randomUUID();
+      return randomUUID2();
     }
     now() {
       return Date.now();
@@ -112381,12 +112591,12 @@ var {
   Help
 } = import__.default;
 // package.json
-var version = "0.9.101";
+var version = "0.9.102";
 
 // src/commands/agent.ts
 init_src();
 import { exec as exec3 } from "node:child_process";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID as randomUUID3 } from "node:crypto";
 import * as fs11 from "node:fs/promises";
 import * as path10 from "node:path";
 import { promisify as promisify3 } from "node:util";
@@ -116423,7 +116633,7 @@ async function runAgent(goal, options, _command) {
   const config4 = await loadConfig(configOptions, options.config);
   const workingDir = process.cwd();
   const stateDir = path10.join(workingDir, ".polka", "agent-state");
-  const sessionId = `agent-${Date.now()}-${randomUUID2()}`;
+  const sessionId = `agent-${Date.now()}-${randomUUID3()}`;
   const asyncExec = promisify3(exec3);
   const tools3 = {
     executeCommand: async (input) => {
@@ -116530,7 +116740,7 @@ ${errorStdout}` : ""}`);
 var agentCommand = new Command("agent").description("Run autonomous agent (experimental)").argument("[goal]", "Goal to achieve", "").option("--continuous", "Run in continuous improvement mode").option("--preset <name>", "Configuration preset", "balanced").option("--config <path>", "Configuration file path").option("--approval-level <level>", "Approval level (none|destructive|commits|all)", "destructive").action(runAgent);
 
 // src/commands/code.ts
-import { readFile as readFile12 } from "node:fs/promises";
+import { readFile as readFile13 } from "node:fs/promises";
 init_mime_types();
 
 // src/runWorkflow.ts
@@ -116539,8 +116749,8 @@ init_src();
 init_lodash();
 init_errors6();
 init_getModel();
-import { mkdir as mkdir8 } from "node:fs/promises";
-import { dirname as dirname7 } from "node:path";
+import { mkdir as mkdir9 } from "node:fs/promises";
+import { dirname as dirname8 } from "node:path";
 
 // src/getProviderOptions.ts
 init_getModel();
@@ -117474,9 +117684,11 @@ async function runWorkflow(workflow2, workflowInput, options) {
     additionalTools,
     config: config4
   };
-  const usage = new UsageMeter(merge_default(prices_default, config4.prices ?? {}), {
+  const pricingService = new PricingService(merge_default({}, prices_default, config4.prices ?? {}));
+  const usage = new UsageMeter(merge_default({}, prices_default, config4.prices ?? {}), {
     maxMessages: config4.maxMessageCount,
-    maxCost: config4.budget
+    maxCost: config4.budget,
+    pricingService
   });
   options.onUsageMeterCreated?.(usage);
   const onEvent = printEvent(verbose, usage, process.stderr);
@@ -117521,8 +117733,8 @@ async function runWorkflow(workflow2, workflowInput, options) {
       const scope = detectProjectScope(cwd);
       const dbPath = memoryConfig.path || DEFAULT_MEMORY_CONFIG.path;
       const resolvedDbPath = resolveHomePath(dbPath);
-      const dbDir = dirname7(resolvedDbPath);
-      await mkdir8(dbDir, { recursive: true, mode: 448 });
+      const dbDir = dirname8(resolvedDbPath);
+      await mkdir9(dbDir, { recursive: true, mode: 448 });
       const sqliteStore = new SQLiteMemoryStore({ enabled: true, type: "sqlite", path: dbPath }, scope);
       const memoryManager = new MemoryManager(sqliteStore);
       memoryStore = memoryManager;
@@ -117603,6 +117815,7 @@ async function runWorkflow(workflow2, workflowInput, options) {
     }
     logger.info("Running workflow...");
     const output = await workflow2(finalWorkflowInput, workflowContext);
+    await usage.waitForPending();
     logger.info(`
 
 Workflow completed successfully.`);
@@ -117689,6 +117902,7 @@ Workflow completed successfully.`);
         }
       });
     }
+    await usage.waitForPending();
     logger.info(usage.getUsageText());
     return;
   } finally {
@@ -118151,7 +118365,7 @@ async function runCode(task3, _options, command) {
       try {
         const mimeType = $lookup(file2);
         if (mimeType) {
-          const buffer = await readFile12(file2);
+          const buffer = await readFile13(file2);
           if (mimeType.startsWith("image/")) {
             fileContents.push({
               type: "image",
@@ -118221,7 +118435,7 @@ var fixCommand = new Command("fix").description("Fix issues by running a command
 init_dist18();
 init_src3();
 import { existsSync as existsSync5, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 init_lodash();
 init_dist();
 
@@ -118314,7 +118528,7 @@ init_src();
 init_dist();
 init_zod();
 init_prompts2();
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 var scriptGenerationSystemPrompt = `Role: Expert TypeScript Developer and Automation Specialist
 
 Goal: Generate a custom polka script based on user requirements.
@@ -118477,7 +118691,7 @@ Please:
       }
       const scriptDir = ".polka-scripts";
       const scriptFileName = `${scriptName}.ts`;
-      const scriptFilePath = join13(scriptDir, scriptFileName);
+      const scriptFilePath = join14(scriptDir, scriptFileName);
       await step("save-script", async () => {
         await tools3.writeToFile({ path: scriptFilePath, content: script });
         logger.info(`
@@ -118512,7 +118726,7 @@ async function createSkill(name18, logger, interactive) {
   if (BUILT_IN_COMMANDS.includes(name18)) {
     throw new Error(`Skill name '${name18}' conflicts with a built-in command. ` + `Please choose a different name (e.g., '${name18}-skill' or 'my-${name18}')`);
   }
-  const skillDir = join14(".claude", "skills", name18);
+  const skillDir = join15(".claude", "skills", name18);
   if (existsSync5(skillDir)) {
     if (interactive) {
       const proceed = await dist_default4({
@@ -118530,7 +118744,7 @@ async function createSkill(name18, logger, interactive) {
   mkdirSync(skillDir, { recursive: true });
   logger.info(`Created skill directory: ${skillDir}`);
   const template = generateSkillTemplate(name18);
-  writeFileSync(join14(skillDir, "SKILL.md"), template);
+  writeFileSync(join15(skillDir, "SKILL.md"), template);
   logger.info(`Created SKILL.md`);
   logger.info("");
   logger.info(`Skill '${name18}' created successfully!`);
@@ -118601,7 +118815,7 @@ Add additional files like:
 async function createScript(name18, logger, interactive, isGlobal = false) {
   const scriptDir = ".polka-scripts";
   const scriptPathConfig = `${scriptDir}/${name18}.ts`;
-  const scriptPathActual = join14(scriptDir, `${name18}.ts`);
+  const scriptPathActual = join15(scriptDir, `${name18}.ts`);
   if (existsSync5(scriptPathActual)) {
     if (interactive) {
       const proceed = await dist_default4({
@@ -118765,7 +118979,7 @@ var initCommand = new Command("init").description("Initialize polkacodes configu
           process.exit(1);
         }
         const scriptDir = ".polka-scripts";
-        const scriptPath = join14(scriptDir, `${name18}.ts`);
+        const scriptPath = join15(scriptDir, `${name18}.ts`);
         if (existsSync5(scriptPath)) {
           if (interactive) {
             const proceed = await dist_default4({
@@ -121032,8 +121246,8 @@ var mcpServerCommand = new Command("mcp-server").description("Start polka-codes
 // src/commands/memory.ts
 init_src3();
 init_src();
-import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname8, resolve as resolve8 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile14, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname9, resolve as resolve8 } from "node:path";
 async function getMemoryStore2() {
   const globalConfigPath = getGlobalConfigPath();
   const config4 = await loadConfigAtPath(globalConfigPath);
@@ -121196,8 +121410,8 @@ async function memoryExport(options) {
       return;
     }
     const outputPath = options.output ? resolve8(process.cwd(), options.output) : resolve8(process.cwd(), `memory-export-${Date.now()}.json`);
-    await mkdir9(dirname8(outputPath), { recursive: true });
-    await writeFile8(outputPath, JSON.stringify(entries, null, 2));
+    await mkdir10(dirname9(outputPath), { recursive: true });
+    await writeFile9(outputPath, JSON.stringify(entries, null, 2));
     console.log(`Exported ${entries.length} entries to ${outputPath}`);
   } finally {
     store.close();
@@ -121207,7 +121421,7 @@ async function memoryImport(inputFile, options) {
   const store = await getMemoryStore2();
   try {
     const inputPath = resolve8(process.cwd(), inputFile);
-    const data = await readFile13(inputPath, "utf-8");
+    const data = await readFile14(inputPath, "utf-8");
     let entries;
     try {
       entries = JSON.parse(data);
@@ -122058,7 +122272,7 @@ var taskCommand = new Command("task").description("Run a generic task using an A
 
 // src/commands/workflow.ts
 init_src();
-import { readFile as readFile14 } from "node:fs/promises";
+import { readFile as readFile15 } from "node:fs/promises";
 async function runWorkflowCommand(task3, _options, command) {
   const workflowOpts = getBaseWorkflowOptions(command);
   const { verbose } = workflowOpts;
@@ -122071,7 +122285,7 @@ async function runWorkflowCommand(task3, _options, command) {
   logger.info(`Loading workflow from '${file2}'...`);
   let content;
   try {
-    content = await readFile14(file2, "utf-8");
+    content = await readFile15(file2, "utf-8");
   } catch (error48) {
     const errorMessage = error48 instanceof Error ? error48.message : String(error48);
     logger.error(`Error reading file '${file2}': ${errorMessage}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polka-codes/cli",
-  "version": "0.9.101",
+  "version": "0.9.102",
   "license": "AGPL-3.0",
   "author": "github@polka.codes",
   "type": "module",