memorix 1.4.3 → 1.4.5

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);
+    }
+  },
+});
+

package/src/cli/commands/task.ts

@@ -1,4 +1,4 @@
-import { defineCommand } from 'citty';
+import { defineCommand } from 'citty';
 import {
   emitError,
   emitResult,
@@ -8,194 +8,194 @@ import {
   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 {
+
+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,
+
+      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': {
+            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 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 (!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;
           }
           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 (!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.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 (!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;
           }
           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 =
+          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);
-    }
-  },
-});
+              : 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);
+    }
+  },
+});