memorix 1.1.7 → 1.1.9

package/src/cli/commands/purge-all-memory.ts

@@ -1,85 +1,85 @@
-/**
- * CLI Command: memorix purge all-memory
- *
- * Delete ALL memories (dangerous operation).
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-
-export default defineCommand({
-  meta: {
-    name: 'all-memory',
-    description: 'Delete ALL memories (dangerous)',
-  },
-  args: {},
-  run: async ({}) => {
-    p.intro('[WARN]  Purge All Memory');
-
-    // Show warning
-    console.log('');
-    console.log('[WARN]  WARNING: This will delete ALL memories!');
-    console.log('');
-    console.log('This will remove:');
-    console.log('  - All observations from all projects');
-    console.log('  - All entities and relations');
-    console.log('  - All embeddings');
-    console.log('');
-    console.log('This action CANNOT be undone.');
-    console.log('');
-    console.log('Project artifacts (hook files) will be preserved.');
-    console.log('');
-
-    // First confirmation
-    const confirmed1 = await p.confirm({
-      message: 'Are you sure you want to delete ALL memories?',
-    });
-
-    if (p.isCancel(confirmed1) || !confirmed1) {
-      p.outro('Purge cancelled.');
-      return;
-    }
-
-    // Second confirmation (type "DELETE" to confirm)
-    const confirmed2 = await p.text({
-      message: 'Type "DELETE" to confirm:',
-      validate: (value) => {
-        if (value !== 'DELETE') {
-          return 'Please type "DELETE" to confirm';
-        }
-        return undefined;
-      },
-    });
-
-    if (p.isCancel(confirmed2) || confirmed2 !== 'DELETE') {
-      p.outro('Purge cancelled.');
-      return;
-    }
-
-    // Delete all memories
-    try {
-      const {
-        getAllObservations,
-        resolveObservations,
-      } = await import('../../memory/observations.js');
-      const { withFreshIndex } = await import('../../memory/freshness.js');
-      const observations = await withFreshIndex(() => getAllObservations());
-      const ids = observations.map((o) => o.id);
-
-      if (ids.length === 0) {
-        console.log('No observations found.');
-        p.outro('No memories to purge.');
-        return;
-      }
-
-      const result = await resolveObservations(ids, 'archived');
-
-      console.log(`[OK] Archived ${result.resolved.length} observations`);
-
-      p.outro(`All memory purged. ${result.resolved.length} observations archived.`);
-    } catch (err) {
-      console.error(`[ERROR] Failed to purge all memory: ${err}`);
-      p.outro('Purge failed.');
-    }
-  },
-});
+/**
+ * CLI Command: memorix purge all-memory
+ *
+ * Delete ALL memories (dangerous operation).
+ */
+
+import { defineCommand } from 'citty';
+import * as p from '@clack/prompts';
+
+export default defineCommand({
+  meta: {
+    name: 'all-memory',
+    description: 'Delete ALL memories (dangerous)',
+  },
+  args: {},
+  run: async ({}) => {
+    p.intro('[WARN]  Purge All Memory');
+
+    // Show warning
+    console.log('');
+    console.log('[WARN]  WARNING: This will delete ALL memories!');
+    console.log('');
+    console.log('This will remove:');
+    console.log('  - All observations from all projects');
+    console.log('  - All entities and relations');
+    console.log('  - All embeddings');
+    console.log('');
+    console.log('This action CANNOT be undone.');
+    console.log('');
+    console.log('Project artifacts (hook files) will be preserved.');
+    console.log('');
+
+    // First confirmation
+    const confirmed1 = await p.confirm({
+      message: 'Are you sure you want to delete ALL memories?',
+    });
+
+    if (p.isCancel(confirmed1) || !confirmed1) {
+      p.outro('Purge cancelled.');
+      return;
+    }
+
+    // Second confirmation (type "DELETE" to confirm)
+    const confirmed2 = await p.text({
+      message: 'Type "DELETE" to confirm:',
+      validate: (value) => {
+        if (value !== 'DELETE') {
+          return 'Please type "DELETE" to confirm';
+        }
+        return undefined;
+      },
+    });
+
+    if (p.isCancel(confirmed2) || confirmed2 !== 'DELETE') {
+      p.outro('Purge cancelled.');
+      return;
+    }
+
+    // Delete all memories
+    try {
+      const {
+        getAllObservations,
+        resolveObservations,
+      } = await import('../../memory/observations.js');
+      const { withFreshIndex } = await import('../../memory/freshness.js');
+      const observations = await withFreshIndex(() => getAllObservations());
+      const ids = observations.map((o) => o.id);
+
+      if (ids.length === 0) {
+        console.log('No observations found.');
+        p.outro('No memories to purge.');
+        return;
+      }
+
+      const result = await resolveObservations(ids, 'archived');
+
+      console.log(`[OK] Archived ${result.resolved.length} observations`);
+
+      p.outro(`All memory purged. ${result.resolved.length} observations archived.`);
+    } catch (err) {
+      console.error(`[ERROR] Failed to purge all memory: ${err}`);
+      p.outro('Purge failed.');
+    }
+  },
+});

package/src/cli/commands/purge-project-memory.ts

@@ -1,83 +1,83 @@
-/**
- * CLI Command: memorix purge project-memory
- *
- * Delete memories for the current project only.
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-
-export default defineCommand({
-  meta: {
-    name: 'project-memory',
-    description: 'Delete memories for current project',
-  },
-  args: {},
-  run: async ({}) => {
-    const os = await import('node:os');
-    let cwd: string;
-    try { cwd = process.cwd(); } catch { cwd = os.homedir(); }
-
-    p.intro('Purge Project Memory');
-
-    // Show what will be deleted
-    console.log('');
-    console.log('Will delete memories for:');
-    console.log(`  Project: ${cwd}`);
-    console.log('');
-    console.log('This will remove all observations, entities, and relations');
-    console.log('associated with this project from the memory database.');
-    console.log('');
-    console.log('Project artifacts (hook files) will be preserved.');
-    console.log('');
-
-    // Confirm
-    const confirmed = await p.confirm({
-      message: 'Continue purge?',
-    });
-
-    if (p.isCancel(confirmed) || !confirmed) {
-      p.outro('Purge cancelled.');
-      return;
-    }
-
-    // Get project ID
-    const projectId = getProjectId(cwd);
-
-    // Delete project memories
-    try {
-      const {
-        getProjectObservations,
-        resolveObservations,
-      } = await import('../../memory/observations.js');
-      const { withFreshIndex } = await import('../../memory/freshness.js');
-      const observations = await withFreshIndex(() => getProjectObservations(projectId));
-      const ids = observations.map((o) => o.id);
-
-      if (ids.length === 0) {
-        console.log('No observations found for this project.');
-        p.outro('No memories to purge.');
-        return;
-      }
-
-      const result = await resolveObservations(ids, 'archived');
-
-      console.log(`[OK] Archived ${result.resolved.length} observations for project`);
-
-      p.outro(`Project memory purged. ${result.resolved.length} observations archived.`);
-    } catch (err) {
-      console.error(`[ERROR] Failed to purge project memory: ${err}`);
-      p.outro('Purge failed.');
-    }
-  },
-});
-
-function getProjectId(projectRoot: string): string {
-  try {
-    const { detectProject } = require('../project/detector.js');
-    const project = detectProject(projectRoot);
-    if (project) return project.id;
-  } catch { /* fallback below */ }
-  const normalized = projectRoot.replace(/\\/g, '/');
-  return `untracked/${normalized}`;
-}
+/**
+ * CLI Command: memorix purge project-memory
+ *
+ * Delete memories for the current project only.
+ */
+
+import { defineCommand } from 'citty';
+import * as p from '@clack/prompts';
+
+export default defineCommand({
+  meta: {
+    name: 'project-memory',
+    description: 'Delete memories for current project',
+  },
+  args: {},
+  run: async ({}) => {
+    const os = await import('node:os');
+    let cwd: string;
+    try { cwd = process.cwd(); } catch { cwd = os.homedir(); }
+
+    p.intro('Purge Project Memory');
+
+    // Show what will be deleted
+    console.log('');
+    console.log('Will delete memories for:');
+    console.log(`  Project: ${cwd}`);
+    console.log('');
+    console.log('This will remove all observations, entities, and relations');
+    console.log('associated with this project from the memory database.');
+    console.log('');
+    console.log('Project artifacts (hook files) will be preserved.');
+    console.log('');
+
+    // Confirm
+    const confirmed = await p.confirm({
+      message: 'Continue purge?',
+    });
+
+    if (p.isCancel(confirmed) || !confirmed) {
+      p.outro('Purge cancelled.');
+      return;
+    }
+
+    // Get project ID
+    const projectId = getProjectId(cwd);
+
+    // Delete project memories
+    try {
+      const {
+        getProjectObservations,
+        resolveObservations,
+      } = await import('../../memory/observations.js');
+      const { withFreshIndex } = await import('../../memory/freshness.js');
+      const observations = await withFreshIndex(() => getProjectObservations(projectId));
+      const ids = observations.map((o) => o.id);
+
+      if (ids.length === 0) {
+        console.log('No observations found for this project.');
+        p.outro('No memories to purge.');
+        return;
+      }
+
+      const result = await resolveObservations(ids, 'archived');
+
+      console.log(`[OK] Archived ${result.resolved.length} observations for project`);
+
+      p.outro(`Project memory purged. ${result.resolved.length} observations archived.`);
+    } catch (err) {
+      console.error(`[ERROR] Failed to purge project memory: ${err}`);
+      p.outro('Purge failed.');
+    }
+  },
+});
+
+function getProjectId(projectRoot: string): string {
+  try {
+    const { detectProject } = require('../project/detector.js');
+    const project = detectProject(projectRoot);
+    if (project) return project.id;
+  } catch { /* fallback below */ }
+  const normalized = projectRoot.replace(/\\/g, '/');
+  return `untracked/${normalized}`;
+}

package/src/cli/commands/reasoning.ts

@@ -1,132 +1,132 @@
-import { defineCommand } from 'citty';
-import { compactSearch } from '../../compact/engine.js';
-import { storeObservation } from '../../memory/observations.js';
-import { emitError, emitResult, getCliProjectContext, parseCsvList, parsePositiveInt } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'reasoning',
-    description: 'Store and search decision rationale from the operator CLI',
-  },
-  args: {
-    entity: { type: 'string', description: 'Entity this reasoning applies to' },
-    decision: { type: 'string', description: 'Decision that was made' },
-    rationale: { type: 'string', description: 'Why this approach was chosen' },
-    alternatives: { type: 'string', description: 'Comma-separated alternatives that were considered' },
-    constraints: { type: 'string', description: 'Comma-separated constraints' },
-    expectedOutcome: { type: 'string', description: 'Expected outcome from this decision' },
-    risks: { type: 'string', description: 'Comma-separated risks or downsides' },
-    concepts: { type: 'string', description: 'Comma-separated related concepts' },
-    files: { type: 'string', description: 'Comma-separated file list' },
-    relatedCommits: { type: 'string', description: 'Comma-separated related commit hashes' },
-    relatedEntities: { type: 'string', description: 'Comma-separated related entity names' },
-    query: { type: 'string', description: 'Search query for reasoning traces' },
-    limit: { type: 'string', description: 'Search result limit' },
-    scope: { type: 'string', description: 'project or global scope for search' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
-      const { project } = await getCliProjectContext({ searchIndex: action === 'search' });
-
-      switch (action) {
-        case 'store': {
-          const entityName = (args.entity as string | undefined)?.trim();
-          const decision = (args.decision as string | undefined)?.trim();
-          const rationale = (args.rationale as string | undefined)?.trim();
-          if (!entityName || !decision || !rationale) {
-            emitError('entity, decision, and rationale are required for "memorix reasoning store"', asJson);
-            return;
-          }
-
-          const alternatives = parseCsvList(args.alternatives as string | undefined);
-          const constraints = parseCsvList(args.constraints as string | undefined);
-          const risks = parseCsvList(args.risks as string | undefined);
-          const concepts = parseCsvList(args.concepts as string | undefined);
-          const filesModified = parseCsvList(args.files as string | undefined);
-          const relatedCommits = parseCsvList(args.relatedCommits as string | undefined);
-          const relatedEntities = parseCsvList(args.relatedEntities as string | undefined);
-
-          const narrativeParts: string[] = [rationale];
-          if (alternatives.length > 0) {
-            narrativeParts.push(`Alternatives considered: ${alternatives.join('; ')}`);
-          }
-          if (constraints.length > 0) {
-            narrativeParts.push(`Constraints: ${constraints.join('; ')}`);
-          }
-          if (args.expectedOutcome) {
-            narrativeParts.push(`Expected outcome: ${String(args.expectedOutcome).trim()}`);
-          }
-          if (risks.length > 0) {
-            narrativeParts.push(`Risks: ${risks.join('; ')}`);
-          }
-
-          const result = await storeObservation({
-            entityName,
-            type: 'reasoning',
-            title: decision,
-            narrative: narrativeParts.join('. '),
-            facts: [
-              `Decision: ${decision}`,
-              ...alternatives.map((item) => `Alternative: ${item}`),
-              ...constraints.map((item) => `Constraint: ${item}`),
-              ...(args.expectedOutcome ? [`Expected outcome: ${String(args.expectedOutcome).trim()}`] : []),
-              ...risks.map((item) => `Risk: ${item}`),
-              ...relatedCommits.map((item) => `Commit: ${item}`),
-              ...relatedEntities.map((item) => `Related entity: ${item}`),
-            ],
-            concepts,
-            filesModified,
-            relatedCommits,
-            relatedEntities,
-            projectId: project.id,
-            source: 'manual',
-          });
-
-          emitResult(
-            { project, observation: result.observation, upserted: result.upserted },
-            `${result.upserted ? 'Updated' : 'Stored'} reasoning trace #${result.observation.id}: ${decision}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'search': {
-          const query = (args.query as string | undefined)?.trim();
-          if (!query) {
-            emitError('query is required for "memorix reasoning search"', asJson);
-            return;
-          }
-          const scope = (args.scope as string | undefined) === 'global' ? 'global' : 'project';
-          const limit = parsePositiveInt(args.limit as string | undefined, 10);
-          const result = await compactSearch({
-            query,
-            limit,
-            type: 'reasoning',
-            projectId: scope === 'global' ? undefined : project.id,
-            status: 'active',
-          });
-          emitResult(
-            { project, scope, entries: result.entries },
-            result.entries.length === 0 ? 'No reasoning traces found.' : `[REASONING] Reasoning traces\n${result.formatted}`,
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Reasoning Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix reasoning store --entity auth --decision "Use SQLite" --rationale "..."');
-          console.log('  memorix reasoning search --query "why sqlite" [--scope project|global --limit 10]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
-
+import { defineCommand } from 'citty';
+import { compactSearch } from '../../compact/engine.js';
+import { storeObservation } from '../../memory/observations.js';
+import { emitError, emitResult, getCliProjectContext, parseCsvList, parsePositiveInt } from './operator-shared.js';
+
+export default defineCommand({
+  meta: {
+    name: 'reasoning',
+    description: 'Store and search decision rationale from the operator CLI',
+  },
+  args: {
+    entity: { type: 'string', description: 'Entity this reasoning applies to' },
+    decision: { type: 'string', description: 'Decision that was made' },
+    rationale: { type: 'string', description: 'Why this approach was chosen' },
+    alternatives: { type: 'string', description: 'Comma-separated alternatives that were considered' },
+    constraints: { type: 'string', description: 'Comma-separated constraints' },
+    expectedOutcome: { type: 'string', description: 'Expected outcome from this decision' },
+    risks: { type: 'string', description: 'Comma-separated risks or downsides' },
+    concepts: { type: 'string', description: 'Comma-separated related concepts' },
+    files: { type: 'string', description: 'Comma-separated file list' },
+    relatedCommits: { type: 'string', description: 'Comma-separated related commit hashes' },
+    relatedEntities: { type: 'string', description: 'Comma-separated related entity names' },
+    query: { type: 'string', description: 'Search query for reasoning traces' },
+    limit: { type: 'string', description: 'Search result limit' },
+    scope: { type: 'string', description: 'project or global scope for search' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
+      const { project } = await getCliProjectContext({ searchIndex: action === 'search' });
+
+      switch (action) {
+        case 'store': {
+          const entityName = (args.entity as string | undefined)?.trim();
+          const decision = (args.decision as string | undefined)?.trim();
+          const rationale = (args.rationale as string | undefined)?.trim();
+          if (!entityName || !decision || !rationale) {
+            emitError('entity, decision, and rationale are required for "memorix reasoning store"', asJson);
+            return;
+          }
+
+          const alternatives = parseCsvList(args.alternatives as string | undefined);
+          const constraints = parseCsvList(args.constraints as string | undefined);
+          const risks = parseCsvList(args.risks as string | undefined);
+          const concepts = parseCsvList(args.concepts as string | undefined);
+          const filesModified = parseCsvList(args.files as string | undefined);
+          const relatedCommits = parseCsvList(args.relatedCommits as string | undefined);
+          const relatedEntities = parseCsvList(args.relatedEntities as string | undefined);
+
+          const narrativeParts: string[] = [rationale];
+          if (alternatives.length > 0) {
+            narrativeParts.push(`Alternatives considered: ${alternatives.join('; ')}`);
+          }
+          if (constraints.length > 0) {
+            narrativeParts.push(`Constraints: ${constraints.join('; ')}`);
+          }
+          if (args.expectedOutcome) {
+            narrativeParts.push(`Expected outcome: ${String(args.expectedOutcome).trim()}`);
+          }
+          if (risks.length > 0) {
+            narrativeParts.push(`Risks: ${risks.join('; ')}`);
+          }
+
+          const result = await storeObservation({
+            entityName,
+            type: 'reasoning',
+            title: decision,
+            narrative: narrativeParts.join('. '),
+            facts: [
+              `Decision: ${decision}`,
+              ...alternatives.map((item) => `Alternative: ${item}`),
+              ...constraints.map((item) => `Constraint: ${item}`),
+              ...(args.expectedOutcome ? [`Expected outcome: ${String(args.expectedOutcome).trim()}`] : []),
+              ...risks.map((item) => `Risk: ${item}`),
+              ...relatedCommits.map((item) => `Commit: ${item}`),
+              ...relatedEntities.map((item) => `Related entity: ${item}`),
+            ],
+            concepts,
+            filesModified,
+            relatedCommits,
+            relatedEntities,
+            projectId: project.id,
+            source: 'manual',
+          });
+
+          emitResult(
+            { project, observation: result.observation, upserted: result.upserted },
+            `${result.upserted ? 'Updated' : 'Stored'} reasoning trace #${result.observation.id}: ${decision}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'search': {
+          const query = (args.query as string | undefined)?.trim();
+          if (!query) {
+            emitError('query is required for "memorix reasoning search"', asJson);
+            return;
+          }
+          const scope = (args.scope as string | undefined) === 'global' ? 'global' : 'project';
+          const limit = parsePositiveInt(args.limit as string | undefined, 10);
+          const result = await compactSearch({
+            query,
+            limit,
+            type: 'reasoning',
+            projectId: scope === 'global' ? undefined : project.id,
+            status: 'active',
+          });
+          emitResult(
+            { project, scope, entries: result.entries },
+            result.entries.length === 0 ? 'No reasoning traces found.' : `[REASONING] Reasoning traces\n${result.formatted}`,
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Reasoning Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix reasoning store --entity auth --decision "Use SQLite" --rationale "..."');
+          console.log('  memorix reasoning search --query "why sqlite" [--scope project|global --limit 10]');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});
+

package/src/cli/commands/repair.ts

@@ -0,0 +1,60 @@
+/**
+ * memorix repair — Safe repair entry points for Memorix-owned integration files.
+ */
+
+import { defineCommand } from 'citty';
+
+export default defineCommand({
+  meta: {
+    name: 'repair',
+    description: 'Repair Memorix-owned agent integration files',
+  },
+  args: {
+    agent: {
+      type: 'string',
+      description: 'Agent to repair (default: all detected repairable entries)',
+    },
+    scope: {
+      type: 'string',
+      description: 'Scope: local, project, global, or all',
+    },
+    dry: {
+      type: 'boolean',
+      description: 'Show what would be repaired without writing files',
+      default: false,
+    },
+    json: {
+      type: 'boolean',
+      description: 'Emit machine-readable JSON output',
+      default: false,
+    },
+  },
+  run: async ({ args }) => {
+    const positional = (args._ as string[]) ?? [];
+    const action = positional[0] || 'agents';
+
+    if (action !== 'agents') {
+      const message = 'Usage: memorix repair agents [--agent <agent>] [--scope local|project|global|all] [--dry]';
+      if (args.json) {
+        console.log(JSON.stringify({ error: message }, null, 2));
+      } else {
+        console.log(message);
+      }
+      process.exitCode = 1;
+      return;
+    }
+
+    const { repairAgentIntegrations, formatAgentRepairResult } = await import('./agent-integrations.js');
+    const repair = await repairAgentIntegrations({
+      agent: args.agent as string | undefined,
+      scope: args.scope as string | undefined,
+      dry: !!args.dry,
+    });
+
+    if (args.json) {
+      console.log(JSON.stringify({ repair }, null, 2));
+    } else {
+      console.log(formatAgentRepairResult(repair));
+    }
+  },
+});