memorix 1.4.5 → 1.5.0

package/src/cli/commands/purge.ts

@@ -0,0 +1,120 @@
+/**
+ * CLI Command: memorix purge
+ *
+ * Retire memories from retrieval. Project-scoped by default; --all covers
+ * every project. Observations and long-term records are archived (never
+ * hard-deleted) so the audit trail survives. Refuses to run outside a
+ * terminal without --yes.
+ */
+
+import { defineCommand } from 'citty';
+import { detectProject } from '../../project/detector.js';
+import { getProjectDataDir } from '../../store/persistence.js';
+
+export default defineCommand({
+  meta: {
+    name: 'purge',
+    description: 'Retire memories from retrieval (current project by default, --all for every project)',
+  },
+  args: {
+    all: {
+      type: 'boolean',
+      description: 'Purge every project instead of the current one',
+      default: false,
+    },
+    yes: {
+      type: 'boolean',
+      description: 'Skip the interactive confirmation',
+      default: false,
+    },
+    json: {
+      type: 'boolean',
+      description: 'Emit a machine-readable result',
+      default: false,
+    },
+  },
+  async run({ args }) {
+    const purgeAll = Boolean(args.all);
+    const yes = Boolean(args.yes);
+    const asJson = Boolean(args.json);
+
+    // Confirmation gate first: a destructive wipe never proceeds in a
+    // non-interactive shell without an explicit --yes.
+    if (!yes && !process.stdin.isTTY) {
+      console.error('[ERROR] Non-interactive environment. Add --yes to confirm.');
+      console.error('[ERROR] Refusing to purge memories without confirmation.');
+      process.exitCode = 1;
+      return;
+    }
+    if (!yes) {
+      const readline = await import('node:readline');
+      const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+      const question = purgeAll
+        ? 'Retire ALL memories from every project? (y/N) '
+        : 'Retire all memories for this project? (y/N) ';
+      const answer = await new Promise<string>((resolve) => rl.question(question, resolve));
+      rl.close();
+      if (answer.trim().toLowerCase() !== 'y') {
+        console.log('Cancelled.');
+        return;
+      }
+    }
+
+    let projectId: string | null = null;
+    if (!purgeAll) {
+      const project = detectProject();
+      if (!project) {
+        console.error('[ERROR] No .git found — run from a project directory or pass --all.');
+        process.exitCode = 1;
+        return;
+      }
+      projectId = project.id;
+    }
+
+    const dataDir = await getProjectDataDir(projectId ?? '');
+    const { initObservationStore } = await import('../../store/obs-store.js');
+    const { getAllObservations, resolveObservations } = await import('../../memory/observations.js');
+    const { withFreshIndex } = await import('../../memory/freshness.js');
+    await initObservationStore(dataDir);
+
+    const observations = await withFreshIndex(() => getAllObservations());
+    const target = purgeAll ? observations : observations.filter((o) => o.projectId === projectId);
+    const ids = target
+      .map((o) => o.id)
+      .filter((id): id is number => typeof id === 'number');
+    const archived = ids.length > 0
+      ? (await resolveObservations(ids, 'archived')).resolved.length
+      : 0;
+
+    const { LongTermMemoryStore } = await import('../../memory/long-term-store.js');
+    const { archiveLongTermMemory } = await import('../../memory/long-term.js');
+    const longTermStore = new LongTermMemoryStore();
+    await longTermStore.init(dataDir);
+    let longTermArchived = 0;
+    for (const memory of longTermStore.list()) {
+      if (memory.state === 'archived' || memory.state === 'superseded') continue;
+      if (!purgeAll && memory.originProjectId !== projectId) continue;
+      try {
+        await archiveLongTermMemory({
+          dataDir,
+          id: memory.id,
+          reason: purgeAll ? 'purge --all' : 'purge (project) ' + (projectId ?? ''),
+        });
+        longTermArchived += 1;
+      } catch { /* already inactive */ }
+    }
+
+    const result = {
+      scope: purgeAll ? 'all' : projectId,
+      observationsArchived: archived,
+      longTermArchived,
+    };
+    if (asJson) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log(
+        `[OK] Purged ${purgeAll ? 'all projects' : result.scope}: archived ${archived} observations and ${longTermArchived} long-term memories.`,
+      );
+    }
+  },
+});

package/src/cli/commands/serve-http.ts

@@ -39,6 +39,36 @@ export function parseSessionTimeoutMs(raw: string | undefined): number {
   return Math.floor(parsed);
 }
 
+export interface ServeHttpConfiguredDefaults {
+  port?: number;
+  transport?: 'stdio' | 'http';
+  dashboard?: boolean;
+  dashboardPort?: number;
+}
+
+/**
+ * The [server] config section is a real default source, not display-only:
+ * `port` becomes the listener default and an explicit `transport: "stdio"`
+ * produces a notice (an explicit serve-http command still wins). CLI flags
+ * always beat config.
+ */
+export function resolveServeHttpDefaults(
+  argsPort: string | undefined,
+  configured: ServeHttpConfiguredDefaults,
+): { port: number; transportNotice?: string } {
+  const configuredPort = typeof configured.port === 'number' && Number.isFinite(configured.port)
+    ? configured.port
+    : undefined;
+  const port = parseTcpPortOrReport(argsPort, configuredPort ?? 3211);
+  if (port === undefined) {
+    return { port: 3211 };
+  }
+  const transportNotice = configured.transport === 'stdio'
+    ? '[memorix] config server.transport = "stdio"; serve-http continues on HTTP (the explicit command wins).'
+    : undefined;
+  return { port, transportNotice };
+}
+
 export default defineCommand({
   meta: {
     name: 'serve-http',
@@ -81,11 +111,15 @@ export default defineCommand({
     const { writeFileSync, mkdirSync } = await import('node:fs');
     const { homedir } = await import('node:os');
 
-    const port = parseTcpPortOrReport(args.port, 3211);
-    if (port === undefined) {
-      process.exitCode = 1;
-      return;
-    }
+    // The [server] config section feeds startup defaults; CLI flags win.
+    let configuredDefaults: ServeHttpConfiguredDefaults = {};
+    try {
+      const { getServerConfig } = await import('../../config.js');
+      configuredDefaults = getServerConfig();
+    } catch { /* config files are optional */ }
+    const resolved = resolveServeHttpDefaults(args.port as string | undefined, configuredDefaults);
+    if (resolved.transportNotice) console.error(resolved.transportNotice);
+    const port = resolved.port;
     const host = args.host || '127.0.0.1';
     const toolProfile = resolveToolProfile({ explicit: args.mode, envValue: process.env.MEMORIX_MODE, fallback: 'team' });
 

package/src/cli/commands/setup.ts

@@ -422,7 +422,9 @@ export function buildMemorixServer(mcp: Exclude<SetupMcpTransport, 'none'>): MCP
   return {
     name: 'memorix',
     command: 'memorix',
-    args: ['serve'],
+    // The installed surface must expose every tool the generated guidance
+    // teaches. lite covers the full taught set; micro would hide half of it.
+    args: ['serve', '--mode', 'lite'],
   };
 }