memorix 1.2.2 → 1.2.4

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

@@ -1,118 +1,118 @@
-import type { ProjectInfo } from '../../types.js';
-
-export interface ResolveServeProjectOptions {
-  cwdArg?: string;
-  envProjectRoot?: string;
-  initCwd?: string;
-  processCwd: string;
-  homeDir: string;
-  lastKnownProjectRoot?: string;
-}
-
-export interface ResolveServeProjectDeps {
-  detectProject: (cwd: string) => ProjectInfo | null;
-  findGitInSubdirs: (dir: string) => string | null;
-  isSystemDirectory: (dir: string) => boolean;
-}
-
-export interface ServeProjectResolution {
-  projectRoot: string;
-  detectedProject: ProjectInfo | null;
-  source: 'direct' | 'subdir' | 'last-known' | 'home' | 'home-subdir' | 'unresolved';
-  messages: string[];
-  error?: string;
-}
-
-export function resolveServeProject(
-  options: ResolveServeProjectOptions,
-  deps: ResolveServeProjectDeps,
-): ServeProjectResolution {
-  let projectRoot =
-    options.cwdArg ||
-    options.envProjectRoot ||
-    options.initCwd ||
-    options.processCwd;
-
-  const messages: string[] = [`[memorix] Starting with cwd: ${projectRoot}`];
-
-  let detected = deps.detectProject(projectRoot);
-  if (detected) {
-    return {
-      projectRoot,
-      detectedProject: detected,
-      source: 'direct',
-      messages,
-    };
-  }
-
-  const subGit = deps.findGitInSubdirs(projectRoot);
-  if (subGit) {
-    projectRoot = subGit;
-    detected = deps.detectProject(subGit);
-    if (detected) {
-      messages.push(`[memorix] Found .git in subdirectory: ${subGit}`);
-      return {
-        projectRoot,
-        detectedProject: detected,
-        source: 'subdir',
-        messages,
-      };
-    }
-  }
-
-  if (deps.isSystemDirectory(projectRoot)) {
-    messages.push(`[memorix] System directory detected: ${projectRoot}`);
-    messages.push('[memorix] Your IDE launched memorix from a non-workspace directory.');
-    messages.push('[memorix] Fix: add --cwd to your MCP config, or use an IDE/client that exposes workspace roots.');
-
-    if (options.lastKnownProjectRoot) {
-      detected = deps.detectProject(options.lastKnownProjectRoot);
-      if (detected) {
-        messages.push(`[memorix] Restored last known project: ${options.lastKnownProjectRoot}`);
-        return {
-          projectRoot: options.lastKnownProjectRoot,
-          detectedProject: detected,
-          source: 'last-known',
-          messages,
-        };
-      }
-    }
-
-    detected = deps.detectProject(options.homeDir);
-    if (detected) {
-      messages.push(`[memorix] Restored project from home directory: ${options.homeDir}`);
-      return {
-        projectRoot: options.homeDir,
-        detectedProject: detected,
-        source: 'home',
-        messages,
-      };
-    }
-
-    const homeSubGit = deps.findGitInSubdirs(options.homeDir);
-    if (homeSubGit) {
-      detected = deps.detectProject(homeSubGit);
-      if (detected) {
-        messages.push(`[memorix] Found .git in home subdirectory: ${homeSubGit}`);
-        return {
-          projectRoot: homeSubGit,
-          detectedProject: detected,
-          source: 'home-subdir',
-          messages,
-        };
-      }
-    }
-  }
-
-  messages.push('[memorix] Unable to establish a reliable git-backed project context.');
-  messages.push('[memorix] Memorix now refuses to silently fall back to untracked/* in stdio mode.');
-
-  return {
-    projectRoot,
-    detectedProject: null,
-    source: 'unresolved',
-    messages,
-    error:
-      'No git project could be resolved from the current workspace. Open the repo root, pass --cwd, or use an MCP client that sends workspace roots.',
-  };
-}
+import type { ProjectInfo } from '../../types.js';
+
+export interface ResolveServeProjectOptions {
+  cwdArg?: string;
+  envProjectRoot?: string;
+  initCwd?: string;
+  processCwd: string;
+  homeDir: string;
+  lastKnownProjectRoot?: string;
+}
+
+export interface ResolveServeProjectDeps {
+  detectProject: (cwd: string) => ProjectInfo | null;
+  findGitInSubdirs: (dir: string) => string | null;
+  isSystemDirectory: (dir: string) => boolean;
+}
+
+export interface ServeProjectResolution {
+  projectRoot: string;
+  detectedProject: ProjectInfo | null;
+  source: 'direct' | 'subdir' | 'last-known' | 'home' | 'home-subdir' | 'unresolved';
+  messages: string[];
+  error?: string;
+}
+
+export function resolveServeProject(
+  options: ResolveServeProjectOptions,
+  deps: ResolveServeProjectDeps,
+): ServeProjectResolution {
+  let projectRoot =
+    options.cwdArg ||
+    options.envProjectRoot ||
+    options.initCwd ||
+    options.processCwd;
+
+  const messages: string[] = [`[memorix] Starting with cwd: ${projectRoot}`];
+
+  let detected = deps.detectProject(projectRoot);
+  if (detected) {
+    return {
+      projectRoot,
+      detectedProject: detected,
+      source: 'direct',
+      messages,
+    };
+  }
+
+  const subGit = deps.findGitInSubdirs(projectRoot);
+  if (subGit) {
+    projectRoot = subGit;
+    detected = deps.detectProject(subGit);
+    if (detected) {
+      messages.push(`[memorix] Found .git in subdirectory: ${subGit}`);
+      return {
+        projectRoot,
+        detectedProject: detected,
+        source: 'subdir',
+        messages,
+      };
+    }
+  }
+
+  if (deps.isSystemDirectory(projectRoot)) {
+    messages.push(`[memorix] System directory detected: ${projectRoot}`);
+    messages.push('[memorix] Your IDE launched memorix from a non-workspace directory.');
+    messages.push('[memorix] Fix: add --cwd to your MCP config, or use an IDE/client that exposes workspace roots.');
+
+    if (options.lastKnownProjectRoot) {
+      detected = deps.detectProject(options.lastKnownProjectRoot);
+      if (detected) {
+        messages.push(`[memorix] Restored last known project: ${options.lastKnownProjectRoot}`);
+        return {
+          projectRoot: options.lastKnownProjectRoot,
+          detectedProject: detected,
+          source: 'last-known',
+          messages,
+        };
+      }
+    }
+
+    detected = deps.detectProject(options.homeDir);
+    if (detected) {
+      messages.push(`[memorix] Restored project from home directory: ${options.homeDir}`);
+      return {
+        projectRoot: options.homeDir,
+        detectedProject: detected,
+        source: 'home',
+        messages,
+      };
+    }
+
+    const homeSubGit = deps.findGitInSubdirs(options.homeDir);
+    if (homeSubGit) {
+      detected = deps.detectProject(homeSubGit);
+      if (detected) {
+        messages.push(`[memorix] Found .git in home subdirectory: ${homeSubGit}`);
+        return {
+          projectRoot: homeSubGit,
+          detectedProject: detected,
+          source: 'home-subdir',
+          messages,
+        };
+      }
+    }
+  }
+
+  messages.push('[memorix] Unable to establish a reliable git-backed project context.');
+  messages.push('[memorix] Memorix now refuses to silently fall back to untracked/* in stdio mode.');
+
+  return {
+    projectRoot,
+    detectedProject: null,
+    source: 'unresolved',
+    messages,
+    error:
+      'No git project could be resolved from the current workspace. Open the repo root, pass --cwd, or use an MCP client that sends workspace roots.',
+  };
+}

package/src/cli/commands/session.ts

@@ -32,7 +32,7 @@ export default defineCommand({
     const asJson = !!args.json;
 
     try {
-      const { project, dataDir, teamStore } = await getCliProjectContext({
+      const { project, dataDir, teamStore, reader } = await getCliProjectContext({
         projectRoot: args.projectRoot as string | undefined,
       });
 
@@ -46,11 +46,6 @@ export default defineCommand({
             emitError('use requires --agent or --agentType so Memorix can activate a coordination identity.', asJson);
             return;
           }
-          const result = await startSession(dataDir, project.id, {
-            sessionId: args.sessionId as string | undefined,
-            agent: args.agent as string | undefined,
-          });
-
           const shouldJoinTeam = !!args.joinTeam;
           let agentRecord: ReturnType<typeof teamStore.registerAgent> | null = null;
           let teamJoinNotice: string | null = null;
@@ -72,6 +67,19 @@ export default defineCommand({
             teamJoinNotice = 'Coordination join skipped: provide --agent or --agentType to create a coordination identity.';
           }
 
+          const contextReader = agentRecord
+            ? {
+                projectId: project.id,
+                agentId: agentRecord.agent_id,
+                isTeamMember: agentRecord.status === 'active',
+              }
+            : reader;
+          const result = await startSession(dataDir, project.id, {
+            sessionId: args.sessionId as string | undefined,
+            agent: args.agent as string | undefined,
+            reader: contextReader,
+          });
+
           let identityActivated = false;
           if (args.use && agentRecord) {
             await saveCliIdentity(dataDir, {
@@ -178,7 +186,7 @@ export default defineCommand({
         case 'context': {
           const limit = parsePositiveInt(args.limit as string | undefined, 3);
           const [context, sessions] = await Promise.all([
-            getSessionContext(dataDir, project.id, limit),
+            getSessionContext(dataDir, project.id, limit, reader),
             listSessions(dataDir, project.id),
           ]);
           const active = sessions.filter((session) => session.status === 'active').length;

package/src/cli/commands/skills.ts

@@ -1,128 +1,128 @@
-import { defineCommand } from 'citty';
+import { defineCommand } from 'citty';
 import type { AgentTarget } from '../../types.js';
 import { getObservationStore } from '../../store/obs-store.js';
 import { filterReadableObservations, resolveObservationVisibility } from '../../memory/visibility.js';
-import { emitError, emitResult, getCliProjectContext } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'skills',
-    description: 'Discover, generate, and inspect project skills from the CLI',
-  },
-  args: {
-    name: { type: 'string', description: 'Skill name for "show"' },
-    target: { type: 'string', description: 'Target agent for generated skills' },
-    write: { type: 'boolean', description: 'Write generated skills to disk' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+import { emitError, emitResult, getCliProjectContext } from './operator-shared.js';
+
+export default defineCommand({
+  meta: {
+    name: 'skills',
+    description: 'Discover, generate, and inspect project skills from the CLI',
+  },
+  args: {
+    name: { type: 'string', description: 'Skill name for "show"' },
+    target: { type: 'string', description: 'Target agent for generated skills' },
+    write: { type: 'boolean', description: 'Write generated skills to disk' },
+    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, reader } = await getCliProjectContext();
-      const { SkillsEngine } = await import('../../skills/engine.js');
-      const engine = new SkillsEngine(project.rootPath);
-
-      switch (action) {
-        case 'list': {
-          const skills = engine.listSkills();
-          emitResult(
-            { project, skills },
-            skills.length === 0
-              ? 'No skills found in project or global agent directories.'
-              : skills.map((skill) => `- ${skill.name} (${skill.sourceAgent})`).join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        case 'generate': {
+      const { SkillsEngine } = await import('../../skills/engine.js');
+      const engine = new SkillsEngine(project.rootPath);
+
+      switch (action) {
+        case 'list': {
+          const skills = engine.listSkills();
+          emitResult(
+            { project, skills },
+            skills.length === 0
+              ? 'No skills found in project or global agent directories.'
+              : skills.map((skill) => `- ${skill.name} (${skill.sourceAgent})`).join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        case 'generate': {
           const observations = filterReadableObservations(
             await getObservationStore().loadAll(),
             reader,
           ).filter((observation) => resolveObservationVisibility(observation) === 'project')
             .map((obs) => ({
-              id: obs.id,
-              entityName: obs.entityName,
-              type: obs.type,
-              title: obs.title,
-              narrative: obs.narrative,
-              facts: obs.facts,
-              concepts: obs.concepts,
-              filesModified: obs.filesModified,
-              createdAt: obs.createdAt,
-              status: obs.status,
-              source: obs.source,
-            }));
-          const skills = engine.generateFromObservations(observations);
-          const written: string[] = [];
-          if (args.write && args.target) {
-            for (const skill of skills) {
-              const writtenPath = engine.writeSkill(skill, args.target as AgentTarget);
-              if (writtenPath) written.push(writtenPath);
-            }
-          }
-          emitResult(
-            { project, skills, written },
-            skills.length === 0
-              ? 'No skill-worthy patterns found yet.'
-              : skills.map((skill) => `- ${skill.name}: ${skill.description}`).join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        case 'show': {
-          const name = (args.name as string | undefined)?.trim();
-          if (!name) {
-            emitError('name is required for "memorix skills show"', asJson);
-            return;
-          }
-          const direct = engine.injectSkill(name);
-          if (direct) {
-            emitResult({ project, skill: direct }, direct.content, asJson);
-            return;
-          }
-
+              id: obs.id,
+              entityName: obs.entityName,
+              type: obs.type,
+              title: obs.title,
+              narrative: obs.narrative,
+              facts: obs.facts,
+              concepts: obs.concepts,
+              filesModified: obs.filesModified,
+              createdAt: obs.createdAt,
+              status: obs.status,
+              source: obs.source,
+            }));
+          const skills = engine.generateFromObservations(observations);
+          const written: string[] = [];
+          if (args.write && args.target) {
+            for (const skill of skills) {
+              const writtenPath = engine.writeSkill(skill, args.target as AgentTarget);
+              if (writtenPath) written.push(writtenPath);
+            }
+          }
+          emitResult(
+            { project, skills, written },
+            skills.length === 0
+              ? 'No skill-worthy patterns found yet.'
+              : skills.map((skill) => `- ${skill.name}: ${skill.description}`).join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        case 'show': {
+          const name = (args.name as string | undefined)?.trim();
+          if (!name) {
+            emitError('name is required for "memorix skills show"', asJson);
+            return;
+          }
+          const direct = engine.injectSkill(name);
+          if (direct) {
+            emitResult({ project, skill: direct }, direct.content, asJson);
+            return;
+          }
+
           const observations = filterReadableObservations(
             await getObservationStore().loadAll(),
             reader,
           ).filter((observation) => resolveObservationVisibility(observation) === 'project')
             .map((obs) => ({
-              id: obs.id,
-              entityName: obs.entityName,
-              type: obs.type,
-              title: obs.title,
-              narrative: obs.narrative,
-              facts: obs.facts,
-              concepts: obs.concepts,
-              filesModified: obs.filesModified,
-              createdAt: obs.createdAt,
-              status: obs.status,
-              source: obs.source,
-            }));
-          const generated = engine.generateFromObservations(observations);
-          const skill = generated.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
-          if (!skill) {
-            emitError(`Skill "${name}" not found`, asJson);
-            return;
-          }
-          emitResult({ project, skill }, skill.content, asJson);
-          return;
-        }
-
-        default:
-          console.log('Memorix Skills Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix skills list');
-          console.log('  memorix skills generate [--write --target codex]');
-          console.log('  memorix skills show --name <skill>');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
-
+              id: obs.id,
+              entityName: obs.entityName,
+              type: obs.type,
+              title: obs.title,
+              narrative: obs.narrative,
+              facts: obs.facts,
+              concepts: obs.concepts,
+              filesModified: obs.filesModified,
+              createdAt: obs.createdAt,
+              status: obs.status,
+              source: obs.source,
+            }));
+          const generated = engine.generateFromObservations(observations);
+          const skill = generated.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
+          if (!skill) {
+            emitError(`Skill "${name}" not found`, asJson);
+            return;
+          }
+          emitResult({ project, skill }, skill.content, asJson);
+          return;
+        }
+
+        default:
+          console.log('Memorix Skills Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix skills list');
+          console.log('  memorix skills generate [--write --target codex]');
+          console.log('  memorix skills show --name <skill>');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});
+