@chendpoc/pi-memory 0.1.13 → 0.2.1

package/src/cli.ts

@@ -1,399 +1,105 @@
 #!/usr/bin/env node
-import fs from "node:fs";
-import path from "node:path";
 
-import { createStandaloneLLMClient } from "./adapters/piComplete.js";
-import { installBundle } from "./bundle/install.js";
-import type { MemoryConfig } from "./config.js";
-import { getMemoryIndexStats } from "./consolidation/memoryIndex.js";
-import { readRecentConsolidationLogs } from "./consolidation/log.js";
-import { getConsolidationStatus } from "./consolidation/enqueue.js";
+import { createLlmClient } from "./adapters/llm/index.js";
+import { resolveAgentDirFromEnv } from "./config/agentDir.js";
+import { loadEnv } from "./config/loadEnv.js";
 import {
-  defaultConsolidationDbPath,
-  runConsolidate,
-} from "./consolidation/scheduler/runConsolidate.js";
-import { setupSchedule } from "./consolidation/scheduler/setupSchedule.js";
-import type { SchedulePlatform } from "./consolidation/scheduler/types.js";
-import { loadMemoryConfig } from "./settings.js";
-import { openSessionIndex } from "./fallback/sessionIndex.js";
-import { SidecarClient } from "./sidecar/client.js";
-import { MemoryService } from "./service.js";
-import { trainBundle } from "./trainer/index.js";
-import { createLLMFactExtractor } from "./trainer/llmExtractor.js";
-import { createTrainScheduler } from "./trainer/scheduler.js";
-import type { QueryIntent } from "./types.js";
-
-async function tryReloadSidecar(cfg: MemoryConfig): Promise<void> {
-  try {
-    fs.accessSync(cfg.socketPath, fs.constants.F_OK);
-  } catch {
-    return;
-  }
-  const client = new SidecarClient(cfg.socketPath, cfg.clientRequestTimeoutMs);
-  try {
-    await client.reload();
-  } catch {
-    /* sidecar not running — install still succeeded */
-  }
-}
-
-async function main(): Promise<void> {
-  const [cmd, ...rest] = process.argv.slice(2);
-  if (!cmd || cmd === "help" || cmd === "--help") {
-    printHelp();
-    process.exit(0);
-  }
-
-  const cfg = loadMemoryConfig();
-  const service = new MemoryService(cfg);
-
-  if (cmd === "health") {
-    await service.start();
-    const h = await service.health();
-    console.log(JSON.stringify({ status: service.getStatus(), health: h }, null, 2));
-    await service.stop();
-    return;
-  }
-
-  if (cmd === "query") {
-    const json = rest.join(" ").trim();
-    if (!json) {
-      console.error('Usage: pi-memory query \'{"anchor_mentions":["Alice"],"mode":"direct_relation"}\'');
-      process.exit(1);
-    }
-    let intent: QueryIntent;
-    try {
-      intent = JSON.parse(json) as QueryIntent;
-    } catch (e) {
-      console.error("Invalid JSON intent:", e);
-      process.exit(1);
+  runConsolidateCommand,
+  runDrainShutdownQueueCommand,
+  runMaintenanceCommand,
+} from "./cli/jobs.js";
+import { createCliLog } from "./cli/log.js";
+import { CLI_HELP, parseCliArgs } from "./cli/parseArgs.js";
+import { runInitCommand } from "./cli/init.js";
+import { runStatusCommand } from "./cli/status.js";
+import { theme } from "./cli/theme.js";
+import { createMemoryStore } from "./store/index.js";
+
+async function main(): Promise<number> {
+  loadEnv();
+
+  const parsed = parseCliArgs(process.argv.slice(2));
+  if (parsed.command === "help") {
+    if (parsed.error) {
+      console.error(theme.error(parsed.error));
     }
-    await service.start();
-    const result = await service.query(intent);
-    console.log(JSON.stringify(result, null, 2));
-    await service.stop();
-    return;
-  }
-
-  if (cmd === "status") {
-    await service.start();
-    console.log(JSON.stringify(service.getStatus(), null, 2));
-    await service.stop();
-    return;
-  }
-
-  if (cmd === "memory-status") {
-    const dbPath = defaultConsolidationDbPath(cfg);
-    const status = getConsolidationStatus(dbPath);
-    const memoryIndex = getMemoryIndexStats(cfg.memoryMdPaths, {
-      maxLines: cfg.consolidation.memory_index_max_lines,
-      maxBytes: cfg.consolidation.memory_index_max_bytes,
-    });
-    const recentLogs = await readRecentConsolidationLogs(
-      cfg.consolidation.schedule.log_path,
-      5,
-    );
-    const schedule = await readScheduleStatus(cfg);
-    console.log(JSON.stringify({
-      db_path: dbPath,
-      queue: status,
-      memory_index: memoryIndex,
-      schedule,
-      recent_logs: recentLogs,
-    }, null, 2));
-    return;
+    console.log(CLI_HELP);
+    return parsed.error ? 1 : 0;
   }
 
-  if (cmd === "consolidate") {
-    const flags = parseConsolidateFlags(rest);
-    const result = await runConsolidate({
-      config: cfg,
-      dryRun: flags.dryRun,
-      phase1Only: flags.phase1Only,
-      phase2Only: flags.phase2Only,
-    });
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
+  const agentDir = resolveAgentDirFromEnv(
+    "options" in parsed ? parsed.options.agentDir : undefined,
+  );
 
-  if (cmd === "setup-schedule") {
-    const flags = parseScheduleFlags(rest);
-    const platform = resolveSchedulePlatform();
-    const result = await setupSchedule({
-      hour: flags.hour ?? cfg.consolidation.schedule.hour,
-      minute: flags.minute ?? cfg.consolidation.schedule.minute,
-      logPath: cfg.consolidation.schedule.log_path,
-      dryRun: flags.dryRun,
-      remove: flags.remove,
-      status: flags.status,
-    }, platform);
-    console.log(JSON.stringify(result, null, 2));
-    return;
+  if (parsed.command === "init") {
+    const log = createCliLog({ verbose: true, debug: parsed.options.verbose });
+    return runInitCommand(agentDir, log);
   }
 
-  if (cmd === "install-bundle") {
-    const bundlePath = rest[0];
-    if (!bundlePath) {
-      console.error("Usage: pi-memory install-bundle <path-to-bundle-dir>");
-      process.exit(1);
-    }
-    const result = await installBundle({
-      bundleRoot: cfg.bundleRoot,
-      sourceDir: bundlePath,
-    });
-    await tryReloadSidecar(cfg);
-    console.log(JSON.stringify(result, null, 2));
-    return;
+  if (parsed.command === "status") {
+    const log = createCliLog({ verbose: true, debug: parsed.options.verbose });
+    return runStatusCommand(agentDir, log);
   }
 
-  if (cmd === "train") {
-    const flags = parseTrainFlags(rest);
-    let extractOpts;
-    if (flags.extractor === "llm") {
-      try {
-        const client = createStandaloneLLMClient(flags.model);
-        extractOpts = {
-          llmExtractor: createLLMFactExtractor({
-            client,
-            batchSize: cfg.trainer.llm_batch_size,
-          }),
-        };
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        console.error(`LLM extractor unavailable (${message}) — falling back to regex.`);
-        extractOpts = undefined;
-      }
-    }
+  const store = createMemoryStore({ agentDir });
+  await store.ensureInitialized();
 
-    const result = await trainBundle({
-      sessionsDir: flags.sessionsDir ?? cfg.sessionsDir,
-      bundleRoot: cfg.bundleRoot,
-      full: flags.full,
-      dryRun: flags.dryRun,
-      noMerge: flags.noMerge,
-      extractOpts,
-    });
-    if (result.sessionsProcessed === 0) {
-      console.log("No new sessions to process.");
-    } else {
-      const output: Record<string, unknown> = {
-        sessions_processed: result.sessionsProcessed,
-        entities: result.entityCount,
-        relations: result.relationCount,
-        events: result.eventCount,
-        dry_run: result.dryRun,
-        bundle_dir: result.bundleResult?.bundleDir ?? null,
-        installed: result.installResult?.installed_dir ?? null,
-      };
-      if (result.delta) {
-        output.delta = {
-          added: result.delta.added,
-          updated: result.delta.updated,
-          deleted: result.delta.deleted,
-          skipped: result.delta.skipped,
-        };
-      }
-      console.log(JSON.stringify(output, null, 2));
-      if (!result.dryRun) {
-        await tryReloadSidecar(cfg);
-      }
-    }
+  const llm = await createLlmClient();
 
-    if (flags.watch) {
-      const interval = cfg.trainer.auto_interval ?? "1h";
-      console.log(`Watching for new sessions (interval: ${interval})...`);
-      createTrainScheduler(
-        { interval, trainConfig: { sessionsDir: flags.sessionsDir ?? cfg.sessionsDir, bundleRoot: cfg.bundleRoot } },
-        (log) => {
-          console.log(JSON.stringify({ type: "scheduled_run", ...log }));
-        },
+  if (parsed.command === "maintenance") {
+    const log = createCliLog({ verbose: parsed.options.verbose });
+    if (parsed.options.verbose && !llm) {
+      log.warn(
+        "no helper LLM configured; consolidate uses rule-based dedupe; shutdown drain skips LLM extract",
       );
-      await new Promise(() => {}); // block forever
-    }
-    return;
-  }
-
-  if (cmd === "index") {
-    const sessionsDir = rest.find((a, i) => rest[i - 1] === "--sessions-dir") ?? cfg.sessionsDir;
-    const dbPath = path.join(cfg.bundleRoot, "sessions.db");
-    const idx = openSessionIndex(dbPath);
-    if (!idx) {
-      console.error("Failed to open SQLite — is better-sqlite3 installed?");
-      process.exit(1);
     }
-    console.log(`Rebuilding FTS5 index at ${dbPath}...`);
-    const { indexed } = await idx.rebuildIndex(sessionsDir);
-    idx.close();
-    console.log(JSON.stringify({ indexed, db_path: dbPath }));
-    return;
+    return runMaintenanceCommand({
+      store,
+      agentDir,
+      llm,
+      options: parsed.options,
+      log,
+    });
   }
 
-  console.error(`Unknown command: ${cmd}`);
-  printHelp();
-  process.exit(1);
-}
-
-function parseTrainFlags(args: string[]): {
-  sessionsDir?: string;
-  full: boolean;
-  dryRun: boolean;
-  noMerge: boolean;
-  extractor: "regex" | "llm";
-  watch: boolean;
-  model?: string;
-} {
-  let sessionsDir: string | undefined;
-  let full = false;
-  let dryRun = false;
-  let noMerge = false;
-  let extractor: "regex" | "llm" = "regex";
-  let watch = false;
-  let model: string | undefined;
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]!;
-    if (arg === "--full") { full = true; continue; }
-    if (arg === "--dry-run") { dryRun = true; continue; }
-    if (arg === "--no-merge") { noMerge = true; continue; }
-    if (arg === "--watch") { watch = true; continue; }
-    if (arg === "--model" && i + 1 < args.length) {
-      model = args[++i];
-      continue;
-    }
-    if (arg === "--sessions-dir" && i + 1 < args.length) {
-      sessionsDir = args[++i];
-      continue;
-    }
-    if (arg === "--extractor" && i + 1 < args.length) {
-      const val = args[++i]!;
-      if (val === "llm" || val === "regex") extractor = val;
-      continue;
+  if (parsed.command === "drain-shutdown-queue") {
+    const log = createCliLog({ verbose: parsed.options.verbose });
+    if (parsed.options.verbose && !llm) {
+      log.warn("no helper LLM configured; shutdown drain skips sessions without compaction export");
     }
+    return runDrainShutdownQueueCommand({
+      store,
+      agentDir,
+      llm,
+      verbose: parsed.options.verbose,
+      log,
+    });
   }
-  return { sessionsDir, full, dryRun, noMerge, extractor, watch, model };
-}
 
-function parseConsolidateFlags(args: string[]): {
-  dryRun: boolean;
-  phase1Only: boolean;
-  phase2Only: boolean;
-} {
-  return {
-    dryRun: args.includes("--dry-run"),
-    phase1Only: args.includes("--phase1-only"),
-    phase2Only: args.includes("--phase2-only"),
-  };
-}
-
-function parseScheduleFlags(args: string[]): {
-  hour?: number;
-  minute?: number;
-  dryRun: boolean;
-  remove: boolean;
-  status: boolean;
-} {
-  let hour: number | undefined;
-  let minute: number | undefined;
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i]!;
-    if (arg === "--hour" && i + 1 < args.length) {
-      hour = Number(args[++i]);
-      continue;
-    }
-    if (arg === "--minute" && i + 1 < args.length) {
-      minute = Number(args[++i]);
-      continue;
+  if (parsed.command === "consolidate") {
+    const log = createCliLog({ verbose: parsed.options.verbose });
+    if (parsed.options.verbose && !llm) {
+      log.warn("no helper LLM configured; using rule-based dedupe only");
     }
+    return runConsolidateCommand({
+      store,
+      agentDir,
+      llm,
+      cron: parsed.options.cron,
+      force: parsed.options.force,
+      verbose: parsed.options.verbose,
+      log,
+    });
   }
-  return {
-    hour,
-    minute,
-    dryRun: args.includes("--dry-run"),
-    remove: args.includes("--remove"),
-    status: args.includes("--status"),
-  };
-}
-
-function resolveSchedulePlatform(): SchedulePlatform {
-  if (process.platform === "darwin") return "darwin";
-  if (process.platform === "linux") return "linux";
-  throw new Error(`setup-schedule is not supported on ${process.platform}`);
-}
-
-function tryResolveSchedulePlatform(): SchedulePlatform | null {
-  if (process.platform === "darwin") return "darwin";
-  if (process.platform === "linux") return "linux";
-  return null;
-}
-
-async function readScheduleStatus(cfg: MemoryConfig) {
-  const platform = tryResolveSchedulePlatform();
-  if (!platform) {
-    return {
-      supported: false,
-      platform: process.platform,
-      files: [],
-    };
-  }
-  const result = await setupSchedule({
-    hour: cfg.consolidation.schedule.hour,
-    minute: cfg.consolidation.schedule.minute,
-    logPath: cfg.consolidation.schedule.log_path,
-    status: true,
-  }, platform);
-  return {
-    supported: true,
-    platform,
-    files: result.files,
-  };
-}
-
-function printHelp(): void {
-  console.log(`pi-memory — local TLM episodic memory (mode B)
-
-Commands:
-  health              Start sidecar (if bundle present) and print /health
-  status              Print MemoryService status snapshot
-  memory-status       Print consolidation queue, MEMORY.md cap, schedule status, and recent job logs
-  consolidate         Run offline memory consolidation
-    --dry-run         Report planned work without writing MEMORY.md/stage1
-    --phase1-only     Drain queue and train graph only
-    --phase2-only     Consume existing stage1 rows only
-  setup-schedule      Install/update the OS user scheduler
-    --hour            Local hour (default from memory.json consolidation.schedule.hour)
-    --minute          Local minute (default from memory.json consolidation.schedule.minute)
-    --dry-run         Print files that would be written
-    --remove          Remove scheduler files
-    --status          Report scheduler file existence
-  query               POST /query with JSON QueryIntent
-  install-bundle      Copy a local bundle dir into ~/.pi/memory/current
-  train               Build a bundle from session history (delta merge by default)
-    --sessions-dir    Override sessions directory (default from config)
-    --full            Ignore marker, rebuild from all sessions
-    --dry-run         Show extraction stats without writing bundle
-    --no-merge        Skip delta merge, full rebuild (ignore existing bundle)
-    --extractor       Extractor type: "regex" (default) or "llm"
-    --model           LLM model for --extractor llm (default: deepseek/deepseek-v4-flash)
-    --watch           Run once then schedule periodic re-training
-  index               Rebuild SQLite FTS5 session search index
-    --sessions-dir    Override sessions directory (default from config)
-
-Environment:
-  Place bundle at ~/.pi/memory/current/ (symlink to bundles/<ts>/)
-  Session fallback searches ~/.pi/sessions/*.json
-  Install tlm on PATH or set memory.tlmPath in Pi extension config
-  LLM extractor uses provider env vars (e.g. DEEPSEEK_API_KEY for deepseek/deepseek-v4-flash)
 
-Example:
-  pi-memory query '{"mode":"direct_relation","anchor_mentions":["Alice"]}'
-  pi-memory install-bundle ./my-bundle-2026-06-01T00-00-00Z
-  pi-memory train --full
-  pi-memory train --extractor llm
-  pi-memory train --watch
-  pi-memory index
-`);
+  return 1;
 }
 
-main().catch((err) => {
-  console.error(err);
-  process.exit(1);
-});
+main().then(
+  (code) => process.exit(code),
+  (error) => {
+    const log = createCliLog({ verbose: true });
+    log.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  },
+);

package/src/commands/index.ts

@@ -0,0 +1,20 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+import { createRememberCommand } from "./remember.js";
+import { createMemoryStatusCommand } from "./status.js";
+import type { CommandDeps } from "./types.js";
+
+export type { CommandDeps, MemoryStatusCommandDeps, RememberCommandDeps } from "./types.js";
+export { parseRememberArgs } from "./parseRememberArgs.js";
+
+export function registerCommands(pi: ExtensionAPI, deps: CommandDeps): void {
+  pi.registerCommand("remember", {
+    description: "Append a user-authored note to MEMORY.md",
+    handler: createRememberCommand(deps),
+  });
+
+  pi.registerCommand("memory-status", {
+    description: "Show MEMORY.md, sidecar, and vector index diagnostics (toggle expand/collapse; hide to dismiss)",
+    handler: createMemoryStatusCommand(deps),
+  });
+}

package/src/commands/parseMemoryStatusArgs.ts

@@ -0,0 +1,11 @@
+export type MemoryStatusAction = "toggle" | "refresh" | "hide" | "expand" | "collapse";
+
+export function parseMemoryStatusArgs(args: string | string[]): MemoryStatusAction {
+  const text = (Array.isArray(args) ? args.join(" ") : args).trim().toLowerCase();
+  if (!text) return "toggle";
+  if (text === "hide" || text === "close" || text === "off" || text === "dismiss") return "hide";
+  if (text === "refresh" || text === "reload") return "refresh";
+  if (text === "expand" || text === "open" || text === "show") return "expand";
+  if (text === "collapse" || text === "fold" || text === "min") return "collapse";
+  return "toggle";
+}

package/src/commands/parseRememberArgs.ts

@@ -0,0 +1,55 @@
+import { MEMORY_SECTIONS, type MemorySection } from "../store/types.js";
+
+const SECTION_ALIASES: Record<string, MemorySection> = {
+  preferences: "Preferences",
+  preference: "Preferences",
+  prefs: "Preferences",
+  pref: "Preferences",
+  conventions: "Conventions",
+  convention: "Conventions",
+  conv: "Conventions",
+  findings: "Findings",
+  finding: "Findings",
+  todos: "Todos",
+  todo: "Todos",
+};
+
+export type ParsedRememberArgs =
+  | { section: MemorySection; content: string }
+  | { error: string };
+
+function normalizeArgs(raw: string | string[]): string {
+  return (Array.isArray(raw) ? raw.join(" ") : raw).trim();
+}
+
+function matchSection(token: string): MemorySection | undefined {
+  const key = token.toLowerCase();
+  if (SECTION_ALIASES[key]) return SECTION_ALIASES[key];
+  return MEMORY_SECTIONS.find((section) => section.toLowerCase() === key);
+}
+
+/** Parse `/remember [section]? content`. Default section: Findings. */
+export function parseRememberArgs(raw: string | string[]): ParsedRememberArgs {
+  const text = normalizeArgs(raw);
+  if (!text) {
+    return {
+      error: "Usage: /remember [Preferences|Conventions|Findings|Todos] <content>",
+    };
+  }
+
+  const space = text.indexOf(" ");
+  const firstToken = space === -1 ? text : text.slice(0, space);
+  const section = matchSection(firstToken);
+
+  if (section) {
+    const content = space === -1 ? "" : text.slice(space + 1).trim();
+    if (!content) {
+      return {
+        error: `Usage: /remember ${section} <content>`,
+      };
+    }
+    return { section, content };
+  }
+
+  return { section: "Findings", content: text };
+}

package/src/commands/remember.ts

@@ -0,0 +1,43 @@
+import type { ExtensionCommandContext } from "@earendil-works/pi-coding-agent";
+
+import type { MemoryStore } from "../store/memoryStore.js";
+import { parseRememberArgs } from "./parseRememberArgs.js";
+
+export type RememberCommandDeps = {
+  getMemoryStore(): MemoryStore | null;
+  onRemembered?(): Promise<void>;
+};
+
+export function createRememberCommand(deps: RememberCommandDeps) {
+  return async (args: string | string[], ctx: ExtensionCommandContext): Promise<void> => {
+    const memoryStore = deps.getMemoryStore();
+    if (!memoryStore) {
+      ctx.ui.notify("pi-memory: not started", "warning");
+      return;
+    }
+
+    const parsed = parseRememberArgs(args);
+    if ("error" in parsed) {
+      ctx.ui.notify(parsed.error, "warning");
+      return;
+    }
+
+    try {
+      await memoryStore.ensureInitialized();
+      await memoryStore.appendUser({
+        id: "",
+        section: parsed.section,
+        content: parsed.content,
+        timestamp: "",
+      });
+      await deps.onRemembered?.();
+
+      ctx.ui.notify(`Saved to MEMORY.md (${parsed.section})`, "info");
+    } catch (error) {
+      ctx.ui.notify(
+        `Remember failed: ${error instanceof Error ? error.message : String(error)}`,
+        "warning",
+      );
+    }
+  };
+}