memorix 1.2.2 → 1.2.3

package/src/cli/commands/ingest-log.ts

@@ -1,183 +1,183 @@
-/**
- * CLI Command: memorix ingest log
- *
- * Batch ingest recent git commits as memories.
- * This is the Git→Memory direction — unique to Memorix.
- */
-
-import { defineCommand } from 'citty';
-import * as p from '@clack/prompts';
-
-type IngestableCommit = {
-  hash: string;
-  shortHash: string;
-  subject: string;
-};
-
-type IngestLogResult = {
-  stored: number;
-  dupSkipped: number;
-  errSkipped: number;
-};
-
-/**
- * Shared dedup logic for batch git ingest.
- * Exported so tests can exercise the production path rather than reimplementing it.
- */
-export async function ingestCommitsWithDedup<T extends IngestableCommit>(
-  commits: T[],
-  existingHashes: Set<string>,
-  ingestOne: (commit: T) => Promise<void>,
-  log: (line: string) => void = console.log,
-): Promise<IngestLogResult> {
-  let stored = 0;
-  let dupSkipped = 0;
-  let errSkipped = 0;
-
-  for (const commit of commits) {
-    if (existingHashes.has(commit.hash)) {
-      dupSkipped++;
+/**
+ * CLI Command: memorix ingest log
+ *
+ * Batch ingest recent git commits as memories.
+ * This is the Git→Memory direction — unique to Memorix.
+ */
+
+import { defineCommand } from 'citty';
+import * as p from '@clack/prompts';
+
+type IngestableCommit = {
+  hash: string;
+  shortHash: string;
+  subject: string;
+};
+
+type IngestLogResult = {
+  stored: number;
+  dupSkipped: number;
+  errSkipped: number;
+};
+
+/**
+ * Shared dedup logic for batch git ingest.
+ * Exported so tests can exercise the production path rather than reimplementing it.
+ */
+export async function ingestCommitsWithDedup<T extends IngestableCommit>(
+  commits: T[],
+  existingHashes: Set<string>,
+  ingestOne: (commit: T) => Promise<void>,
+  log: (line: string) => void = console.log,
+): Promise<IngestLogResult> {
+  let stored = 0;
+  let dupSkipped = 0;
+  let errSkipped = 0;
+
+  for (const commit of commits) {
+    if (existingHashes.has(commit.hash)) {
+      dupSkipped++;
       log(`  [SKIP] ${commit.shortHash} ${commit.subject} — already ingested`);
-      continue;
-    }
-    try {
-      await ingestOne(commit);
-      stored++;
-      existingHashes.add(commit.hash);
-      log(`  [OK] ${commit.shortHash} ${commit.subject}`);
-    } catch (err) {
-      errSkipped++;
-      const message = err instanceof Error ? err.message : String(err);
+      continue;
+    }
+    try {
+      await ingestOne(commit);
+      stored++;
+      existingHashes.add(commit.hash);
+      log(`  [OK] ${commit.shortHash} ${commit.subject}`);
+    } catch (err) {
+      errSkipped++;
+      const message = err instanceof Error ? err.message : String(err);
       log(`  [SKIP] ${commit.shortHash} ${commit.subject} — error: ${message}`);
-    }
-  }
-
-  return { stored, dupSkipped, errSkipped };
-}
-
-export default defineCommand({
-  meta: {
-    name: 'log',
-    description: 'Batch ingest recent git commits as memories',
-  },
-  args: {
-    count: {
-      type: 'string',
-      description: 'Number of recent commits to ingest (default: 10)',
-      required: false,
-    },
-  },
-  run: async ({ args }) => {
-    const os = await import('node:os');
-    let cwd: string;
-    try { cwd = process.cwd(); } catch { cwd = os.homedir(); }
-
-    const count = parseInt(args.count || '10', 10);
-
-    p.intro(`Ingest recent ${count} commits`);
-
-    try {
-      const { getRecentCommits, ingestCommit } = await import('../../git/extractor.js');
-      const rawCommits = getRecentCommits(cwd, count);
-
-      if (rawCommits.length === 0) {
-        console.log('No commits found.');
-        p.outro('Nothing to ingest.');
-        return;
-      }
-
-      // Apply noise filter
-      const { filterCommits } = await import('../../git/noise-filter.js');
-      const { getGitConfig } = await import('../../config.js');
-      const gitCfg = getGitConfig();
-      const { kept: commits, skipped: noiseCommits } = filterCommits(rawCommits, {
-        skipMergeCommits: gitCfg.skipMergeCommits,
-        excludePatterns: gitCfg.excludePatterns,
-        noiseKeywords: gitCfg.noiseKeywords,
-      });
-
-      if (commits.length === 0) {
-        console.log(`All ${rawCommits.length} commits filtered as noise.`);
-        p.outro('Nothing to ingest.');
-        return;
-      }
-
-      // Show commits
-      console.log('');
-      console.log(`Found ${rawCommits.length} commits (${noiseCommits.length} filtered as noise):`);
-      console.log('');
-      for (const commit of commits) {
-        console.log(`  ${commit.shortHash} ${commit.subject}`);
-      }
-      if (noiseCommits.length > 0) {
-        console.log('');
-        console.log(`  Filtered (noise):`);
-        for (const { commit, reason } of noiseCommits) {
+    }
+  }
+
+  return { stored, dupSkipped, errSkipped };
+}
+
+export default defineCommand({
+  meta: {
+    name: 'log',
+    description: 'Batch ingest recent git commits as memories',
+  },
+  args: {
+    count: {
+      type: 'string',
+      description: 'Number of recent commits to ingest (default: 10)',
+      required: false,
+    },
+  },
+  run: async ({ args }) => {
+    const os = await import('node:os');
+    let cwd: string;
+    try { cwd = process.cwd(); } catch { cwd = os.homedir(); }
+
+    const count = parseInt(args.count || '10', 10);
+
+    p.intro(`Ingest recent ${count} commits`);
+
+    try {
+      const { getRecentCommits, ingestCommit } = await import('../../git/extractor.js');
+      const rawCommits = getRecentCommits(cwd, count);
+
+      if (rawCommits.length === 0) {
+        console.log('No commits found.');
+        p.outro('Nothing to ingest.');
+        return;
+      }
+
+      // Apply noise filter
+      const { filterCommits } = await import('../../git/noise-filter.js');
+      const { getGitConfig } = await import('../../config.js');
+      const gitCfg = getGitConfig();
+      const { kept: commits, skipped: noiseCommits } = filterCommits(rawCommits, {
+        skipMergeCommits: gitCfg.skipMergeCommits,
+        excludePatterns: gitCfg.excludePatterns,
+        noiseKeywords: gitCfg.noiseKeywords,
+      });
+
+      if (commits.length === 0) {
+        console.log(`All ${rawCommits.length} commits filtered as noise.`);
+        p.outro('Nothing to ingest.');
+        return;
+      }
+
+      // Show commits
+      console.log('');
+      console.log(`Found ${rawCommits.length} commits (${noiseCommits.length} filtered as noise):`);
+      console.log('');
+      for (const commit of commits) {
+        console.log(`  ${commit.shortHash} ${commit.subject}`);
+      }
+      if (noiseCommits.length > 0) {
+        console.log('');
+        console.log(`  Filtered (noise):`);
+        for (const { commit, reason } of noiseCommits) {
           console.log(`  [SKIP] ${commit.shortHash} ${commit.subject} — ${reason}`);
-        }
-      }
-      console.log('');
-
-      // Confirm
-      const confirmed = await p.confirm({
-        message: `Ingest ${commits.length} commits as memories?`,
-      });
-
-      if (p.isCancel(confirmed) || !confirmed) {
-        p.outro('Ingest cancelled.');
-        return;
-      }
-
-      // Store each commit
-      const { initObservations, storeObservation } = await import('../../memory/observations.js');
-      const { getProjectDataDir } = await import('../../store/persistence.js');
-      const { detectProject } = await import('../../project/detector.js');
-      const { initObservationStore, getObservationStore: getStore } = await import('../../store/obs-store.js');
-
-      const project = detectProject(cwd);
-      if (!project) {
-        p.log.error('No .git found — not a project directory.');
-        return;
-      }
-      const dataDir = await getProjectDataDir(project.id);
-      await initObservationStore(dataDir);
-      await initObservations(dataDir);
-
-      // Dedup: load existing commit hashes to skip already-ingested commits (#48)
-      const existingObs = await getStore().loadAll() as Array<{ commitHash?: string }>;
-      const existingHashes = new Set(
-        existingObs.map(o => o.commitHash).filter((hash): hash is string => typeof hash === 'string' && hash.length > 0),
-      );
-
-      const { stored, dupSkipped, errSkipped } = await ingestCommitsWithDedup(
-        commits,
-        existingHashes,
-        async (commit) => {
-          const result = ingestCommit(commit);
-          await storeObservation({
-            entityName: result.entityName,
-            type: result.type as any,
-            title: result.title,
-            sourceDetail: 'git-ingest',
-            narrative: result.narrative,
-            facts: result.facts,
-            concepts: result.concepts,
-            filesModified: result.filesModified,
-            projectId: project.id,
-            source: 'git',
-            commitHash: commit.hash,
-          });
-        },
-        console.log,
-      );
-
-      const parts = [`Ingested ${stored}/${commits.length} commits`];
-      if (dupSkipped) parts.push(`${dupSkipped} already stored`);
-      if (errSkipped) parts.push(`${errSkipped} errors`);
-      p.outro(parts.join(', ') + '.');
-    } catch (err) {
-      console.error(`Failed to ingest log: ${err}`);
-      p.outro('Ingest failed. Make sure you are in a git repository.');
-    }
-  },
-});
+        }
+      }
+      console.log('');
+
+      // Confirm
+      const confirmed = await p.confirm({
+        message: `Ingest ${commits.length} commits as memories?`,
+      });
+
+      if (p.isCancel(confirmed) || !confirmed) {
+        p.outro('Ingest cancelled.');
+        return;
+      }
+
+      // Store each commit
+      const { initObservations, storeObservation } = await import('../../memory/observations.js');
+      const { getProjectDataDir } = await import('../../store/persistence.js');
+      const { detectProject } = await import('../../project/detector.js');
+      const { initObservationStore, getObservationStore: getStore } = await import('../../store/obs-store.js');
+
+      const project = detectProject(cwd);
+      if (!project) {
+        p.log.error('No .git found — not a project directory.');
+        return;
+      }
+      const dataDir = await getProjectDataDir(project.id);
+      await initObservationStore(dataDir);
+      await initObservations(dataDir);
+
+      // Dedup: load existing commit hashes to skip already-ingested commits (#48)
+      const existingObs = await getStore().loadAll() as Array<{ commitHash?: string }>;
+      const existingHashes = new Set(
+        existingObs.map(o => o.commitHash).filter((hash): hash is string => typeof hash === 'string' && hash.length > 0),
+      );
+
+      const { stored, dupSkipped, errSkipped } = await ingestCommitsWithDedup(
+        commits,
+        existingHashes,
+        async (commit) => {
+          const result = ingestCommit(commit);
+          await storeObservation({
+            entityName: result.entityName,
+            type: result.type as any,
+            title: result.title,
+            sourceDetail: 'git-ingest',
+            narrative: result.narrative,
+            facts: result.facts,
+            concepts: result.concepts,
+            filesModified: result.filesModified,
+            projectId: project.id,
+            source: 'git',
+            commitHash: commit.hash,
+          });
+        },
+        console.log,
+      );
+
+      const parts = [`Ingested ${stored}/${commits.length} commits`];
+      if (dupSkipped) parts.push(`${dupSkipped} already stored`);
+      if (errSkipped) parts.push(`${errSkipped} errors`);
+      p.outro(parts.join(', ') + '.');
+    } catch (err) {
+      console.error(`Failed to ingest log: ${err}`);
+      p.outro('Ingest failed. Make sure you are in a git repository.');
+    }
+  },
+});

package/src/cli/commands/ingest.ts

@@ -1,44 +1,44 @@
-/**
- * CLI Command: memorix ingest
- *
- * Parent command for Git→Memory and image ingestion.
- */
-
-import { defineCommand } from 'citty';
-
-export default defineCommand({
-  meta: {
-    name: 'ingest',
-    description: 'Ingest engineering knowledge from Git and images',
-  },
-  subCommands: {
-    commit: () => import('./ingest-commit.js').then((module) => module.default),
-    log: () => import('./ingest-log.js').then((module) => module.default),
-    image: () => import('./ingest-image.js').then((module) => module.default),
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    if (action === 'commit') {
-      const module = await import('./ingest-commit.js');
-      await module.default.run?.({ args: { ...args, _: [] }, rawArgs: [], cmd: module.default } as any);
-      return;
-    }
-    if (action === 'log') {
-      const module = await import('./ingest-log.js');
-      await module.default.run?.({ args: { ...args, _: [] }, rawArgs: [], cmd: module.default } as any);
-      return;
-    }
-    if (action === 'image') {
-      const module = await import('./ingest-image.js');
-      await module.default.run?.({ args: { ...args, _: [] }, rawArgs: [], cmd: module.default } as any);
-      return;
-    }
-
-    console.log('Memorix Ingest Commands');
-    console.log('');
-    console.log('Usage:');
-    console.log('  memorix ingest commit [--ref HEAD]');
-    console.log('  memorix ingest log [--count 10]');
-    console.log('  memorix ingest image --path ./diagram.png');
-  },
-});
+/**
+ * CLI Command: memorix ingest
+ *
+ * Parent command for Git→Memory and image ingestion.
+ */
+
+import { defineCommand } from 'citty';
+
+export default defineCommand({
+  meta: {
+    name: 'ingest',
+    description: 'Ingest engineering knowledge from Git and images',
+  },
+  subCommands: {
+    commit: () => import('./ingest-commit.js').then((module) => module.default),
+    log: () => import('./ingest-log.js').then((module) => module.default),
+    image: () => import('./ingest-image.js').then((module) => module.default),
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    if (action === 'commit') {
+      const module = await import('./ingest-commit.js');
+      await module.default.run?.({ args: { ...args, _: [] }, rawArgs: [], cmd: module.default } as any);
+      return;
+    }
+    if (action === 'log') {
+      const module = await import('./ingest-log.js');
+      await module.default.run?.({ args: { ...args, _: [] }, rawArgs: [], cmd: module.default } as any);
+      return;
+    }
+    if (action === 'image') {
+      const module = await import('./ingest-image.js');
+      await module.default.run?.({ args: { ...args, _: [] }, rawArgs: [], cmd: module.default } as any);
+      return;
+    }
+
+    console.log('Memorix Ingest Commands');
+    console.log('');
+    console.log('Usage:');
+    console.log('  memorix ingest commit [--ref HEAD]');
+    console.log('  memorix ingest log [--count 10]');
+    console.log('  memorix ingest image --path ./diagram.png');
+  },
+});

package/src/cli/commands/integrate-shared.ts

@@ -1,15 +1,15 @@
-import { homedir } from 'node:os';
-
-export function getIntegrationTargetRoot(
-  useGlobalDefaults: boolean,
-  cwd: string,
-  homeDir = homedir(),
-): string {
-  return useGlobalDefaults ? homeDir : cwd;
-}
-
-export function getIntegrationScopeLabel(useGlobalDefaults: boolean): string {
-  return useGlobalDefaults
-    ? 'global defaults'
-    : 'current project';
-}
+import { homedir } from 'node:os';
+
+export function getIntegrationTargetRoot(
+  useGlobalDefaults: boolean,
+  cwd: string,
+  homeDir = homedir(),
+): string {
+  return useGlobalDefaults ? homeDir : cwd;
+}
+
+export function getIntegrationScopeLabel(useGlobalDefaults: boolean): string {
+  return useGlobalDefaults
+    ? 'global defaults'
+    : 'current project';
+}

package/src/cli/commands/lock.ts

@@ -1,97 +1,97 @@
-import { defineCommand } from 'citty';
+import { defineCommand } from 'citty';
 import { emitError, emitResult, getCliProjectContext, resolveCliActorId, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'lock',
-    description: 'Acquire, release, and inspect advisory team file locks',
-  },
-  args: {
-    file: { type: 'string', description: 'File path to lock or inspect' },
-    agentId: { type: 'string', description: 'Agent ID acquiring or releasing the lock' },
-    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: 'lock',
+    description: 'Acquire, release, and inspect advisory team file locks',
+  },
+  args: {
+    file: { type: 'string', description: 'File path to lock or inspect' },
+    agentId: { type: 'string', description: 'Agent ID acquiring or releasing the lock' },
+    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 agentId = resolveCliActorId(args.agentId, identity);
-
-      switch (action) {
-        case 'lock': {
+
+      switch (action) {
+        case 'lock': {
           if (!args.file || !agentId) {
             emitError('file and an active CLI identity or agentId are required for "memorix lock lock"', asJson);
             return;
           }
           const result = teamStore.acquireLock(project.id, args.file as string, agentId);
-          if (!result.success) {
-            emitError(`File is already locked by ${shortId(result.lockedBy)}`, asJson);
-            return;
-          }
-          emitResult(
+          if (!result.success) {
+            emitError(`File is already locked by ${shortId(result.lockedBy)}`, asJson);
+            return;
+          }
+          emitResult(
             { project, file: args.file, lockedBy: agentId },
-            `Locked: ${args.file as string}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'unlock': {
+            `Locked: ${args.file as string}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'unlock': {
           if (!args.file || !agentId) {
             emitError('file and an active CLI identity or agentId are required for "memorix lock unlock"', asJson);
             return;
           }
           const released = teamStore.releaseLock(project.id, args.file as string, agentId);
-          if (!released) {
-            emitError('Cannot unlock: not the owner or the file is not locked', asJson);
-            return;
-          }
-          emitResult(
-            { project, file: args.file, released: true },
-            `Unlocked: ${args.file as string}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'status': {
-          if (args.file) {
-            const lock = teamStore.getLockStatus(project.id, args.file as string);
-            emitResult(
-              { project, lock },
-              lock
-                ? `Locked by ${teamStore.getAgent(lock.locked_by)?.name ?? shortId(lock.locked_by)}: ${args.file as string}`
-                : `Unlocked: ${args.file as string}`,
-              asJson,
-            );
-            return;
-          }
-
+          if (!released) {
+            emitError('Cannot unlock: not the owner or the file is not locked', asJson);
+            return;
+          }
+          emitResult(
+            { project, file: args.file, released: true },
+            `Unlocked: ${args.file as string}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'status': {
+          if (args.file) {
+            const lock = teamStore.getLockStatus(project.id, args.file as string);
+            emitResult(
+              { project, lock },
+              lock
+                ? `Locked by ${teamStore.getAgent(lock.locked_by)?.name ?? shortId(lock.locked_by)}: ${args.file as string}`
+                : `Unlocked: ${args.file as string}`,
+              asJson,
+            );
+            return;
+          }
+
           const locks = teamStore.listLocks(project.id, agentId);
-          emitResult(
-            { project, locks },
-            locks.length === 0
-              ? 'No active file locks.'
-              : locks
-                  .map((lock) => `- ${lock.file} -> ${teamStore.getAgent(lock.locked_by)?.name ?? shortId(lock.locked_by)}`)
-                  .join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Lock Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix lock lock --file src/app.ts --agentId <id>');
-          console.log('  memorix lock unlock --file src/app.ts --agentId <id>');
-          console.log('  memorix lock status [--file src/app.ts] [--agentId <id>]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+          emitResult(
+            { project, locks },
+            locks.length === 0
+              ? 'No active file locks.'
+              : locks
+                  .map((lock) => `- ${lock.file} -> ${teamStore.getAgent(lock.locked_by)?.name ?? shortId(lock.locked_by)}`)
+                  .join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Lock Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix lock lock --file src/app.ts --agentId <id>');
+          console.log('  memorix lock unlock --file src/app.ts --agentId <id>');
+          console.log('  memorix lock status [--file src/app.ts] [--agentId <id>]');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});