@hiveai/cli 0.4.5 → 0.5.0

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command32 } from "commander";
+import { Command as Command35 } from "commander";
 
 // src/commands/briefing.ts
 import { existsSync } from "fs";
@@ -341,6 +341,33 @@ function registerIndexCode(program2) {
       `Indexed ${fileCount} file(s) with ${exportCount} export(s) \u2192 ${path2.relative(root, codeMapPath(paths))}`
     );
   });
+  idx.command("code-search").description(
+    "Build the semantic-search embeddings index for code (powers the code_search MCP tool).\n\n  Reads .ai/code-map.json (run `haive index code` first) and embeds each exported\n  symbol's metadata (filename + name + kind + description).\n\n  Re-runs are incremental: unchanged entries keep their cached vectors, only the\n  diff is re-embedded. First run downloads the bge-small-en-v1.5 model (~110MB).\n"
+  ).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot4(opts.dir);
+    const paths = resolveHaivePaths3(root);
+    let mod;
+    try {
+      mod = await import("@hiveai/embeddings");
+    } catch {
+      ui.error(
+        "@hiveai/embeddings is not installed. Install it (`pnpm add @hiveai/embeddings`) or run `haive embeddings install`."
+      );
+      process.exit(1);
+    }
+    ui.info("Loading embedder (first run downloads ~110MB)\u2026");
+    const embedder = await mod.Embedder.create();
+    ui.info(`Embedding code-map symbols\u2026`);
+    try {
+      const { report } = await mod.rebuildCodeIndex(paths, embedder);
+      ui.success(
+        `Code-search index ready: ${report.total} symbols (+${report.added} new, ~${report.updated} updated, =${report.unchanged} cached, -${report.removed} removed)`
+      );
+    } catch (err) {
+      ui.error(err instanceof Error ? err.message : String(err));
+      process.exit(1);
+    }
+  });
 }
 
 // src/commands/init.ts
@@ -3344,9 +3371,294 @@ Next steps:
   });
 }
 
+// src/commands/stats.ts
+import "commander";
+import {
+  aggregateUsage,
+  findProjectRoot as findProjectRoot32,
+  parseSince,
+  readUsageEvents,
+  resolveHaivePaths as resolveHaivePaths29,
+  usageLogSize
+} from "@hiveai/core";
+function registerStats(program2) {
+  program2.command("stats").description("Show MCP tool-usage stats over a window (e.g. --since 7d).").option("--since <window>", "ISO date or relative (e.g. '7d', '24h', '30m')", "30d").option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot32(opts.dir);
+    const paths = resolveHaivePaths29(root);
+    const size = await usageLogSize(paths);
+    if (!size.exists) {
+      if (opts.json) {
+        console.log(JSON.stringify({ error: "no_usage_log" }));
+        return;
+      }
+      ui.warn(
+        `No usage log found at ${root}. Stats are populated as the MCP server logs each tool call. Run a session first, then re-check.`
+      );
+      return;
+    }
+    const events = await readUsageEvents(paths);
+    const since = parseSince(opts.since);
+    const aggregate = aggregateUsage(events, since ?? void 0);
+    if (opts.json) {
+      console.log(JSON.stringify(aggregate, null, 2));
+      return;
+    }
+    const window = opts.since ?? "all time";
+    console.log(ui.bold(`hAIve usage stats (${window})`));
+    console.log(
+      `  ${ui.dim("total calls:")} ${aggregate.total}  ${ui.dim("unique tools:")} ${aggregate.by_tool.length}  ${ui.dim("log lines:")} ${size.lines}`
+    );
+    if (aggregate.window_start) {
+      console.log(
+        `  ${ui.dim("window:")} ${aggregate.window_start.slice(0, 19)} \u2192 ${aggregate.window_end?.slice(0, 19)}`
+      );
+    }
+    if (aggregate.by_tool.length === 0) {
+      ui.info(`No events in window. Try a wider --since (current: ${window}).`);
+      return;
+    }
+    console.log();
+    console.log(ui.bold("Top tools:"));
+    const maxCount = aggregate.by_tool[0]?.count ?? 1;
+    for (const t of aggregate.by_tool.slice(0, 20)) {
+      const bar = "\u2588".repeat(Math.max(1, Math.round(t.count / maxCount * 30)));
+      const pct = (t.count / aggregate.total * 100).toFixed(1);
+      console.log(
+        `  ${t.tool.padEnd(28)} ${ui.green(bar)} ${ui.bold(String(t.count))} ${ui.dim(`(${pct}%, last ${t.last_used.slice(0, 19)})`)}`
+      );
+    }
+  });
+}
+
+// src/commands/bench.ts
+import { performance } from "perf_hooks";
+import "commander";
+import {
+  estimateTokens,
+  findProjectRoot as findProjectRoot33,
+  resolveHaivePaths as resolveHaivePaths30
+} from "@hiveai/core";
+import {
+  antiPatternsCheck,
+  codeMapTool,
+  codeSearch,
+  getBriefing,
+  getRecap,
+  memRelevantTo
+} from "@hiveai/mcp";
+function registerBench(program2) {
+  program2.command("bench").description("Self-test the local hAIve setup: runs core MCP tools against this project and reports latency + payload size.").option("-t, --task <task>", "task description for ranking-aware tools", "audit dependencies for security risks").option("--json", "emit JSON instead of a table", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot33(opts.dir);
+    const paths = resolveHaivePaths30(root);
+    const ctx = { paths };
+    const task = opts.task ?? "audit dependencies for security risks";
+    const scenarios = [
+      async () => {
+        const t0 = performance.now();
+        const out = await getBriefing(
+          {
+            task,
+            files: [],
+            max_tokens: 4e3,
+            max_memories: 8,
+            include_project_context: true,
+            include_module_contexts: true,
+            semantic: true,
+            include_stale: false,
+            track: false,
+            format: "compact",
+            symbols: [],
+            min_semantic_score: 0
+          },
+          ctx
+        );
+        return summarize("get_briefing(compact)", t0, out, [
+          out.low_value ? "low_value (cold-start)" : `${out.memories.length} memories`,
+          `search=${out.search_mode}`
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await codeMapTool({ paths: [], max_files: 40, max_tokens: 2e3 }, ctx);
+        return summarize("code_map(budget=2k)", t0, out, [
+          out.available ? `${out.files.length}/${out.total_files} files` : "unavailable",
+          out.budget_clipped ? "clipped" : "fits"
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await getRecap({ scope: "any" }, ctx);
+        return summarize("get_recap", t0, out, [
+          out.recap ? `${out.recap.id.slice(0, 30)}\u2026` : "no recap"
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await memRelevantTo(
+          { task, files: [], limit: 8, min_semantic_score: 0.25, format: "compact" },
+          ctx
+        );
+        return summarize("mem_relevant_to", t0, out, [
+          `${out.memories.length} memories`,
+          `search=${out.search_mode}`
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await codeSearch({ query: task, k: 5, min_score: 0.2 }, ctx);
+        return summarize("code_search", t0, out, [
+          out.available ? `${out.hits.length} hits` : "needs index (haive index code-search)"
+        ]);
+      },
+      async () => {
+        const t0 = performance.now();
+        const out = await antiPatternsCheck({ diff: task, paths: [], limit: 5, semantic: true }, ctx);
+        return summarize("anti_patterns_check", t0, out, [
+          `${out.warnings.length}/${out.scanned} warn`
+        ]);
+      }
+    ];
+    const results = [];
+    for (const run of scenarios) {
+      try {
+        results.push(await run());
+      } catch (err) {
+        results.push({
+          name: "(error)",
+          ok: false,
+          latency_ms: 0,
+          payload_tokens: 0,
+          notes: [err instanceof Error ? err.message : String(err)]
+        });
+      }
+    }
+    if (opts.json) {
+      console.log(JSON.stringify({ root, task, scenarios: results }, null, 2));
+      return;
+    }
+    console.log(ui.bold(`hAIve bench \u2014 ${root}`));
+    console.log(ui.dim(`task: ${task}`));
+    console.log();
+    console.log(
+      `${"scenario".padEnd(28)} ${"latency".padStart(8)}  ${"tokens".padStart(7)}  notes`
+    );
+    console.log("\u2500".repeat(88));
+    for (const r of results) {
+      const status = r.ok ? ui.green("\u2713") : ui.red("\u2717");
+      console.log(
+        `${status} ${r.name.padEnd(26)} ${`${r.latency_ms.toFixed(0)} ms`.padStart(8)}  ${String(r.payload_tokens).padStart(7)}  ${r.notes.join("; ")}`
+      );
+    }
+    const totalTokens = results.reduce((s, r) => s + r.payload_tokens, 0);
+    const totalMs = results.reduce((s, r) => s + r.latency_ms, 0);
+    console.log("\u2500".repeat(88));
+    console.log(
+      `${ui.dim("totals:")}                       ${`${totalMs.toFixed(0)} ms`.padStart(8)}  ${String(totalTokens).padStart(7)}`
+    );
+  });
+}
+function summarize(name, t0, payload, notes) {
+  return {
+    name,
+    ok: true,
+    latency_ms: performance.now() - t0,
+    payload_tokens: estimateTokens(JSON.stringify(payload)),
+    notes
+  };
+}
+
+// src/commands/memory-suggest.ts
+import "commander";
+import {
+  aggregateUsage as aggregateUsage2,
+  findProjectRoot as findProjectRoot34,
+  parseSince as parseSince2,
+  readUsageEvents as readUsageEvents2,
+  resolveHaivePaths as resolveHaivePaths31
+} from "@hiveai/core";
+var SEARCH_TOOLS = /* @__PURE__ */ new Set([
+  "mem_search",
+  "code_search",
+  "mem_relevant_to",
+  "get_briefing"
+]);
+function registerMemorySuggest(memory2) {
+  memory2.command("suggest").description("Suggest memories to create based on recurring search queries in the usage log.").option("--since <window>", "ISO date or relative (e.g. '7d', '24h')", "30d").option("--min <count>", "minimum repeat count to surface a query", "2").option("--json", "emit JSON instead of human-readable output", false).option("-d, --dir <dir>", "project root").action(async (opts) => {
+    const root = findProjectRoot34(opts.dir);
+    const paths = resolveHaivePaths31(root);
+    const events = await readUsageEvents2(paths);
+    if (events.length === 0) {
+      if (opts.json) {
+        console.log(JSON.stringify({ suggestions: [] }));
+        return;
+      }
+      ui.warn("No usage log entries yet. Suggestions appear after the MCP server records some calls.");
+      return;
+    }
+    const since = parseSince2(opts.since);
+    const minCount = Math.max(1, parseInt(opts.min ?? "2", 10));
+    const cutoff = since ? since.getTime() : 0;
+    const queries = /* @__PURE__ */ new Map();
+    for (const e of events) {
+      if (cutoff && Date.parse(e.at) < cutoff) continue;
+      if (!SEARCH_TOOLS.has(e.tool)) continue;
+      const key = (e.summary ?? "").toLowerCase().trim();
+      if (!key) continue;
+      const prior = queries.get(key);
+      if (prior) {
+        prior.count++;
+        prior.tools.add(e.tool);
+        if (e.at > prior.last) prior.last = e.at;
+      } else {
+        queries.set(key, { count: 1, tools: /* @__PURE__ */ new Set([e.tool]), last: e.at });
+      }
+    }
+    const suggestions = [...queries.entries()].filter(([, v]) => v.count >= minCount).map(([query, v]) => ({
+      query,
+      count: v.count,
+      tools: [...v.tools].sort(),
+      last_used: v.last,
+      reason: chooseReason(v.tools, v.count)
+    })).sort((a, b) => b.count - a.count);
+    if (opts.json) {
+      console.log(JSON.stringify({ window: opts.since, suggestions }, null, 2));
+      return;
+    }
+    const totals = aggregateUsage2(events, since ?? void 0);
+    console.log(ui.bold(`hAIve memory suggestions (${opts.since ?? "all time"})`));
+    console.log(
+      ui.dim(`scanned ${totals.total} events, ${suggestions.length} repeated queries (\u2265${minCount})`)
+    );
+    console.log();
+    if (suggestions.length === 0) {
+      ui.info("No recurring searches yet \u2014 nothing to suggest.");
+      return;
+    }
+    for (const s of suggestions.slice(0, 30)) {
+      console.log(
+        `  ${ui.bold(`\xD7${s.count}`)} ${ui.dim(`[${s.tools.join(",")}]`)}  ${truncate(s.query, 70)}`
+      );
+      console.log(`     ${ui.dim("\u2192")} ${s.reason}`);
+    }
+  });
+}
+function chooseReason(tools, count) {
+  if (tools.has("code_search")) {
+    return `${count} agents searched the code for this \u2014 consider mem_save (architecture/decision) capturing where it lives.`;
+  }
+  if (tools.has("mem_search") || tools.has("mem_relevant_to")) {
+    return `${count} agents asked but the memory layer had no clear answer \u2014 consider mem_save (convention/decision/gotcha).`;
+  }
+  return `${count} agents asked the briefing for this \u2014 consider promoting the answer to a team memory.`;
+}
+function truncate(text, max) {
+  if (text.length <= max) return text;
+  return text.slice(0, max - 1) + "\u2026";
+}
+
 // src/index.ts
-var program = new Command32();
-program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.4.5");
+var program = new Command35();
+program.name("haive").description("hAIve \u2014 team-first persistent memory layer for AI coding agents").version("0.5.0");
 registerInit(program);
 registerMcp(program);
 registerBriefing(program);
@@ -3376,10 +3688,13 @@ registerMemoryTried(memory);
 registerMemoryImport(memory);
 registerMemoryImportChangelog(memory);
 registerMemoryDigest(memory);
+registerMemorySuggest(memory);
 var session = program.command("session").description("Manage session lifecycle");
 registerSessionEnd(session);
 registerSnapshot(program);
 registerHub(program);
+registerStats(program);
+registerBench(program);
 program.parseAsync(process.argv).catch((err) => {
   if (isZodError(err)) {
     for (const issue of err.issues) {