memorix 1.2.0 → 1.2.2

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

@@ -1,73 +1,75 @@
-import { defineCommand } from 'citty';
-import { readFileSync } from 'node:fs';
-import path from 'node:path';
-import { analyzeImage } from '../../multimodal/image-loader.js';
-import { storeObservation } from '../../memory/observations.js';
-import { emitError, emitResult, getCliProjectContext } from './operator-shared.js';
-
-function inferMimeType(filePath: string): string {
-  const ext = path.extname(filePath).toLowerCase();
-  switch (ext) {
-    case '.jpg':
-    case '.jpeg':
-      return 'image/jpeg';
-    case '.gif':
-      return 'image/gif';
-    case '.webp':
-      return 'image/webp';
-    default:
-      return 'image/png';
-  }
-}
-
-export default defineCommand({
-  meta: {
-    name: 'image',
-    description: 'Analyze an image and store the result as memory',
-  },
-  args: {
-    path: { type: 'string', description: 'Path to the image file' },
-    prompt: { type: 'string', description: 'Custom analysis prompt' },
+import { defineCommand } from 'citty';
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { analyzeImage } from '../../multimodal/image-loader.js';
+import { storeObservation } from '../../memory/observations.js';
+import { emitError, emitResult, getCliProjectContext, resolveCliWriteScope } from './operator-shared.js';
+
+function inferMimeType(filePath: string): string {
+  const ext = path.extname(filePath).toLowerCase();
+  switch (ext) {
+    case '.jpg':
+    case '.jpeg':
+      return 'image/jpeg';
+    case '.gif':
+      return 'image/gif';
+    case '.webp':
+      return 'image/webp';
+    default:
+      return 'image/png';
+  }
+}
+
+export default defineCommand({
+  meta: {
+    name: 'image',
+    description: 'Analyze an image and store the result as memory',
+  },
+  args: {
+    path: { type: 'string', description: 'Path to the image file' },
+    prompt: { type: 'string', description: 'Custom analysis prompt' },
     mimeType: { type: 'string', description: 'Explicit MIME type override' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const asJson = !!args.json;
-    try {
-      const imagePath = (args.path as string | undefined)?.trim();
-      if (!imagePath) {
-        emitError('path is required for "memorix ingest image"', asJson);
-        return;
-      }
-      const { project } = await getCliProjectContext();
-      const resolvedPath = path.resolve(process.cwd(), imagePath);
-      const base64 = readFileSync(resolvedPath).toString('base64');
-      const filename = path.basename(resolvedPath);
-      const analysis = await analyzeImage({
-        base64,
-        filename,
-        mimeType: (args.mimeType as string | undefined) || inferMimeType(resolvedPath),
-        prompt: args.prompt as string | undefined,
-      });
-
+    visibility: { type: 'string', description: 'Memory visibility: project (default), personal, or team' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const asJson = !!args.json;
+    try {
+      const imagePath = (args.path as string | undefined)?.trim();
+      if (!imagePath) {
+        emitError('path is required for "memorix ingest image"', asJson);
+        return;
+      }
+      const { project, reader, identity } = await getCliProjectContext();
+      const resolvedPath = path.resolve(project.rootPath, imagePath);
+      const base64 = readFileSync(resolvedPath).toString('base64');
+      const filename = path.basename(resolvedPath);
+      const analysis = await analyzeImage({
+        base64,
+        filename,
+        mimeType: (args.mimeType as string | undefined) || inferMimeType(resolvedPath),
+        prompt: args.prompt as string | undefined,
+      });
+
       const result = await storeObservation({
-        entityName: filename.replace(/\.[^.]+$/, '') || `image-${Date.now()}`,
-        type: 'discovery',
-        title: `Image analysis: ${filename}`,
-        narrative: analysis.description,
-        concepts: analysis.tags,
-        facts: analysis.entities,
+        entityName: filename.replace(/\.[^.]+$/, '') || `image-${Date.now()}`,
+        type: 'discovery',
+        title: `Image analysis: ${filename}`,
+        narrative: analysis.description,
+        concepts: analysis.tags,
+        facts: analysis.entities,
         projectId: project.id,
         source: 'manual',
-      });
-
-      emitResult(
-        { project, analysis, observation: result.observation },
-        `Stored image analysis #${result.observation.id}: ${filename}`,
-        asJson,
-      );
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+        ...resolveCliWriteScope({ reader, identity }, args.visibility as string | undefined),
+      });
+
+      emitResult(
+        { project, analysis, observation: result.observation },
+        `Stored image analysis #${result.observation.id}: ${filename}`,
+        asJson,
+      );
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

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';
+}