memorix 1.4.3 → 1.4.4

package/src/cli/commands/audit-list.ts

@@ -1,89 +1,89 @@
-/**
- * CLI Command: memorix audit list
- *
- * List all files written by Memorix (audit trail).
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-
-export default defineCommand({
-  meta: {
-    name: 'list',
-    description: 'List Memorix-written files (audit trail)',
-  },
-  args: {
-    project: {
-      type: 'string',
-      description: 'Filter by project (optional)',
-      required: false,
-    },
-  },
-  run: async ({ args }) => {
-    const { getAllAuditEntries, getProjectId } = await import('../../audit/index.js');
-    const os = await import('node:os');
-    let cwd: string;
-    try {
-      cwd = process.cwd();
-    } catch {
-      cwd = os.homedir();
-      console.log(`[WARN] Could not access current directory, using home: ${cwd}`);
-    }
-
-    p.intro('Memorix Audit Trail');
-
-    const allEntries = await getAllAuditEntries();
-
-    if (allEntries.length === 0) {
-      console.log('No Memorix-written files found.');
-      p.outro('Audit trail is empty.');
-      return;
-    }
-
-    // Filter by project if specified
-    let entries = allEntries;
-    if (args.project) {
-      const targetProjectId = getProjectId(args.project);
-      entries = allEntries.filter((e) => e.projectId === targetProjectId);
-    }
-
-    if (entries.length === 0) {
-      console.log('No Memorix-written files found for this project.');
-      p.outro('Audit trail is empty for this project.');
-      return;
-    }
-
-    // Group by project
-    const byProject: Record<string, Array<{ entry: import('../../audit/index.js').AuditEntry }>> = {};
-    for (const { projectId, entry } of entries) {
-      if (!byProject[projectId]) {
-        byProject[projectId] = [];
-      }
-      byProject[projectId].push({ entry });
-    }
-
-    // Display by project
-    console.log('');
-    for (const [projectId, items] of Object.entries(byProject)) {
-      console.log(`Project: ${projectId}`);
-      console.log('');
-
-      for (const { entry } of items) {
-        const icon = entry.type === 'hook' ? '[HOOK]' : '[TASK]';
-        const agent = entry.agent ? ` (${entry.agent})` : '';
-        console.log(`${icon} ${entry.path}${agent}`);
-        console.log(`   Created: ${entry.createdAt}`);
-        console.log('');
-      }
-    }
-
-    // Summary
-    const hookCount = entries.filter((e) => e.entry.type === 'hook').length;
-    const ruleCount = entries.filter((e) => e.entry.type === 'rule').length;
-    const projectCount = new Set(entries.map((e) => e.projectId)).size;
-
-    p.note(`${projectCount} projects, ${hookCount} hooks, ${ruleCount} rules`);
-
-    p.outro('Audit trail complete.');
-  },
-});
+/**
+ * CLI Command: memorix audit list
+ *
+ * List all files written by Memorix (audit trail).
+ */
+
+import { defineCommand } from 'citty';
+import * as p from '@clack/prompts';
+
+export default defineCommand({
+  meta: {
+    name: 'list',
+    description: 'List Memorix-written files (audit trail)',
+  },
+  args: {
+    project: {
+      type: 'string',
+      description: 'Filter by project (optional)',
+      required: false,
+    },
+  },
+  run: async ({ args }) => {
+    const { getAllAuditEntries, getProjectId } = await import('../../audit/index.js');
+    const os = await import('node:os');
+    let cwd: string;
+    try {
+      cwd = process.cwd();
+    } catch {
+      cwd = os.homedir();
+      console.log(`[WARN] Could not access current directory, using home: ${cwd}`);
+    }
+
+    p.intro('Memorix Audit Trail');
+
+    const allEntries = await getAllAuditEntries();
+
+    if (allEntries.length === 0) {
+      console.log('No Memorix-written files found.');
+      p.outro('Audit trail is empty.');
+      return;
+    }
+
+    // Filter by project if specified
+    let entries = allEntries;
+    if (args.project) {
+      const targetProjectId = getProjectId(args.project);
+      entries = allEntries.filter((e) => e.projectId === targetProjectId);
+    }
+
+    if (entries.length === 0) {
+      console.log('No Memorix-written files found for this project.');
+      p.outro('Audit trail is empty for this project.');
+      return;
+    }
+
+    // Group by project
+    const byProject: Record<string, Array<{ entry: import('../../audit/index.js').AuditEntry }>> = {};
+    for (const { projectId, entry } of entries) {
+      if (!byProject[projectId]) {
+        byProject[projectId] = [];
+      }
+      byProject[projectId].push({ entry });
+    }
+
+    // Display by project
+    console.log('');
+    for (const [projectId, items] of Object.entries(byProject)) {
+      console.log(`Project: ${projectId}`);
+      console.log('');
+
+      for (const { entry } of items) {
+        const icon = entry.type === 'hook' ? '[HOOK]' : '[TASK]';
+        const agent = entry.agent ? ` (${entry.agent})` : '';
+        console.log(`${icon} ${entry.path}${agent}`);
+        console.log(`   Created: ${entry.createdAt}`);
+        console.log('');
+      }
+    }
+
+    // Summary
+    const hookCount = entries.filter((e) => e.entry.type === 'hook').length;
+    const ruleCount = entries.filter((e) => e.entry.type === 'rule').length;
+    const projectCount = new Set(entries.map((e) => e.projectId)).size;
+
+    p.note(`${projectCount} projects, ${hookCount} hooks, ${ruleCount} rules`);
+
+    p.outro('Audit trail complete.');
+  },
+});

package/src/cli/commands/formation.ts

@@ -1,48 +1,48 @@
-import { defineCommand } from 'citty';
-import { getBeforeAfterMetrics, getMetricsSummary } from '../../memory/formation/index.js';
-import { emitError, emitResult } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'formation',
-    description: 'Inspect Memory Formation Pipeline runtime metrics',
-  },
-  args: {
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
-      switch (action) {
-        case 'metrics': {
-          const summary = getMetricsSummary();
-          const beforeAfter = getBeforeAfterMetrics();
-          emitResult(
-            { summary, beforeAfter },
-            summary.total === 0
-              ? 'Formation Pipeline: No metrics collected yet.'
-              : [
-                  'Formation Pipeline Metrics',
-                  `- Total observations processed: ${summary.total}`,
-                  `- Average value score: ${summary.avgValueScore.toFixed(3)}`,
-                  `- Average processing time: ${summary.avgDurationMs.toFixed(1)}ms`,
-                ].join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Formation Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix formation metrics');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
-
+import { defineCommand } from 'citty';
+import { getBeforeAfterMetrics, getMetricsSummary } from '../../memory/formation/index.js';
+import { emitError, emitResult } from './operator-shared.js';
+
+export default defineCommand({
+  meta: {
+    name: 'formation',
+    description: 'Inspect Memory Formation Pipeline runtime metrics',
+  },
+  args: {
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
+      switch (action) {
+        case 'metrics': {
+          const summary = getMetricsSummary();
+          const beforeAfter = getBeforeAfterMetrics();
+          emitResult(
+            { summary, beforeAfter },
+            summary.total === 0
+              ? 'Formation Pipeline: No metrics collected yet.'
+              : [
+                  'Formation Pipeline Metrics',
+                  `- Total observations processed: ${summary.total}`,
+                  `- Average value score: ${summary.avgValueScore.toFixed(3)}`,
+                  `- Average processing time: ${summary.avgDurationMs.toFixed(1)}ms`,
+                ].join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Formation Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix formation metrics');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});
+

package/src/cli/commands/git-hook-install.ts

@@ -1,111 +1,111 @@
-/**
- * CLI Command: memorix git-hook install
- *
- * Installs a git post-commit hook that automatically ingests commits as memories.
- * This is the Git→Memory automation — every commit becomes a searchable memory.
- *
- * Cross-platform: generates both bash (Unix) and PowerShell (Windows) hooks.
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-import { existsSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
-import { ensureHooksDir } from '../../git/hooks-path.js';
-
-const HOOK_MARKER = '# [memorix-git-hook]';
-
-export default defineCommand({
-  meta: {
-    name: 'git-hook-install',
-    description: 'Install git post-commit hook for automatic memory capture',
-  },
-  args: {
-    cwd: {
-      type: 'string',
-      description: 'Project directory (default: current directory)',
-      required: false,
-    },
-    force: {
-      type: 'boolean',
-      description: 'Overwrite existing hook without asking',
-      required: false,
-    },
-  },
-  run: async ({ args }) => {
-    const projectDir = args.cwd || process.cwd();
-
-    p.intro('Install Git post-commit hook');
-
-    // 1. Resolve git hooks directory (handles normal repos and worktrees)
-    const resolved = ensureHooksDir(projectDir);
-    if (!resolved) {
-      p.log.error(`No .git found in ${projectDir} (checked both directory and worktree file)`);
-      p.outro('Run this command from a git repository root.');
-      return;
-    }
-
-    const { hookPath } = resolved;
-
-    // 3. Check for existing hook
-    if (existsSync(hookPath)) {
-      const existing = readFileSync(hookPath, 'utf-8');
-
-      if (existing.includes(HOOK_MARKER)) {
-        p.log.warn('Memorix git hook is already installed.');
-        p.outro('Use `memorix git-hook uninstall` to remove it first.');
-        return;
-      }
-
-      // Existing non-memorix hook — ask to append
-      if (!args.force) {
-        const action = await p.select({
-          message: 'A post-commit hook already exists. What would you like to do?',
-          options: [
-            { value: 'append', label: 'Append', hint: 'Add memorix hook after existing content' },
-            { value: 'skip', label: 'Skip', hint: 'Do not modify the existing hook' },
-          ],
-        });
-
-        if (p.isCancel(action) || action === 'skip') {
-          p.outro('Installation cancelled.');
-          return;
-        }
-      }
-
-      // Append to existing hook
-      const appended = existing.trimEnd() + '\n\n' + generateHookScript();
-      writeFileSync(hookPath, appended, 'utf-8');
-      try { chmodSync(hookPath, 0o755); } catch { /* Windows doesn't need chmod */ }
-
-      p.log.success('Memorix hook appended to existing post-commit hook.');
-    } else {
-      // Create new hook
-      const script = '#!/bin/sh\n' + generateHookScript();
-      writeFileSync(hookPath, script, 'utf-8');
-      try { chmodSync(hookPath, 0o755); } catch { /* Windows doesn't need chmod */ }
-
-      p.log.success('Git post-commit hook installed.');
-    }
-
-    p.log.info(`Hook path: ${hookPath}`);
-    p.log.info('Every commit will now be automatically captured as a memory.');
-    p.log.info('Memories are tagged with source="git" and include the commit hash.');
-    p.outro('Done! Try making a commit to see it in action.');
-  },
-});
-
-/**
- * Generate the hook script content.
- * Uses `memorix ingest commit --auto` for non-interactive ingest.
- * Runs in background to not block the commit.
- */
-function generateHookScript(): string {
-  return `${HOOK_MARKER}
-# Memorix: Auto-ingest git commits as memories
-# Runs in background — does not block your commit workflow.
-# To remove: memorix git-hook uninstall
-if command -v memorix >/dev/null 2>&1; then
-  memorix ingest commit --auto >/dev/null 2>&1 &
-fi
-`;
-}
+/**
+ * CLI Command: memorix git-hook install
+ *
+ * Installs a git post-commit hook that automatically ingests commits as memories.
+ * This is the Git→Memory automation — every commit becomes a searchable memory.
+ *
+ * Cross-platform: generates both bash (Unix) and PowerShell (Windows) hooks.
+ */
+
+import { defineCommand } from 'citty';
+import * as p from '@clack/prompts';
+import { existsSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
+import { ensureHooksDir } from '../../git/hooks-path.js';
+
+const HOOK_MARKER = '# [memorix-git-hook]';
+
+export default defineCommand({
+  meta: {
+    name: 'git-hook-install',
+    description: 'Install git post-commit hook for automatic memory capture',
+  },
+  args: {
+    cwd: {
+      type: 'string',
+      description: 'Project directory (default: current directory)',
+      required: false,
+    },
+    force: {
+      type: 'boolean',
+      description: 'Overwrite existing hook without asking',
+      required: false,
+    },
+  },
+  run: async ({ args }) => {
+    const projectDir = args.cwd || process.cwd();
+
+    p.intro('Install Git post-commit hook');
+
+    // 1. Resolve git hooks directory (handles normal repos and worktrees)
+    const resolved = ensureHooksDir(projectDir);
+    if (!resolved) {
+      p.log.error(`No .git found in ${projectDir} (checked both directory and worktree file)`);
+      p.outro('Run this command from a git repository root.');
+      return;
+    }
+
+    const { hookPath } = resolved;
+
+    // 3. Check for existing hook
+    if (existsSync(hookPath)) {
+      const existing = readFileSync(hookPath, 'utf-8');
+
+      if (existing.includes(HOOK_MARKER)) {
+        p.log.warn('Memorix git hook is already installed.');
+        p.outro('Use `memorix git-hook uninstall` to remove it first.');
+        return;
+      }
+
+      // Existing non-memorix hook — ask to append
+      if (!args.force) {
+        const action = await p.select({
+          message: 'A post-commit hook already exists. What would you like to do?',
+          options: [
+            { value: 'append', label: 'Append', hint: 'Add memorix hook after existing content' },
+            { value: 'skip', label: 'Skip', hint: 'Do not modify the existing hook' },
+          ],
+        });
+
+        if (p.isCancel(action) || action === 'skip') {
+          p.outro('Installation cancelled.');
+          return;
+        }
+      }
+
+      // Append to existing hook
+      const appended = existing.trimEnd() + '\n\n' + generateHookScript();
+      writeFileSync(hookPath, appended, 'utf-8');
+      try { chmodSync(hookPath, 0o755); } catch { /* Windows doesn't need chmod */ }
+
+      p.log.success('Memorix hook appended to existing post-commit hook.');
+    } else {
+      // Create new hook
+      const script = '#!/bin/sh\n' + generateHookScript();
+      writeFileSync(hookPath, script, 'utf-8');
+      try { chmodSync(hookPath, 0o755); } catch { /* Windows doesn't need chmod */ }
+
+      p.log.success('Git post-commit hook installed.');
+    }
+
+    p.log.info(`Hook path: ${hookPath}`);
+    p.log.info('Every commit will now be automatically captured as a memory.');
+    p.log.info('Memories are tagged with source="git" and include the commit hash.');
+    p.outro('Done! Try making a commit to see it in action.');
+  },
+});
+
+/**
+ * Generate the hook script content.
+ * Uses `memorix ingest commit --auto` for non-interactive ingest.
+ * Runs in background to not block the commit.
+ */
+function generateHookScript(): string {
+  return `${HOOK_MARKER}
+# Memorix: Auto-ingest git commits as memories
+# Runs in background — does not block your commit workflow.
+# To remove: memorix git-hook uninstall
+if command -v memorix >/dev/null 2>&1; then
+  memorix ingest commit --auto >/dev/null 2>&1 &
+fi
+`;
+}

package/src/cli/commands/handoff.ts

@@ -1,33 +1,33 @@
-import { defineCommand } from 'citty';
-import { storeObservation } from '../../memory/observations.js';
-import { createHandoffArtifact } from '../../team/handoff.js';
+import { defineCommand } from 'citty';
+import { storeObservation } from '../../memory/observations.js';
+import { createHandoffArtifact } from '../../team/handoff.js';
 import { emitError, emitResult, getCliProjectContext, parseCsvList, resolveCliActorId, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'handoff',
-    description: 'Create structured handoff artifacts between agents',
-  },
-  args: {
-    fromAgentId: { type: 'string', description: 'Sender agent ID' },
-    toAgentId: { type: 'string', description: 'Optional recipient agent ID' },
-    taskId: { type: 'string', description: 'Optional related task ID' },
-    summary: { type: 'string', description: 'Human-readable summary of the handoff' },
-    context: { type: 'string', description: 'Detailed machine-readable context for the next agent' },
-    filesModified: { type: 'string', description: 'Comma-separated file list' },
-    concepts: { type: 'string', description: 'Comma-separated discoverability concepts' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+
+export default defineCommand({
+  meta: {
+    name: 'handoff',
+    description: 'Create structured handoff artifacts between agents',
+  },
+  args: {
+    fromAgentId: { type: 'string', description: 'Sender agent ID' },
+    toAgentId: { type: 'string', description: 'Optional recipient agent ID' },
+    taskId: { type: 'string', description: 'Optional related task ID' },
+    summary: { type: 'string', description: 'Human-readable summary of the handoff' },
+    context: { type: 'string', description: 'Detailed machine-readable context for the next agent' },
+    filesModified: { type: 'string', description: 'Comma-separated file list' },
+    concepts: { type: 'string', description: 'Comma-separated discoverability concepts' },
+    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, teamStore, identity } = await getCliProjectContext();
       const fromAgentId = resolveCliActorId(args.fromAgentId, identity, 'fromAgentId');
-
-      switch (action) {
-        case 'send': {
+
+      switch (action) {
+        case 'send': {
           if (!fromAgentId || !args.summary || !args.context) {
             emitError('summary, context, and an active CLI identity or fromAgentId are required for "memorix handoff send"', asJson);
             return;
@@ -50,31 +50,31 @@ export default defineCommand({
               projectId: project.id,
               fromAgentId,
               toAgentId,
-              taskId: args.taskId as string | undefined,
-              summary: args.summary as string,
-              context: args.context as string,
-              filesModified: parseCsvList(args.filesModified as string | undefined),
-              concepts: parseCsvList(args.concepts as string | undefined),
-            },
-            storeObservation,
-            teamStore,
-          );
-          emitResult(
-            { project, handoff: result },
-            `Handoff created: observation #${result.observationId} from ${shortId(result.fromAgentId)}${result.toAgentId ? ` to ${shortId(result.toAgentId)}` : ' (broadcast)'}`,
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Handoff Commands');
-          console.log('');
-          console.log('Usage:');
+              taskId: args.taskId as string | undefined,
+              summary: args.summary as string,
+              context: args.context as string,
+              filesModified: parseCsvList(args.filesModified as string | undefined),
+              concepts: parseCsvList(args.concepts as string | undefined),
+            },
+            storeObservation,
+            teamStore,
+          );
+          emitResult(
+            { project, handoff: result },
+            `Handoff created: observation #${result.observationId} from ${shortId(result.fromAgentId)}${result.toAgentId ? ` to ${shortId(result.toAgentId)}` : ' (broadcast)'}`,
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Handoff Commands');
+          console.log('');
+          console.log('Usage:');
           console.log('  memorix handoff send --summary "..." --context "..." [--fromAgentId <id>] [--toAgentId <id>] [--taskId <id>]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});