@askexenow/exe-os 0.9.299 → 0.9.301

package/dist/chunk-7KPWYWYL.js

@@ -0,0 +1,290 @@
+import {
+  storeBehavior
+} from "./chunk-NXL3VKXM.js";
+import {
+  getClient
+} from "./chunk-XABJRAUW.js";
+import {
+  loadConfig
+} from "./chunk-R36FAN53.js";
+
+// src/lib/skill-learning.ts
+import crypto from "crypto";
+var DEFAULT_SKILL_THRESHOLD = 3;
+async function extractTrajectory(taskId, agentId) {
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT tool_name, raw_text
+          FROM memories
+          WHERE task_id = ? AND agent_id = ?
+          ORDER BY timestamp ASC`,
+    args: [taskId, agentId]
+  });
+  if (result.rows.length === 0) return [];
+  const rawTools = result.rows.map((r) => {
+    const toolName = String(r.tool_name);
+    if (toolName === "Bash") {
+      const text = String(r.raw_text);
+      const cmdMatch = text.match(/(?:command|Command).*?[:\s]+"?(\w+)/);
+      return cmdMatch ? `Bash:${cmdMatch[1]}` : "Bash";
+    }
+    return toolName;
+  });
+  const signature = [];
+  for (const tool of rawTools) {
+    if (signature.length === 0 || signature[signature.length - 1] !== tool) {
+      signature.push(tool);
+    }
+  }
+  return signature;
+}
+function hashSignature(signature) {
+  return crypto.createHash("sha256").update(signature.join("|")).digest("hex").slice(0, 16);
+}
+async function storeTrajectory(opts) {
+  const client = getClient();
+  const id = crypto.randomUUID();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const signatureHash = hashSignature(opts.signature);
+  await client.execute({
+    sql: `INSERT INTO trajectories (id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at)
+          VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    args: [
+      id,
+      opts.taskId,
+      opts.agentId,
+      opts.projectName,
+      opts.taskTitle,
+      JSON.stringify(opts.signature),
+      signatureHash,
+      opts.signature.length,
+      now
+    ]
+  });
+  return id;
+}
+async function findSimilarTrajectories(signature, threshold = DEFAULT_SKILL_THRESHOLD) {
+  const client = getClient();
+  const hash = hashSignature(signature);
+  const result = await client.execute({
+    sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
+          FROM trajectories
+          WHERE signature_hash = ?
+          ORDER BY created_at DESC
+          LIMIT 20`,
+    args: [hash]
+  });
+  const mapRow = (r) => ({
+    id: String(r.id),
+    taskId: String(r.task_id),
+    agentId: String(r.agent_id),
+    projectName: String(r.project_name),
+    taskTitle: String(r.task_title),
+    signature: JSON.parse(String(r.signature)),
+    signatureHash: String(r.signature_hash),
+    toolCount: Number(r.tool_count),
+    skillId: r.skill_id ? String(r.skill_id) : null,
+    createdAt: String(r.created_at)
+  });
+  const matches = result.rows.map(mapRow);
+  if (matches.length >= threshold) return matches;
+  const nearResult = await client.execute({
+    sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, skill_id, created_at
+          FROM trajectories
+          WHERE tool_count BETWEEN ? AND ?
+            AND signature_hash != ?
+          ORDER BY created_at DESC
+          LIMIT 50`,
+    args: [
+      Math.max(1, signature.length - 3),
+      signature.length + 3,
+      hash
+    ]
+  });
+  for (const r of nearResult.rows) {
+    const candidateSig = JSON.parse(String(r.signature));
+    if (editDistance(signature, candidateSig) <= 2) {
+      matches.push(mapRow(r));
+    }
+  }
+  return matches;
+}
+async function captureTrajectory(opts) {
+  const signature = await extractTrajectory(opts.taskId, opts.agentId);
+  if (signature.length < 3) {
+    return { trajectoryId: "", similarCount: 0, similar: [] };
+  }
+  const trajectoryId = await storeTrajectory({
+    taskId: opts.taskId,
+    agentId: opts.agentId,
+    projectName: opts.projectName,
+    taskTitle: opts.taskTitle,
+    signature
+  });
+  const similar = await findSimilarTrajectories(
+    signature,
+    opts.skillThreshold ?? DEFAULT_SKILL_THRESHOLD
+  );
+  return { trajectoryId, similarCount: similar.length, similar };
+}
+function buildExtractionPrompt(trajectories) {
+  const items = trajectories.map((t, i) => {
+    const sig = t.signature.join(" \u2192 ");
+    return `Task ${i + 1}: "${t.taskTitle}" (${t.agentId}, ${t.projectName}) \u2014 ${t.toolCount} tool calls
+Signature: ${sig}`;
+  }).join("\n\n");
+  return `You are analyzing ${trajectories.length} completed tasks that followed similar procedures:
+
+${items}
+
+Extract the reusable procedure. Format your response EXACTLY like this:
+
+SKILL: {name \u2014 short, descriptive}
+TRIGGER: {when to use this \u2014 one sentence}
+STEPS:
+1. ...
+2. ...
+PITFALLS: {common mistakes to avoid}
+
+Be specific and actionable. Include tool names, file patterns, and concrete commands where applicable.`;
+}
+async function extractSkill(trajectories, model) {
+  if (trajectories.length === 0) return null;
+  const config = await loadConfig();
+  const skillModel = model ?? config.skillModel;
+  const Anthropic = (await import("@anthropic-ai/sdk")).default;
+  const client = new Anthropic();
+  const prompt = buildExtractionPrompt(trajectories);
+  const response = await client.messages.create({
+    model: skillModel,
+    max_tokens: 500,
+    messages: [{ role: "user", content: prompt }]
+  });
+  const textBlock = response.content.find((b) => b.type === "text");
+  const skillText = textBlock?.text;
+  if (!skillText) return null;
+  const agentId = trajectories[0].agentId;
+  const projectName = trajectories[0].projectName;
+  const skillId = await storeBehavior({
+    agentId,
+    content: skillText,
+    domain: "skill",
+    projectName
+  });
+  const dbClient = getClient();
+  for (const t of trajectories) {
+    await dbClient.execute({
+      sql: "UPDATE trajectories SET skill_id = ? WHERE id = ?",
+      args: [skillId, t.id]
+    });
+  }
+  process.stderr.write(
+    `[skill-learning] Skill extracted from ${trajectories.length} trajectories \u2192 behavior ${skillId}
+`
+  );
+  return skillId;
+}
+async function captureAndLearn(opts) {
+  try {
+    const config = await loadConfig();
+    if (!config.skillLearning) return;
+    const { trajectoryId, similarCount, similar } = await captureTrajectory({
+      ...opts,
+      skillThreshold: config.skillThreshold
+    });
+    if (!trajectoryId) return;
+    if (similarCount >= config.skillThreshold) {
+      const unprocessed = similar.filter((t) => !t.skillId);
+      if (unprocessed.length >= config.skillThreshold) {
+        extractSkill(unprocessed, config.skillModel).catch((err) => {
+          process.stderr.write(
+            `[skill-learning] Extraction failed: ${err instanceof Error ? err.message : String(err)}
+`
+          );
+        });
+      }
+    }
+  } catch (err) {
+    process.stderr.write(
+      `[skill-learning] captureAndLearn failed: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+}
+async function sweepTrajectories(threshold, model) {
+  const config = await loadConfig();
+  if (!config.skillLearning) return { clustersProcessed: 0, skillsExtracted: 0 };
+  const t = threshold ?? config.skillThreshold;
+  const client = getClient();
+  const result = await client.execute({
+    sql: `SELECT signature_hash, COUNT(*) as cnt
+          FROM trajectories
+          WHERE skill_id IS NULL
+          GROUP BY signature_hash
+          HAVING cnt >= ?
+          ORDER BY cnt DESC
+          LIMIT 10`,
+    args: [t]
+  });
+  let clustersProcessed = 0;
+  let skillsExtracted = 0;
+  for (const row of result.rows) {
+    const hash = String(row.signature_hash);
+    const trajResult = await client.execute({
+      sql: `SELECT id, task_id, agent_id, project_name, task_title, signature, signature_hash, tool_count, created_at
+            FROM trajectories
+            WHERE signature_hash = ? AND skill_id IS NULL
+            ORDER BY created_at DESC
+            LIMIT 10`,
+      args: [hash]
+    });
+    const trajectories = trajResult.rows.map((r) => ({
+      id: String(r.id),
+      taskId: String(r.task_id),
+      agentId: String(r.agent_id),
+      projectName: String(r.project_name),
+      taskTitle: String(r.task_title),
+      signature: JSON.parse(String(r.signature)),
+      signatureHash: String(r.signature_hash),
+      toolCount: Number(r.tool_count),
+      skillId: null,
+      createdAt: String(r.created_at)
+    }));
+    if (trajectories.length >= t) {
+      clustersProcessed++;
+      const skillId = await extractSkill(trajectories, model ?? config.skillModel);
+      if (skillId) skillsExtracted++;
+    }
+  }
+  return { clustersProcessed, skillsExtracted };
+}
+function editDistance(a, b) {
+  const m = a.length;
+  const n = b.length;
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+  for (let i = 0; i <= m; i++) dp[i][0] = i;
+  for (let j = 0; j <= n; j++) dp[0][j] = j;
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      dp[i][j] = Math.min(
+        dp[i - 1][j] + 1,
+        dp[i][j - 1] + 1,
+        dp[i - 1][j - 1] + cost
+      );
+    }
+  }
+  return dp[m][n];
+}
+
+export {
+  extractTrajectory,
+  hashSignature,
+  storeTrajectory,
+  findSimilarTrajectories,
+  captureTrajectory,
+  extractSkill,
+  captureAndLearn,
+  sweepTrajectories,
+  editDistance
+};

package/dist/chunk-7P4B6AEP.js

@@ -0,0 +1,227 @@
+import {
+  getClient
+} from "./chunk-V6LOEOXG.js";
+
+// src/lib/token-spend.ts
+import { readdir, stat } from "fs/promises";
+import { createReadStream } from "fs";
+import { createInterface } from "readline";
+import path from "path";
+import os from "os";
+var MODEL_PRICING = {
+  // Opus 4.5+ ($5/$25 — Anthropic price drop from original Opus 4)
+  "claude-opus-4-7": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-6": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  "claude-opus-4-5": { input: 5 / 1e6, output: 25 / 1e6, cacheRead: 0.5 / 1e6, cacheWrite: 6.25 / 1e6 },
+  // Opus 4.0/4.1 (legacy $15/$75)
+  "claude-opus-4-1": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  "claude-opus-4": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 4.x
+  "claude-sonnet-4": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Sonnet 3.7/3.5
+  "claude-3-7-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  "claude-3-5-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 4.5
+  "claude-haiku-4-5": { input: 1 / 1e6, output: 5 / 1e6, cacheRead: 0.1 / 1e6, cacheWrite: 1.25 / 1e6 },
+  // Haiku 3.5
+  "claude-3-5-haiku": { input: 0.8 / 1e6, output: 4 / 1e6, cacheRead: 0.08 / 1e6, cacheWrite: 1 / 1e6 },
+  // Opus 3
+  "claude-3-opus": { input: 15 / 1e6, output: 75 / 1e6, cacheRead: 1.5 / 1e6, cacheWrite: 18.75 / 1e6 },
+  // Sonnet 3
+  "claude-3-sonnet": { input: 3 / 1e6, output: 15 / 1e6, cacheRead: 0.3 / 1e6, cacheWrite: 3.75 / 1e6 },
+  // Haiku 3
+  "claude-3-haiku": { input: 0.25 / 1e6, output: 1.25 / 1e6, cacheRead: 0.03 / 1e6, cacheWrite: 0.3 / 1e6 }
+};
+var DEFAULT_PRICING = MODEL_PRICING["claude-sonnet-4"];
+var CACHE_TTL_MS = 5 * 60 * 1e3;
+var JSONL_INDEX_TTL_MS = 5 * 60 * 1e3;
+var USAGE_CACHE_MAX_ENTRIES = 1e4;
+var _spendCache = /* @__PURE__ */ new Map();
+var _spendInFlight = /* @__PURE__ */ new Map();
+var _usageCache = /* @__PURE__ */ new Map();
+var _usageInFlight = /* @__PURE__ */ new Map();
+var _jsonlPathIndex = null;
+function yieldToEventLoop() {
+  return new Promise((resolve) => setImmediate(resolve));
+}
+function getPricing(model) {
+  if (MODEL_PRICING[model]) return MODEL_PRICING[model];
+  const stripped = model.replace(/-\d{8}$/, "");
+  if (MODEL_PRICING[stripped]) return MODEL_PRICING[stripped];
+  const sortedKeys = Object.keys(MODEL_PRICING).sort((a, b) => b.length - a.length);
+  for (const key of sortedKeys) {
+    if (model.includes(key)) return MODEL_PRICING[key];
+  }
+  return DEFAULT_PRICING;
+}
+async function getAgentSpend(period = "7d") {
+  const cached = _spendCache.get(period);
+  if (cached && Date.now() < cached.expires) {
+    return cached.result;
+  }
+  const inFlight = _spendInFlight.get(period);
+  if (inFlight) return inFlight;
+  const promise = computeAgentSpend(period).finally(() => _spendInFlight.delete(period));
+  _spendInFlight.set(period, promise);
+  return promise;
+}
+async function computeAgentSpend(period) {
+  const cutoff = periodToCutoff(period);
+  const client = getClient();
+  const dbResult = await client.execute({
+    sql: `SELECT session_uuid, agent_id FROM session_agent_map WHERE started_at >= ?`,
+    args: [cutoff]
+  });
+  if (dbResult.rows.length === 0) return [];
+  const sessionAgent = /* @__PURE__ */ new Map();
+  for (const row of dbResult.rows) {
+    sessionAgent.set(row.session_uuid, row.agent_id);
+  }
+  const jsonlPaths = await getClaudeSessionJsonlIndex();
+  if (jsonlPaths.size === 0) return [];
+  const agentTotals = /* @__PURE__ */ new Map();
+  let processed = 0;
+  for (const [sessionUuid, agentId] of sessionAgent) {
+    const jsonlPath = jsonlPaths.get(sessionUuid);
+    if (!jsonlPath) continue;
+    try {
+      const usage = await extractSessionUsageCached(jsonlPath);
+      if (usage.input === 0 && usage.output === 0) continue;
+      const totals = agentTotals.get(agentId) ?? {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheCreate: 0,
+        costUSD: 0,
+        sessions: /* @__PURE__ */ new Set()
+      };
+      totals.input += usage.input;
+      totals.output += usage.output;
+      totals.cacheRead += usage.cacheRead;
+      totals.cacheCreate += usage.cacheCreate;
+      totals.costUSD += usage.costUSD;
+      totals.sessions.add(sessionUuid);
+      agentTotals.set(agentId, totals);
+    } catch {
+    }
+    processed++;
+    if (processed % 25 === 0) await yieldToEventLoop();
+  }
+  const result = Array.from(agentTotals.entries()).map(([agentId, t]) => ({
+    agentId,
+    inputTokens: t.input,
+    outputTokens: t.output,
+    cacheReadTokens: t.cacheRead,
+    cacheCreationTokens: t.cacheCreate,
+    costUSD: t.costUSD,
+    sessions: t.sessions.size,
+    period
+  })).sort((a, b) => b.costUSD - a.costUSD);
+  _spendCache.set(period, { result, expires: Date.now() + CACHE_TTL_MS });
+  return result;
+}
+async function getClaudeSessionJsonlIndex() {
+  if (_jsonlPathIndex && Date.now() < _jsonlPathIndex.expires) {
+    return _jsonlPathIndex.paths;
+  }
+  const claudeDir = path.join(os.homedir(), ".claude", "projects");
+  const paths = /* @__PURE__ */ new Map();
+  let projectDirs = [];
+  try {
+    const entries = await readdir(claudeDir, { withFileTypes: true });
+    projectDirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path.join(claudeDir, entry.name));
+  } catch {
+    _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+    return paths;
+  }
+  let scanned = 0;
+  for (const dir of projectDirs) {
+    try {
+      const files = await readdir(dir);
+      for (const file of files) {
+        if (!file.endsWith(".jsonl")) continue;
+        paths.set(file.slice(0, -".jsonl".length), path.join(dir, file));
+      }
+    } catch {
+    }
+    scanned++;
+    if (scanned % 25 === 0) await yieldToEventLoop();
+  }
+  _jsonlPathIndex = { expires: Date.now() + JSONL_INDEX_TTL_MS, paths };
+  return paths;
+}
+async function extractSessionUsageCached(jsonlPath) {
+  const st = await stat(jsonlPath);
+  const cached = _usageCache.get(jsonlPath);
+  if (cached && cached.mtimeMs === st.mtimeMs && cached.size === st.size) {
+    return cached.usage;
+  }
+  const existing = _usageInFlight.get(jsonlPath);
+  if (existing) return existing;
+  const promise = extractSessionUsage(jsonlPath).then((usage) => {
+    _usageCache.set(jsonlPath, { mtimeMs: st.mtimeMs, size: st.size, usage });
+    pruneUsageCache();
+    return usage;
+  }).finally(() => _usageInFlight.delete(jsonlPath));
+  _usageInFlight.set(jsonlPath, promise);
+  return promise;
+}
+function pruneUsageCache() {
+  if (_usageCache.size <= USAGE_CACHE_MAX_ENTRIES) return;
+  const overflow = _usageCache.size - USAGE_CACHE_MAX_ENTRIES;
+  let removed = 0;
+  for (const key of _usageCache.keys()) {
+    _usageCache.delete(key);
+    removed++;
+    if (removed >= overflow) break;
+  }
+}
+async function extractSessionUsage(jsonlPath) {
+  let input = 0;
+  let output = 0;
+  let cacheRead = 0;
+  let cacheCreate = 0;
+  let costUSD = 0;
+  const seenMessageIds = /* @__PURE__ */ new Set();
+  const rl = createInterface({
+    input: createReadStream(jsonlPath, { encoding: "utf8" }),
+    crlfDelay: Infinity
+  });
+  for await (const line of rl) {
+    if (!line.includes('"type":"assistant"')) continue;
+    try {
+      const record = JSON.parse(line);
+      if (record.type !== "assistant") continue;
+      const messageId = record.message?.id;
+      if (messageId) {
+        if (seenMessageIds.has(messageId)) continue;
+        seenMessageIds.add(messageId);
+      }
+      const usage = record.message?.usage;
+      if (!usage) continue;
+      const model = record.message?.model ?? "";
+      const pricing = getPricing(model);
+      const inp = usage.input_tokens ?? 0;
+      const out = usage.output_tokens ?? 0;
+      const cr = usage.cache_read_input_tokens ?? 0;
+      const cc = usage.cache_creation_input_tokens ?? 0;
+      input += inp;
+      output += out;
+      cacheRead += cr;
+      cacheCreate += cc;
+      if (pricing) {
+        costUSD += inp * pricing.input + out * pricing.output + cr * pricing.cacheRead + cc * pricing.cacheWrite;
+      }
+    } catch {
+    }
+  }
+  return { input, output, cacheRead, cacheCreate, costUSD };
+}
+function periodToCutoff(period) {
+  const ms = { "24h": 864e5, "7d": 6048e5, "30d": 2592e6 }[period];
+  return new Date(Date.now() - ms).toISOString();
+}
+
+export {
+  getAgentSpend
+};