memorix 1.2.1 → 1.2.2

package/src/cli/commands/task.ts

@@ -1,192 +1,201 @@
-import { defineCommand } from 'citty';
-import { emitError, emitResult, getCliProjectContext, parseCsvList, parseOptionalJsonObject, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'task',
-    description: 'Create, claim, complete, and inspect team tasks',
-  },
-  args: {
-    description: { type: 'string', description: 'Task description (for create)' },
-    deps: { type: 'string', description: 'Comma-separated dependency task IDs' },
-    taskId: { type: 'string', description: 'Task ID for claim, complete, fail, or release' },
-    agentId: { type: 'string', description: 'Agent ID for claim, complete, fail, release, or agent-aware list' },
-    result: { type: 'string', description: 'Completion or failure summary' },
-    status: { type: 'string', description: 'Filter by status for list' },
-    available: { type: 'boolean', description: 'Show only claimable tasks' },
-    metadata: { type: 'string', description: 'JSON metadata object for create' },
-    requiredRole: { type: 'string', description: 'Required role for this task' },
-    preferredRole: { type: 'string', description: 'Preferred role for this task' },
-    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 } = await getCliProjectContext();
-
-      switch (action) {
-        case 'create': {
-          if (!args.description) {
-            emitError('description is required for "memorix task create"', asJson);
+import { defineCommand } from 'citty';
+import {
+  emitError,
+  emitResult,
+  getCliProjectContext,
+  parseCsvList,
+  parseOptionalJsonObject,
+  resolveCliActorId,
+  shortId,
+} from './operator-shared.js';
+
+export default defineCommand({
+  meta: {
+    name: 'task',
+    description: 'Create, claim, complete, and inspect team tasks',
+  },
+  args: {
+    description: { type: 'string', description: 'Task description (for create)' },
+    deps: { type: 'string', description: 'Comma-separated dependency task IDs' },
+    taskId: { type: 'string', description: 'Task ID for claim, complete, fail, or release' },
+    agentId: { type: 'string', description: 'Agent ID for claim, complete, fail, release, or agent-aware list' },
+    result: { type: 'string', description: 'Completion or failure summary' },
+    status: { type: 'string', description: 'Filter by status for list' },
+    available: { type: 'boolean', description: 'Show only claimable tasks' },
+    metadata: { type: 'string', description: 'JSON metadata object for create' },
+    requiredRole: { type: 'string', description: 'Required role for this task' },
+    preferredRole: { type: 'string', description: 'Preferred role for this task' },
+    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 'create': {
+          if (!args.description) {
+            emitError('description is required for "memorix task create"', asJson);
+            return;
+          }
+
+          const metadata = parseOptionalJsonObject(args.metadata as string | undefined, 'metadata');
+          if (metadata) {
+            const { checkPipelineGuards } = await import('../../orchestrate/planner.js');
+            const guard = checkPipelineGuards({
+              existingTasks: teamStore.listTasks(project.id),
+              newTaskMeta: metadata,
+            });
+            if (!guard.allowed) {
+              emitError(guard.reason, asJson);
+              return;
+            }
+          }
+
+          const task = teamStore.createTask({
+            projectId: project.id,
+            description: args.description as string,
+            deps: parseCsvList(args.deps as string | undefined),
+            metadata,
+            createdBy: agentId,
+            requiredRole: args.requiredRole as string | undefined,
+            preferredRole: args.preferredRole as string | undefined,
+          });
+          const deps = teamStore.getTaskDeps(task.task_id);
+          emitResult(
+            { project, task, deps },
+            `Task created: ${shortId(task.task_id)} "${task.description}"${deps.length > 0 ? ` (${deps.length} dep)` : ''}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'claim': {
+          if (!args.taskId || !agentId) {
+            emitError('taskId and an active CLI identity or agentId are required for "memorix task claim"', asJson);
             return;
           }
-
-          const metadata = parseOptionalJsonObject(args.metadata as string | undefined, 'metadata');
-          if (metadata) {
-            const { checkPipelineGuards } = await import('../../orchestrate/planner.js');
-            const guard = checkPipelineGuards({
-              existingTasks: teamStore.listTasks(project.id),
-              newTaskMeta: metadata,
-            });
-            if (!guard.allowed) {
-              emitError(guard.reason, asJson);
-              return;
-            }
-          }
-
-          const task = teamStore.createTask({
-            projectId: project.id,
-            description: args.description as string,
-            deps: parseCsvList(args.deps as string | undefined),
-            metadata,
-            createdBy: args.agentId as string | undefined,
-            requiredRole: args.requiredRole as string | undefined,
-            preferredRole: args.preferredRole as string | undefined,
-          });
-          const deps = teamStore.getTaskDeps(task.task_id);
-          emitResult(
-            { project, task, deps },
-            `Task created: ${shortId(task.task_id)} "${task.description}"${deps.length > 0 ? ` (${deps.length} dep)` : ''}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'claim': {
-          if (!args.taskId || !args.agentId) {
-            emitError('taskId and agentId are required for "memorix task claim"', asJson);
-            return;
-          }
-          const result = teamStore.claimTask(args.taskId as string, args.agentId as string);
-          if (!result.success) {
-            emitError(result.reason ?? 'Unable to claim task', asJson);
-            return;
-          }
-          emitResult(
-            { project, result },
-            `Task claimed: ${result.task?.description ?? args.taskId}${result.hint ? `\nHint: ${result.hint}` : ''}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'complete': {
-          if (!args.taskId || !args.agentId || !args.result) {
-            emitError('taskId, agentId, and result are required for "memorix task complete"', asJson);
-            return;
-          }
-          const result = teamStore.completeTask(args.taskId as string, args.agentId as string, args.result as string);
-          if (!result.success) {
-            emitError(result.reason ?? 'Unable to complete task', asJson);
-            return;
-          }
-          emitResult(
-            { project, task: teamStore.getTask(args.taskId as string), result: args.result },
-            `Task completed: ${shortId(args.taskId as string)}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'fail': {
-          if (!args.taskId || !args.agentId || !args.result) {
-            emitError('taskId, agentId, and result are required for "memorix task fail"', asJson);
-            return;
-          }
-          const result = teamStore.failTask(args.taskId as string, args.agentId as string, args.result as string);
-          if (!result.success) {
-            emitError(result.reason ?? 'Unable to fail task', asJson);
+          const result = teamStore.claimTask(args.taskId as string, agentId);
+          if (!result.success) {
+            emitError(result.reason ?? 'Unable to claim task', asJson);
+            return;
+          }
+          emitResult(
+            { project, result },
+            `Task claimed: ${result.task?.description ?? args.taskId}${result.hint ? `\nHint: ${result.hint}` : ''}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'complete': {
+          if (!args.taskId || !agentId || !args.result) {
+            emitError('taskId, result, and an active CLI identity or agentId are required for "memorix task complete"', asJson);
             return;
           }
-          emitResult(
-            { project, task: teamStore.getTask(args.taskId as string), result: args.result },
-            `Task failed: ${shortId(args.taskId as string)}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'release': {
-          if (!args.taskId || !args.agentId) {
-            emitError('taskId and agentId are required for "memorix task release"', asJson);
+          const result = teamStore.completeTask(args.taskId as string, agentId, args.result as string);
+          if (!result.success) {
+            emitError(result.reason ?? 'Unable to complete task', asJson);
+            return;
+          }
+          emitResult(
+            { project, task: teamStore.getTask(args.taskId as string), result: args.result },
+            `Task completed: ${shortId(args.taskId as string)}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'fail': {
+          if (!args.taskId || !agentId || !args.result) {
+            emitError('taskId, result, and an active CLI identity or agentId are required for "memorix task fail"', asJson);
             return;
           }
-          const result = teamStore.releaseTask(args.taskId as string, args.agentId as string);
-          if (!result.success) {
-            emitError(result.reason ?? 'Unable to release task', asJson);
+          const result = teamStore.failTask(args.taskId as string, agentId, args.result as string);
+          if (!result.success) {
+            emitError(result.reason ?? 'Unable to fail task', asJson);
+            return;
+          }
+          emitResult(
+            { project, task: teamStore.getTask(args.taskId as string), result: args.result },
+            `Task failed: ${shortId(args.taskId as string)}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'release': {
+          if (!args.taskId || !agentId) {
+            emitError('taskId and an active CLI identity or agentId are required for "memorix task release"', asJson);
             return;
           }
-          emitResult(
-            { project, task: teamStore.getTask(args.taskId as string) },
-            `Task released: ${shortId(args.taskId as string)}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'list': {
-          const tasks =
-            args.available && args.agentId
-              ? teamStore.listTasksForAgent(project.id, args.agentId as string)
-              : teamStore.listTasks(
-                  project.id,
-                  args.available
-                    ? { available: true }
-                    : args.status
-                      ? { status: args.status as string }
-                      : undefined,
-                );
-          const payload = tasks.map((task) => ({
-            ...task,
-            deps: teamStore.getTaskDeps(task.task_id),
-          }));
-          emitResult(
-            { project, tasks: payload },
-            tasks.length === 0
-              ? 'No tasks found.'
-              : payload
-                  .map((task) => {
-                    const assignee = task.assignee_agent_id
-                      ? teamStore.getAgent(task.assignee_agent_id)?.name ?? shortId(task.assignee_agent_id)
-                      : 'unassigned';
-                    const roleTag = task.required_role
-                      ? `[${task.required_role}${task.preferred_role && task.preferred_role !== task.required_role ? ` -> ${task.preferred_role}` : ''}]`
-                      : task.preferred_role
-                        ? `[~${task.preferred_role}]`
-                        : '';
-                    return `- ${task.status}: ${shortId(task.task_id)} "${task.description}" - ${assignee} ${roleTag}`.trim();
-                  })
-                  .join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Task Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix task create --description "..." [--agentId <id>] [--deps id1,id2]');
-          console.log('  memorix task claim --taskId <id> --agentId <id>');
-          console.log('  memorix task complete --taskId <id> --agentId <id> --result "..."');
-          console.log('  memorix task fail --taskId <id> --agentId <id> --result "..."');
-          console.log('  memorix task release --taskId <id> --agentId <id>');
-          console.log('  memorix task list [--status pending|in_progress|completed|failed] [--available --agentId <id>]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+          const result = teamStore.releaseTask(args.taskId as string, agentId);
+          if (!result.success) {
+            emitError(result.reason ?? 'Unable to release task', asJson);
+            return;
+          }
+          emitResult(
+            { project, task: teamStore.getTask(args.taskId as string) },
+            `Task released: ${shortId(args.taskId as string)}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'list': {
+          const tasks =
+            args.available && agentId
+              ? teamStore.listTasksForAgent(project.id, agentId)
+              : teamStore.listTasks(
+                  project.id,
+                  args.available
+                    ? { available: true }
+                    : args.status
+                      ? { status: args.status as string }
+                      : undefined,
+                );
+          const payload = tasks.map((task) => ({
+            ...task,
+            deps: teamStore.getTaskDeps(task.task_id),
+          }));
+          emitResult(
+            { project, tasks: payload },
+            tasks.length === 0
+              ? 'No tasks found.'
+              : payload
+                  .map((task) => {
+                    const assignee = task.assignee_agent_id
+                      ? teamStore.getAgent(task.assignee_agent_id)?.name ?? shortId(task.assignee_agent_id)
+                      : 'unassigned';
+                    const roleTag = task.required_role
+                      ? `[${task.required_role}${task.preferred_role && task.preferred_role !== task.required_role ? ` -> ${task.preferred_role}` : ''}]`
+                      : task.preferred_role
+                        ? `[~${task.preferred_role}]`
+                        : '';
+                    return `- ${task.status}: ${shortId(task.task_id)} "${task.description}" - ${assignee} ${roleTag}`.trim();
+                  })
+                  .join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Task Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix task create --description "..." [--agentId <id>] [--deps id1,id2]');
+          console.log('  memorix task claim --taskId <id> --agentId <id>');
+          console.log('  memorix task complete --taskId <id> --agentId <id> --result "..."');
+          console.log('  memorix task fail --taskId <id> --agentId <id> --result "..."');
+          console.log('  memorix task release --taskId <id> --agentId <id>');
+          console.log('  memorix task list [--status pending|in_progress|completed|failed] [--available --agentId <id>]');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

package/src/cli/commands/team.ts

@@ -1,6 +1,7 @@
 import { defineCommand } from 'citty';
 import { AGENT_TYPE_ROLE_MAP } from '../../team/team-store.js';
-import { emitError, emitResult, getCliProjectContext, parseCsvList, parsePositiveInt, shortId } from './operator-shared.js';
+import { clearCliIdentity } from '../identity.js';
+import { emitError, emitResult, getCliProjectContext, parseCsvList, parsePositiveInt, resolveCliActorId, shortId } from './operator-shared.js';
 
 export default defineCommand({
   meta: {
@@ -27,7 +28,8 @@ export default defineCommand({
     const asJson = !!args.json;
 
     try {
-      const { project, teamStore } = await getCliProjectContext();
+      const { project, dataDir, teamStore, identity } = await getCliProjectContext();
+      const selectedAgentId = resolveCliActorId(args.agentId, identity);
 
       switch (action) {
         case 'join': {
@@ -53,20 +55,22 @@ export default defineCommand({
         }
 
         case 'leave': {
-          const agentId = args.agentId as string | undefined;
-          if (!agentId) {
-            emitError('agentId is required for "memorix team leave"', asJson);
+          if (!selectedAgentId) {
+            emitError('an active CLI identity or agentId is required for "memorix team leave"', asJson);
             return;
           }
-          const left = teamStore.leaveAgent(agentId);
-          const releasedLocks = teamStore.releaseAllLocks(agentId);
-          const releasedTasks = teamStore.releaseTasksByAgent(agentId);
+          const left = teamStore.leaveAgent(selectedAgentId);
+          const releasedLocks = teamStore.releaseAllLocks(selectedAgentId);
+          const releasedTasks = teamStore.releaseTasksByAgent(selectedAgentId);
           if (!left) {
-            emitError(`Agent "${agentId}" not found`, asJson);
+            emitError(`Agent "${selectedAgentId}" not found`, asJson);
             return;
           }
+          if (identity?.agentId === selectedAgentId) {
+            await clearCliIdentity(dataDir);
+          }
           emitResult(
-            { project, agentId, releasedLocks, releasedTasks },
+            { project, agentId: selectedAgentId, releasedLocks, releasedTasks },
             `Left team: released ${releasedLocks} lock(s), ${releasedTasks} task(s)`,
             asJson,
           );

package/src/cli/commands/transfer.ts

@@ -1,73 +1,126 @@
 import { defineCommand } from 'citty';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
 import { exportAsJson, exportAsMarkdown, importFromJson } from '../../memory/export-import.js';
 import { emitError, emitResult, getCliProjectContext } from './operator-shared.js';
 
-export default defineCommand({
-  meta: {
-    name: 'transfer',
-    description: 'Export or import project memory snapshots',
-  },
-  args: {
-    format: { type: 'string', description: 'Export format: json or markdown' },
-    data: { type: 'string', description: 'JSON payload from a previous export' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
+async function readStandardInput(): Promise<string> {
+  return new Promise((resolve, reject) => {
+    let content = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      content += chunk;
+    });
+    process.stdin.on('end', () => resolve(content));
+    process.stdin.on('error', reject);
+  });
+}
 
-    try {
-      const { project, dataDir } = await getCliProjectContext();
+async function readImportPayload(args: Record<string, unknown>, projectRoot: string): Promise<string> {
+  const data = typeof args.data === 'string' ? args.data.trim() : '';
+  const file = typeof args.file === 'string' ? args.file.trim() : '';
+  const readFromStdin = args.stdin === true || data === '-';
+  const sources = Number(Boolean(data && data !== '-')) + Number(Boolean(file)) + Number(readFromStdin);
+  if (sources !== 1) {
+    throw new Error('Choose exactly one import source: --data <json>, --file <path>, or --stdin.');
+  }
+  if (readFromStdin) return readStandardInput();
+  if (file) return fs.readFile(path.resolve(projectRoot, file), 'utf8');
+  return data;
+}
 
-      switch (action) {
+async function writeExportPayload(projectRoot: string, output: string, payload: string): Promise<string> {
+  const outputPath = path.resolve(projectRoot, output);
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, payload, 'utf8');
+  return outputPath;
+}
+
+export default defineCommand({
+  meta: {
+    name: 'transfer',
+    description: 'Export or import project memory snapshots',
+  },
+  args: {
+    format: { type: 'string', description: 'Export format: json or markdown' },
+    data: { type: 'string', description: 'JSON payload from a previous export' },
+    file: { type: 'string', description: 'File containing a JSON payload to import' },
+    stdin: { type: 'boolean', description: 'Read a JSON import payload from standard input' },
+    out: { type: 'string', description: 'Write the export payload to this file instead of stdout' },
+    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, dataDir, reader } = await getCliProjectContext();
+
+      switch (action) {
         case 'export': {
           const format = (args.format as string | undefined) === 'markdown' ? 'markdown' : 'json';
           if (format === 'markdown') {
-            const markdown = await exportAsMarkdown(dataDir, project.id);
+            const markdown = await exportAsMarkdown(dataDir, project.id, reader);
+            const output = (args.out as string | undefined)?.trim();
+            if (output) {
+              const outputPath = await writeExportPayload(project.rootPath, output, markdown);
+              emitResult({ project, format, outputPath }, `Export written: ${outputPath}`, asJson);
+              return;
+            }
             emitResult({ project, format, markdown }, markdown, asJson);
             return;
           }
-          const exported = await exportAsJson(dataDir, project.id);
-          emitResult(
-            { project, format, export: exported },
-            JSON.stringify(exported, null, 2),
-            asJson,
-          );
-          return;
-        }
-
-        case 'import': {
-          const raw = (args.data as string | undefined)?.trim();
-          if (!raw) {
-            emitError('data is required for "memorix transfer import"', asJson);
-            return;
-          }
-          let parsed: Parameters<typeof importFromJson>[1];
-          try {
-            parsed = JSON.parse(raw);
-          } catch (error) {
-            emitError(`Invalid JSON import payload: ${error instanceof Error ? error.message : String(error)}`, asJson);
+          const exported = await exportAsJson(dataDir, project.id, reader);
+          const serialized = JSON.stringify(exported, null, 2);
+          const output = (args.out as string | undefined)?.trim();
+          if (output) {
+            const outputPath = await writeExportPayload(project.rootPath, output, `${serialized}\n`);
+            emitResult(
+              { project, format, outputPath, stats: exported.stats },
+              `Export written: ${outputPath}`,
+              asJson,
+            );
             return;
           }
-          const result = await importFromJson(dataDir, parsed);
           emitResult(
-            { project, result },
-            `Import complete: ${result.observationsImported} observation(s), ${result.sessionsImported} session(s), ${result.skipped} skipped.`,
+            { project, format, export: exported },
+            serialized,
             asJson,
           );
-          return;
-        }
-
-        default:
-          console.log('Memorix Transfer Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix transfer export [--format json|markdown]');
+          return;
+        }
+
+        case 'import': {
+          const raw = (await readImportPayload(args as Record<string, unknown>, project.rootPath)).trim();
+          if (!raw) throw new Error('Import payload is empty.');
+          let parsed: Parameters<typeof importFromJson>[1];
+          try {
+            parsed = JSON.parse(raw);
+          } catch (error) {
+            emitError(`Invalid JSON import payload: ${error instanceof Error ? error.message : String(error)}`, asJson);
+            return;
+          }
+          const result = await importFromJson(dataDir, parsed);
+          emitResult(
+            { project, result },
+            `Import complete: ${result.observationsImported} observation(s), ${result.sessionsImported} session(s), ${result.skipped} skipped.`,
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Transfer Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix transfer export [--format json|markdown] [--out ./.memorix-export.json]');
+          console.log('  memorix transfer import --file ./.memorix-export.json');
+          console.log('  memorix transfer import --stdin');
           console.log('  memorix transfer import --data "<json>"');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
-
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});
+