@goondocks/myco 0.2.6 → 0.2.8

package/dist/cli-K5FSKLQC.js

@@ -0,0 +1,625 @@
+#!/usr/bin/env node
+import { createRequire as __cr } from 'node:module'; const require = __cr(import.meta.url);
+import {
+  DEFAULT_LOG_TAIL,
+  matchesFilter,
+  queryLogs
+} from "./chunk-TH6GIBXG.js";
+import {
+  LEVEL_ORDER,
+  VectorIndex,
+  createEmbeddingProvider,
+  generateEmbedding,
+  initFts,
+  rebuildIndex,
+  searchFts
+} from "./chunk-AOMX45LH.js";
+import {
+  MycoIndex
+} from "./chunk-PA3VMINE.js";
+import {
+  loadConfig,
+  require_dist
+} from "./chunk-UIIZRTJU.js";
+import {
+  resolveVaultDir
+} from "./chunk-N33KUCFP.js";
+import {
+  AgentRegistry
+} from "./chunk-TWDS6MSU.js";
+import {
+  EMBEDDING_INPUT_LIMIT
+} from "./chunk-NYNEJ5QY.js";
+import {
+  __toESM
+} from "./chunk-PZUWP5VK.js";
+
+// src/cli.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// src/logs/format.ts
+var LOG_VALUE_MAX_DISPLAY = 80;
+var CORE_FIELDS = ["timestamp", "level", "component", "message"];
+function formatLogLine(entry) {
+  const time = formatLocalTime(entry.timestamp);
+  const lvl = entry.level.toUpperCase().padEnd(5);
+  const comp = `[${entry.component}]`.padEnd(14);
+  const extras = [];
+  for (const [key, value] of Object.entries(entry)) {
+    if (CORE_FIELDS.includes(key)) continue;
+    const str = String(value);
+    const display = str.length > LOG_VALUE_MAX_DISPLAY ? str.slice(0, LOG_VALUE_MAX_DISPLAY) + "..." : str;
+    extras.push(`${key}=${display}`);
+  }
+  const extraStr = extras.length > 0 ? "  " + extras.join(" ") : "";
+  return `${time} ${lvl} ${comp} ${entry.message}${extraStr}`;
+}
+function formatLocalTime(iso) {
+  const d = new Date(iso);
+  const hh = String(d.getHours()).padStart(2, "0");
+  const mm = String(d.getMinutes()).padStart(2, "0");
+  const ss = String(d.getSeconds()).padStart(2, "0");
+  return `${hh}:${mm}:${ss}`;
+}
+function parseIntFlag(args, long, short) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === long || short && args[i] === short) {
+      const val = parseInt(args[i + 1], 10);
+      return isNaN(val) ? void 0 : val;
+    }
+  }
+  return void 0;
+}
+function parseStringFlag(args, long, short) {
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === long || short && args[i] === short) {
+      return args[i + 1];
+    }
+  }
+  return void 0;
+}
+
+// src/cli.ts
+var import_yaml = __toESM(require_dist(), 1);
+function loadEnv() {
+  const envPath = path.resolve(process.cwd(), ".env");
+  if (!fs.existsSync(envPath)) return;
+  for (const line of fs.readFileSync(envPath, "utf-8").split("\n")) {
+    const match = line.match(/^\s*([^#=]+?)\s*=\s*(.*?)\s*$/);
+    if (match && !process.env[match[1]]) {
+      process.env[match[1]] = match[2];
+    }
+  }
+}
+loadEnv();
+var USAGE = `Usage: myco <command> [args]
+
+Commands:
+  init [options]         Initialize a new vault
+  stats                  Vault health, index counts, vector count
+  search <query>         Combined FTS + vector search with scores
+  vectors <query>        Raw vector search with similarity scores
+  session [id|latest]    Show a session note
+  logs [options]         View daemon logs (--tail N, --follow, --level, --component)
+  restart                Restart the daemon with current code
+  rebuild                Reindex the entire vault
+
+Init options:
+  --vault <path>              Vault directory (default: .myco/ in project root)
+  --llm-provider <name>       LLM provider: ollama, lm-studio, anthropic
+  --llm-model <name>          LLM model name (e.g., gpt-oss)
+  --llm-url <url>             LLM base URL (default per provider)
+  --embedding-provider <name> Embedding provider: ollama, lm-studio
+  --embedding-model <name>    Embedding model name (e.g., bge-m3)
+  --embedding-url <url>       Embedding base URL (default per provider)
+  --user <name>               Team username
+  --team                      Enable team mode
+`;
+async function main() {
+  const [cmd, ...args] = process.argv.slice(2);
+  if (!cmd || cmd === "--help" || cmd === "-h") {
+    process.stdout.write(USAGE);
+    return;
+  }
+  if (cmd === "init") return initVault(args);
+  const vaultDir = resolveVaultDir();
+  if (!fs.existsSync(path.join(vaultDir, "myco.yaml"))) {
+    console.error(`No myco.yaml found in ${vaultDir}. Run 'myco init' first.`);
+    process.exit(1);
+  }
+  switch (cmd) {
+    case "stats":
+      return stats(vaultDir);
+    case "search":
+      return search(vaultDir, args.join(" "));
+    case "vectors":
+      return vectors(vaultDir, args.join(" "));
+    case "session":
+      return session(vaultDir, args[0]);
+    case "restart":
+      return restart(vaultDir);
+    case "rebuild":
+      return rebuild(vaultDir);
+    case "logs":
+      return logs(vaultDir, args);
+    default:
+      console.error(`Unknown command: ${cmd}`);
+      process.stdout.write(USAGE);
+      process.exit(1);
+  }
+}
+function stats(vaultDir) {
+  const index = new MycoIndex(path.join(vaultDir, "index.db"));
+  const sessions = index.query({ type: "session" });
+  const memories = index.query({ type: "memory" });
+  const plans = index.query({ type: "plan" });
+  console.log("=== Myco Vault ===");
+  console.log(`Path: ${vaultDir}`);
+  console.log();
+  console.log("--- Index ---");
+  console.log(`Sessions:  ${sessions.length}`);
+  console.log(`Memories:  ${memories.length}`);
+  console.log(`Plans:     ${plans.length}`);
+  const types = {};
+  for (const m of memories) {
+    const t = m.frontmatter?.observation_type || "unknown";
+    types[t] = (types[t] || 0) + 1;
+  }
+  if (Object.keys(types).length > 0) {
+    console.log("\n--- Memories by Type ---");
+    for (const [t, c] of Object.entries(types).sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${t}: ${c}`);
+    }
+  }
+  const vecDb = path.join(vaultDir, "vectors.db");
+  if (fs.existsSync(vecDb)) {
+    try {
+      const vec = new VectorIndex(vecDb, 1024);
+      console.log(`
+--- Vectors ---`);
+      console.log(`Embeddings: ${vec.count()}`);
+      vec.close();
+    } catch (e) {
+      console.log(`
+Vectors: error \u2014 ${e.message}`);
+    }
+  } else {
+    console.log("\nVectors: not initialized");
+  }
+  const daemonPath = path.join(vaultDir, "daemon.json");
+  if (fs.existsSync(daemonPath)) {
+    try {
+      const daemon = JSON.parse(fs.readFileSync(daemonPath, "utf-8"));
+      const alive = isProcessAlive(daemon.pid);
+      console.log(`
+--- Daemon ---`);
+      console.log(`PID:      ${daemon.pid} (${alive ? "running" : "dead"})`);
+      console.log(`Port:     ${daemon.port}`);
+      console.log(`Started:  ${daemon.started}`);
+      console.log(`Sessions: ${(daemon.sessions || []).length}`);
+    } catch {
+    }
+  }
+  index.close();
+}
+async function search(vaultDir, query) {
+  if (!query) {
+    console.error("Usage: myco search <query>");
+    process.exit(1);
+  }
+  const index = new MycoIndex(path.join(vaultDir, "index.db"));
+  const vecDb = path.join(vaultDir, "vectors.db");
+  if (fs.existsSync(vecDb)) {
+    try {
+      const config = loadConfig(vaultDir);
+      const embeddingProvider = createEmbeddingProvider(config.intelligence.embedding);
+      const emb = await generateEmbedding(embeddingProvider, query);
+      const vec = new VectorIndex(vecDb, emb.dimensions);
+      console.log(`=== Semantic Search: "${query}" ===`);
+      const results = vec.search(emb.embedding, { limit: 10 });
+      if (results.length === 0) {
+        console.log("  (no results)");
+      } else {
+        const noteMap = new Map(
+          index.queryByIds(results.map((r) => r.id)).map((n) => [n.id, n])
+        );
+        for (const r of results) {
+          const title = noteMap.get(r.id)?.title || r.id;
+          console.log(`  sim: ${r.similarity.toFixed(3)} | [${r.metadata.type}] ${title.slice(0, 60)}`);
+        }
+      }
+      vec.close();
+    } catch (e) {
+      console.log(`Semantic search unavailable: ${e.message}`);
+    }
+  }
+  console.log(`
+=== FTS Search: "${query}" ===`);
+  const ftsResults = searchFts(index, query, { limit: 10 });
+  if (ftsResults.length === 0) {
+    console.log("  (no results)");
+  } else {
+    for (const r of ftsResults) {
+      console.log(`  [${r.type}] ${r.title?.slice(0, 70)}`);
+      if (r.snippet) console.log(`    ${r.snippet.slice(0, 100)}`);
+    }
+  }
+  index.close();
+}
+async function vectors(vaultDir, query) {
+  if (!query) {
+    console.error("Usage: myco vectors <query>");
+    process.exit(1);
+  }
+  const config = loadConfig(vaultDir);
+  const embeddingProvider = createEmbeddingProvider(config.intelligence.embedding);
+  const emb = await generateEmbedding(embeddingProvider, query);
+  const vecDb = path.join(vaultDir, "vectors.db");
+  if (!fs.existsSync(vecDb)) {
+    console.error("No vector index found");
+    process.exit(1);
+  }
+  const vec = new VectorIndex(vecDb, emb.dimensions);
+  const index = new MycoIndex(path.join(vaultDir, "index.db"));
+  const results = vec.search(emb.embedding, { limit: 20, relativeThreshold: 0 });
+  console.log(`Query: "${query}"`);
+  console.log(`Dimensions: ${emb.dimensions}`);
+  console.log(`Total vectors: ${vec.count()}`);
+  console.log();
+  if (results.length === 0) {
+    console.log("(no results)");
+  } else {
+    const noteMap = new Map(
+      index.queryByIds(results.map((r) => r.id)).map((n) => [n.id, n])
+    );
+    const topScore = results[0].similarity;
+    console.log(`Top score: ${topScore.toFixed(4)}`);
+    console.log(`Default threshold (0.5x): ${(topScore * 0.5).toFixed(4)}`);
+    console.log();
+    console.log("  Sim     Ratio  Type       ID / Title");
+    console.log("  ------  -----  ---------  " + "-".repeat(50));
+    for (const r of results) {
+      const title = noteMap.get(r.id)?.title || r.id;
+      const ratio = (r.similarity / topScore).toFixed(2);
+      const pass = r.similarity >= topScore * 0.5 ? "\u2713" : " ";
+      console.log(`${pass} ${r.similarity.toFixed(4)}  ${ratio}   ${r.metadata.type.padEnd(9)}  ${title.slice(0, 50)}`);
+    }
+  }
+  vec.close();
+  index.close();
+}
+function session(vaultDir, idOrLatest) {
+  const index = new MycoIndex(path.join(vaultDir, "index.db"));
+  const sessions = index.query({ type: "session" });
+  if (sessions.length === 0) {
+    console.log("No sessions found");
+    index.close();
+    return;
+  }
+  let target;
+  if (!idOrLatest || idOrLatest === "latest") {
+    target = sessions[sessions.length - 1];
+  } else {
+    target = sessions.find((s) => s.id.includes(idOrLatest));
+  }
+  if (!target) {
+    console.error(`Session not found: ${idOrLatest}`);
+    console.log("Available:", sessions.map((s) => s.id).join(", "));
+    index.close();
+    return;
+  }
+  const fullPath = path.join(vaultDir, target.path);
+  if (fs.existsSync(fullPath)) {
+    console.log(fs.readFileSync(fullPath, "utf-8"));
+  } else {
+    console.log(`Title: ${target.title}`);
+    console.log(`Content:
+${target.content?.slice(0, 2e3)}`);
+  }
+  index.close();
+}
+async function restart(vaultDir) {
+  const daemonPath = path.join(vaultDir, "daemon.json");
+  if (fs.existsSync(daemonPath)) {
+    try {
+      const daemon = JSON.parse(fs.readFileSync(daemonPath, "utf-8"));
+      if (isProcessAlive(daemon.pid)) {
+        process.kill(daemon.pid, "SIGTERM");
+        console.log(`Stopped daemon (pid ${daemon.pid})`);
+      } else {
+        console.log(`Daemon pid ${daemon.pid} was already dead`);
+      }
+    } catch {
+    }
+    try {
+      fs.unlinkSync(daemonPath);
+    } catch {
+    }
+  }
+  const { DaemonClient } = await import("./client-4JMOYNKK.js");
+  const client = new DaemonClient(vaultDir);
+  console.log("Waiting for health check...");
+  const healthy = await client.ensureRunning();
+  if (healthy) {
+    try {
+      const info = JSON.parse(fs.readFileSync(daemonPath, "utf-8"));
+      console.log(`Daemon healthy on port ${info.port}`);
+    } catch {
+      console.log("Daemon healthy");
+    }
+  } else {
+    console.error("Daemon failed to become healthy");
+  }
+}
+async function rebuild(vaultDir) {
+  console.log(`Rebuilding index for ${vaultDir}...`);
+  const index = new MycoIndex(path.join(vaultDir, "index.db"));
+  initFts(index);
+  const count = rebuildIndex(index, vaultDir);
+  console.log(`Indexed ${count} notes (FTS)`);
+  const vecDb = path.join(vaultDir, "vectors.db");
+  try {
+    const config = loadConfig(vaultDir);
+    const embeddingProvider = createEmbeddingProvider(config.intelligence.embedding);
+    const testEmbed = await embeddingProvider.embed("test");
+    const vec = new VectorIndex(vecDb, testEmbed.dimensions);
+    const allNotes = index.query({});
+    const activeNotes = allNotes.filter((n) => {
+      const status = n.frontmatter?.status;
+      return status !== "superseded" && status !== "archived";
+    });
+    let embedded = 0;
+    for (const note of activeNotes) {
+      const text = `${note.title}
+${note.content}`.slice(0, EMBEDDING_INPUT_LIMIT);
+      try {
+        const emb = await generateEmbedding(embeddingProvider, text);
+        vec.upsert(note.id, emb.embedding, {
+          type: note.type,
+          session_id: note.frontmatter?.session ?? ""
+        });
+        embedded++;
+        process.stdout.write(`\rEmbedded ${embedded}/${activeNotes.length}`);
+      } catch (e) {
+        console.error(`
+Failed to embed ${note.id}: ${e.message}`);
+      }
+    }
+    console.log(`
+Embedded ${embedded} notes (vectors)
+Skipped ${allNotes.length - activeNotes.length} superseded/archived`);
+    vec.close();
+  } catch (e) {
+    console.log(`Vector rebuild skipped: ${e.message}`);
+  }
+  index.close();
+}
+var FOLLOW_POLL_INTERVAL_MS = 500;
+function logs(vaultDir, args) {
+  const logDir = path.join(vaultDir, "logs");
+  const follow = args.includes("--follow") || args.includes("-f");
+  const limit = parseIntFlag(args, "--tail", "-n") ?? DEFAULT_LOG_TAIL;
+  const rawLevel = parseStringFlag(args, "--level", "-l");
+  if (rawLevel && !(rawLevel in LEVEL_ORDER)) {
+    console.error(`Invalid level: ${rawLevel}. Valid levels: ${Object.keys(LEVEL_ORDER).join(", ")}`);
+    process.exit(1);
+  }
+  const level = rawLevel;
+  const component = parseStringFlag(args, "--component", "-c");
+  const since = parseStringFlag(args, "--since");
+  const until = parseStringFlag(args, "--until");
+  const result = queryLogs(logDir, { limit, level, component, since, until });
+  for (const e of result.entries) {
+    process.stdout.write(formatLogLine(e) + "\n");
+  }
+  if (result.truncated) {
+    process.stdout.write(`  ... ${result.total - result.entries.length} earlier entries omitted
+`);
+  }
+  if (!follow) return;
+  const followFilter = { level, component, until };
+  const logPath = path.join(logDir, "daemon.log");
+  let offset = 0;
+  try {
+    offset = fs.statSync(logPath).size;
+  } catch {
+  }
+  fs.watchFile(logPath, { interval: FOLLOW_POLL_INTERVAL_MS }, (curr, prev) => {
+    if (curr.size < prev.size || curr.ino !== prev.ino) {
+      offset = 0;
+    }
+    if (curr.size <= offset) return;
+    try {
+      const fd = fs.openSync(logPath, "r");
+      const buf = Buffer.alloc(curr.size - offset);
+      fs.readSync(fd, buf, 0, buf.length, offset);
+      fs.closeSync(fd);
+      const text = buf.toString("utf-8");
+      const lastNewline = text.lastIndexOf("\n");
+      if (lastNewline < 0) return;
+      offset += Buffer.byteLength(text.slice(0, lastNewline + 1));
+      for (const line of text.slice(0, lastNewline).split("\n")) {
+        if (!line.trim()) continue;
+        try {
+          const e = JSON.parse(line);
+          if (!matchesFilter(e, followFilter)) continue;
+          process.stdout.write(formatLogLine(e) + "\n");
+        } catch {
+        }
+      }
+    } catch {
+    }
+  });
+  process.on("SIGINT", () => {
+    fs.unwatchFile(logPath);
+    process.exit(0);
+  });
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var PROVIDER_DEFAULTS = {
+  ollama: { base_url: "http://localhost:11434" },
+  "lm-studio": { base_url: "http://localhost:1234" }
+};
+var DASHBOARD_CONTENT = `# Myco Vault
+
+## Active Plans
+\`\`\`dataview
+TABLE status, tags FROM #type/plan
+WHERE status = "active" OR status = "in_progress"
+SORT created DESC
+\`\`\`
+
+## Recent Sessions
+\`\`\`dataview
+TABLE user, started, tools_used FROM #type/session
+SORT started DESC LIMIT 10
+\`\`\`
+
+## Recent Memories
+\`\`\`dataview
+TABLE observation_type AS "Type", created FROM #type/memory
+SORT created DESC LIMIT 15
+\`\`\`
+
+## Memories by Type
+\`\`\`dataview
+TABLE WITHOUT ID observation_type AS "Type", length(rows) AS "Count"
+FROM #type/memory GROUP BY observation_type
+SORT length(rows) DESC
+\`\`\`
+
+## Gotchas
+\`\`\`dataview
+LIST FROM #memory/gotcha SORT created DESC LIMIT 10
+\`\`\`
+`;
+var VAULT_GITIGNORE = `# Runtime \u2014 rebuilt on daemon startup
+index.db
+index.db-wal
+index.db-shm
+vectors.db
+
+# Daemon state \u2014 per-machine, ephemeral
+daemon.json
+buffer/
+logs/
+
+# Obsidian \u2014 per-user workspace config
+.obsidian/
+`;
+function configureVaultEnv(projectRoot, vaultDir) {
+  const registry = new AgentRegistry();
+  const active = registry.detectActiveAgent();
+  if (active) {
+    if (active.configureVaultEnv(projectRoot, vaultDir)) {
+      console.log(`Set MYCO_VAULT_DIR for ${active.displayName}`);
+    }
+  } else {
+    for (const name of registry.adapterNames) {
+      const adapter = registry.getAdapter(name);
+      if (adapter?.configureVaultEnv(projectRoot, vaultDir)) {
+        console.log(`Set MYCO_VAULT_DIR for ${adapter.displayName}`);
+      }
+    }
+  }
+  console.log(`
+For other agents, add to your shell profile:`);
+  console.log(`  export MYCO_VAULT_DIR="${vaultDir}"
+`);
+}
+async function initVault(args) {
+  const vaultPath = parseStringFlag(args, "--vault");
+  const llmProvider = parseStringFlag(args, "--llm-provider") ?? "ollama";
+  const llmModel = parseStringFlag(args, "--llm-model") ?? "gpt-oss";
+  const llmUrl = parseStringFlag(args, "--llm-url") ?? PROVIDER_DEFAULTS[llmProvider]?.base_url;
+  const embeddingProvider = parseStringFlag(args, "--embedding-provider") ?? "ollama";
+  const embeddingModel = parseStringFlag(args, "--embedding-model") ?? "bge-m3";
+  const embeddingUrl = parseStringFlag(args, "--embedding-url") ?? PROVIDER_DEFAULTS[embeddingProvider]?.base_url;
+  const user = parseStringFlag(args, "--user") ?? "";
+  const teamEnabled = args.includes("--team");
+  const vaultDir = vaultPath ? vaultPath.startsWith("~/") ? path.join(os.homedir(), vaultPath.slice(2)) : path.resolve(vaultPath) : path.join(resolveVaultDir());
+  if (fs.existsSync(path.join(vaultDir, "myco.yaml"))) {
+    console.log(`Vault already initialized at ${vaultDir}`);
+    return;
+  }
+  console.log(`Initializing Myco vault at ${vaultDir}`);
+  const dirs = ["sessions", "plans", "memories", "artifacts", "team", "buffer", "logs"];
+  for (const dir of dirs) {
+    fs.mkdirSync(path.join(vaultDir, dir), { recursive: true });
+  }
+  const config = {
+    version: 2,
+    intelligence: {
+      llm: {
+        provider: llmProvider,
+        model: llmModel,
+        ...llmUrl ? { base_url: llmUrl } : {},
+        context_window: 8192,
+        max_tokens: 1024
+      },
+      embedding: {
+        provider: embeddingProvider,
+        model: embeddingModel,
+        ...embeddingUrl ? { base_url: embeddingUrl } : {}
+      }
+    },
+    daemon: {
+      log_level: "info",
+      grace_period: 30,
+      max_log_size: 5242880
+    },
+    capture: {
+      transcript_paths: [],
+      artifact_watch: [".claude/plans/", ".cursor/plans/"],
+      artifact_extensions: [".md"],
+      buffer_max_events: 500
+    },
+    context: {
+      max_tokens: 1200,
+      layers: { plans: 200, sessions: 500, memories: 300, team: 200 }
+    },
+    team: {
+      enabled: teamEnabled,
+      user,
+      sync: "git"
+    }
+  };
+  fs.writeFileSync(
+    path.join(vaultDir, "myco.yaml"),
+    import_yaml.default.stringify(config),
+    "utf-8"
+  );
+  fs.writeFileSync(path.join(vaultDir, ".gitignore"), VAULT_GITIGNORE, "utf-8");
+  fs.writeFileSync(path.join(vaultDir, "_dashboard.md"), DASHBOARD_CONTENT, "utf-8");
+  const index = new MycoIndex(path.join(vaultDir, "index.db"));
+  initFts(index);
+  index.close();
+  console.log("");
+  console.log("=== Myco Vault Initialized ===");
+  console.log(`Path:               ${vaultDir}`);
+  console.log(`LLM provider:       ${llmProvider} / ${llmModel}`);
+  console.log(`Embedding provider: ${embeddingProvider} / ${embeddingModel}`);
+  console.log(`Team mode:          ${teamEnabled ? "enabled" : "disabled"}`);
+  if (user) console.log(`User:               ${user}`);
+  console.log("");
+  const projectRoot = path.resolve(".");
+  const isProjectLocal = vaultDir.startsWith(projectRoot);
+  if (!isProjectLocal) {
+    configureVaultEnv(projectRoot, vaultDir);
+  }
+  console.log("Next: start a coding session \u2014 Myco will begin capturing automatically.");
+}
+main().catch((err) => {
+  console.error(`myco: ${err.message}`);
+  process.exit(1);
+});
+//# sourceMappingURL=cli-K5FSKLQC.js.map