@artyfacts/claude 1.3.24 → 1.3.26

package/dist/index.mjs

@@ -14,7 +14,7 @@ import {
   promptForApiKey,
   runDeviceAuth,
   saveCredentials
-} from "./chunk-OISOOGKZ.mjs";
+} from "./chunk-7QRIXWMF.mjs";
 
 // node_modules/@anthropic-ai/sdk/internal/tslib.mjs
 function __classPrivateFieldSet(receiver, state, value, kind, f) {
@@ -4220,7 +4220,7 @@ var schemas = {
     }
   },
   // ---------------------------------------------------------------------------
-  // Task Tools
+  // Task Tools (v2 - tasks are first-class entities)
   // ---------------------------------------------------------------------------
   get_task: {
     name: "get_task",
@@ -4230,7 +4230,7 @@ var schemas = {
       properties: {
         task_id: {
           type: "string",
-          description: "The task UUID or section_id"
+          description: "The task UUID"
         }
       },
       required: ["task_id"]
@@ -4238,13 +4238,13 @@ var schemas = {
   },
   list_tasks: {
     name: "list_tasks",
-    description: "List tasks with optional filters.",
+    description: "List tasks from the queue. Returns tasks from the tasks table with goal context.",
     input_schema: {
       type: "object",
       properties: {
-        artifact_id: {
+        goal_id: {
           type: "string",
-          description: "Filter by artifact"
+          description: "Filter by goal ID"
         },
         status: {
           type: "string",
@@ -4264,21 +4264,54 @@ var schemas = {
       required: []
     }
   },
+  create_goal: {
+    name: "create_goal",
+    description: "Create a new goal (v2). Goals are first-class entities that contain tasks.",
+    input_schema: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Goal title"
+        },
+        description: {
+          type: "string",
+          description: "Goal description and objectives"
+        },
+        priority: {
+          type: "string",
+          enum: ["low", "medium", "high", "urgent"],
+          default: "medium",
+          description: "Priority level"
+        },
+        target_date: {
+          type: "string",
+          description: "Optional: target completion date (ISO format)"
+        },
+        tags: {
+          type: "array",
+          items: { type: "string" },
+          description: "Optional: tags for categorization"
+        }
+      },
+      required: ["title"]
+    }
+  },
   create_task: {
     name: "create_task",
-    description: "Create a new task on an artifact.",
+    description: "Create a new task under a goal.",
     input_schema: {
       type: "object",
       properties: {
-        artifact_id: {
+        goal_id: {
           type: "string",
-          description: "The artifact to add the task to"
+          description: "The goal UUID to add the task to"
         },
-        heading: {
+        title: {
           type: "string",
-          description: "Task title/heading"
+          description: "Task title"
         },
-        content: {
+        description: {
           type: "string",
           description: "Task description and requirements"
         },
@@ -4289,26 +4322,41 @@ var schemas = {
         depends_on: {
           type: "array",
           items: { type: "string" },
-          description: "Optional: section_ids of tasks this depends on"
+          description: "Optional: task IDs this depends on"
         },
         priority: {
-          type: "number",
-          enum: [1, 2, 3],
-          description: "Optional: priority (1=high, 2=medium, 3=low)"
+          type: "string",
+          enum: ["low", "medium", "high"],
+          default: "medium",
+          description: "Optional: priority level"
         }
       },
-      required: ["artifact_id", "heading", "content"]
+      required: ["goal_id", "title"]
+    }
+  },
+  claim_task: {
+    name: "claim_task",
+    description: "Claim a task for execution. Sets status to in_progress.",
+    input_schema: {
+      type: "object",
+      properties: {
+        task_id: {
+          type: "string",
+          description: "The task UUID to claim"
+        }
+      },
+      required: ["task_id"]
     }
   },
   complete_task: {
     name: "complete_task",
-    description: "Mark a task as completed with output.",
+    description: "Mark a task as completed. Returns list of unblocked tasks that can now be worked on.",
     input_schema: {
       type: "object",
       properties: {
         task_id: {
           type: "string",
-          description: "The task UUID or section_id"
+          description: "The task UUID"
         },
         output: {
           type: "string",
@@ -4334,7 +4382,7 @@ var schemas = {
       properties: {
         task_id: {
           type: "string",
-          description: "The task UUID or section_id"
+          description: "The task UUID"
         },
         reason: {
           type: "string",
@@ -4350,6 +4398,56 @@ var schemas = {
     }
   },
   // ---------------------------------------------------------------------------
+  // Inbox Tools (v2)
+  // ---------------------------------------------------------------------------
+  list_inbox: {
+    name: "list_inbox",
+    description: "List pending inbox items (decisions, approvals, reviews).",
+    input_schema: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["pending", "resolved"],
+          description: "Filter by status"
+        },
+        kind: {
+          type: "string",
+          enum: ["decision", "approval", "review"],
+          description: "Filter by type"
+        },
+        limit: {
+          type: "number",
+          default: 20,
+          description: "Max results"
+        }
+      },
+      required: []
+    }
+  },
+  resolve_inbox: {
+    name: "resolve_inbox",
+    description: "Resolve an inbox item with a decision. May trigger auto-execution.",
+    input_schema: {
+      type: "object",
+      properties: {
+        inbox_id: {
+          type: "string",
+          description: "The inbox item UUID"
+        },
+        decision: {
+          type: "string",
+          description: "The decision/resolution"
+        },
+        notes: {
+          type: "string",
+          description: "Optional: additional notes"
+        }
+      },
+      required: ["inbox_id", "decision"]
+    }
+  },
+  // ---------------------------------------------------------------------------
   // Blocker Tools
   // ---------------------------------------------------------------------------
   get_blocker: {
@@ -4504,7 +4602,9 @@ var permissionToTools = {
   "agents:read": ["get_agent", "list_agents"],
   "agents:write": ["create_agent", "update_agent"],
   "tasks:read": ["get_task", "list_tasks"],
-  "tasks:write": ["create_task", "complete_task", "block_task"],
+  "tasks:write": ["create_task", "claim_task", "complete_task", "block_task"],
+  "inbox:read": ["list_inbox"],
+  "inbox:write": ["resolve_inbox"],
   "blockers:read": ["get_blocker", "list_blockers"],
   "blockers:write": ["create_blocker", "resolve_blocker"],
   "org:read": ["get_org_context", "get_project", "list_projects"]
@@ -4737,37 +4837,55 @@ var getTaskHandler = async (args, client) => {
 var listTasksHandler = async (args, client) => {
   try {
     const params = new URLSearchParams();
-    if (args.artifact_id) params.set("artifact_id", String(args.artifact_id));
+    if (args.goal_id) params.set("goal_id", String(args.goal_id));
     if (args.status) params.set("status", String(args.status));
     if (args.assignee) params.set("assignee", String(args.assignee));
     if (args.limit) params.set("limit", String(args.limit));
     const query = params.toString();
-    const path2 = `/tasks${query ? `?${query}` : ""}`;
+    const path2 = `/tasks/queue${query ? `?${query}` : ""}`;
     const data = await client.get(path2);
     return { success: true, data };
   } catch (error) {
     return { success: false, error: String(error) };
   }
 };
+var createGoalHandler = async (args, client) => {
+  try {
+    const data = await client.post("/goals", {
+      title: args.title,
+      description: args.description,
+      priority: args.priority || "medium",
+      target_date: args.target_date,
+      tags: args.tags
+    });
+    return { success: true, data };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+};
 var createTaskHandler = async (args, client) => {
   try {
-    const data = await client.post(`/artifacts/${args.artifact_id}/sections`, {
-      section_id: `task-${Date.now()}`,
-      heading: args.heading,
-      content: args.content,
-      type: "task",
-      task_status: "pending",
+    const data = await client.post("/tasks", {
+      goal_id: args.goal_id,
+      title: args.title,
+      description: args.description,
       assignee_agent_id: args.assignee,
       depends_on: args.depends_on,
-      priority: args.priority,
-      agent_id: "system",
-      agent_name: "System"
+      priority: args.priority || "medium"
     });
     return { success: true, data };
   } catch (error) {
     return { success: false, error: String(error) };
   }
 };
+var claimTaskHandler = async (args, client) => {
+  try {
+    const data = await client.post(`/tasks/${args.task_id}/claim`, {});
+    return { success: true, data };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+};
 var completeTaskHandler = async (args, client) => {
   try {
     const data = await client.post(`/tasks/${args.task_id}/complete`, {
@@ -4782,7 +4900,7 @@ var completeTaskHandler = async (args, client) => {
 };
 var blockTaskHandler = async (args, client) => {
   try {
-    const data = await client.post(`/tasks/${args.task_id}/fail`, {
+    const data = await client.post(`/tasks/${args.task_id}/block`, {
       reason: args.reason,
       blocker_type: args.blocker_type
     });
@@ -4791,6 +4909,31 @@ var blockTaskHandler = async (args, client) => {
     return { success: false, error: String(error) };
   }
 };
+var listInboxHandler = async (args, client) => {
+  try {
+    const params = new URLSearchParams();
+    if (args.status) params.set("status", String(args.status));
+    if (args.kind) params.set("kind", String(args.kind));
+    if (args.limit) params.set("limit", String(args.limit));
+    const query = params.toString();
+    const path2 = `/inbox${query ? `?${query}` : ""}`;
+    const data = await client.get(path2);
+    return { success: true, data };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+};
+var resolveInboxHandler = async (args, client) => {
+  try {
+    const data = await client.post(`/inbox/${args.inbox_id}/resolve`, {
+      decision: args.decision,
+      notes: args.notes
+    });
+    return { success: true, data };
+  } catch (error) {
+    return { success: false, error: String(error) };
+  }
+};
 var getBlockerHandler = async (args, client) => {
   try {
     const data = await client.get(`/blockers/${args.blocker_id}`);
@@ -4886,13 +5029,19 @@ var handlers = {
   list_agents: listAgentsHandler,
   create_agent: createAgentHandler,
   update_agent: updateAgentHandler,
-  // Tasks
+  // Goals (v2)
+  create_goal: createGoalHandler,
+  // Tasks (v2)
   get_task: getTaskHandler,
   list_tasks: listTasksHandler,
   create_task: createTaskHandler,
+  claim_task: claimTaskHandler,
   complete_task: completeTaskHandler,
   block_task: blockTaskHandler,
-  // Blockers
+  // Inbox (v2)
+  list_inbox: listInboxHandler,
+  resolve_inbox: resolveInboxHandler,
+  // Blockers (legacy - kept for compatibility)
   get_blocker: getBlockerHandler,
   list_blockers: listBlockersHandler,
   create_blocker: createBlockerHandler,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artyfacts/claude",
-  "version": "1.3.24",
+  "version": "1.3.26",
   "description": "Claude adapter for Artyfacts - Execute tasks using Claude Code CLI",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
@@ -15,13 +15,6 @@
       "require": "./dist/index.js"
     }
   },
-  "scripts": {
-    "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --watch",
-    "start": "node bin/artyfacts-claude.js",
-    "test": "vitest",
-    "lint": "eslint src/"
-  },
   "keywords": [
     "artyfacts",
     "claude",
@@ -54,5 +47,12 @@
   },
   "engines": {
     "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts src/cli.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/cli.ts --format cjs,esm --dts --watch",
+    "start": "node bin/artyfacts-claude.js",
+    "test": "vitest",
+    "lint": "eslint src/"
   }
-}
+}

package/src/cli.ts

@@ -227,12 +227,16 @@ async function checkAndClaimTasks(
 
     const data = await response.json() as { tasks?: Array<{
       id: string;
-      section_id: string;
-      heading: string;
-      content: string;
-      artifact_id: string;
-      artifact_title?: string;
-      priority?: number;
+      goal_id: string;
+      goal_title?: string;
+      title: string;
+      description?: string;
+      status: string;
+      priority: string;
+      estimated_minutes?: number;
+      agent_id?: string;
+      agent_name?: string;
+      metadata?: Record<string, unknown>;
     }> };
 
     const tasks = data.tasks || [];
@@ -252,15 +256,18 @@ async function checkAndClaimTasks(
       }
 
       // Try to claim the task
-      console.log(`\n[Claiming] ${task.heading}`);
+      console.log(`\n[Claiming] ${task.title} (as ${task.agent_name || task.agent_id || 'unknown'})`);
       
-      // Use UUID (task.id) for claiming - section_id isn't globally unique
+      // Use task.id (UUID) for claiming, include agent_id from task
       const claimResponse = await fetch(`${baseUrl}/tasks/${task.id}/claim`, {
         method: 'POST',
         headers: {
           'Authorization': `Bearer ${apiKey}`,
           'Content-Type': 'application/json',
         },
+        body: JSON.stringify({
+          agent_id: task.agent_id,
+        }),
       });
 
       if (!claimResponse.ok) {
@@ -269,19 +276,17 @@ async function checkAndClaimTasks(
         continue;
       }
 
-      // Get the claimed task data (includes UUID which is globally unique)
-      // Response format: { success: true, task: { id: ..., artifact_id: ..., ... } }
+      // Get the claimed task data
       const claimData = await claimResponse.json().catch((e) => {
         console.log(`  ⚠️ Could not parse claim response: ${e}`);
         return { task: { id: task.id } };
       }) as { 
-        success?: boolean;
-        task?: { id: string; artifact_id?: string };
+        claimed?: boolean;
+        task?: { id: string; goal_id?: string; goal_title?: string };
       };
       
-      // Use UUID for subsequent calls (globally unique, avoids org filter issues)
       const taskUuid = claimData.task?.id || task.id;
-      console.log(`  📎 Using task UUID: ${taskUuid} (from queue: ${task.id})`);  // DEBUG
+      const goalTitle = claimData.task?.goal_title || task.goal_title;
 
       // Successfully claimed - now execute
       activeTasks.add(task.id);
@@ -296,14 +301,20 @@ async function checkAndClaimTasks(
       console.log('  → Executing with Claude...');
 
       try {
-        // Use UUID for context/complete (more reliable than section_id)
+        // Execute the task (v2 schema)
+        const priorityMap: Record<string, 'low' | 'medium' | 'high'> = {
+          'urgent': 'high',
+          'high': 'high',
+          'medium': 'medium',
+          'low': 'low',
+        };
         const result = await executor.execute({
-          taskId: taskUuid,  // Use UUID instead of section_id
-          heading: task.heading,
-          content: task.content,
-          artifactId: task.artifact_id,
-          artifactTitle: task.artifact_title,
-          priority: task.priority,
+          id: taskUuid,
+          title: task.title,
+          description: task.description || '',
+          goalId: task.goal_id,
+          goalTitle: goalTitle,
+          priority: priorityMap[task.priority] || 'medium',
         });
 
         if (result.success) {
@@ -452,36 +463,43 @@ async function runAgent(options: {
     await mcpHandler.handleConnectRequest(event);
   });
 
-  // Handle task assignments
+  // Handle task assignments (v2 schema)
   listener.on<TaskAssignedEvent>('task_assigned', async (event) => {
     const task = event.data;
     
-    // Skip if already processing
-    if (activeTasks.has(task.taskId)) {
+    // v2: use id, fallback to taskId for backwards compatibility
+    const taskId = task.id || task.taskId || '';
+    const taskTitle = task.title || task.heading || 'Untitled Task';
+    const taskDescription = task.description || task.content || '';
+    const goalId = task.goalId || task.artifactId || '';
+    const goalTitle = task.goalTitle || task.artifactTitle;
+    
+    // Skip if already processing or no task ID
+    if (!taskId || activeTasks.has(taskId)) {
       return;
     }
-    activeTasks.add(task.taskId);
+    activeTasks.add(taskId);
 
-    console.log(`\n[Task received] ${task.heading}`);
+    console.log(`\n[Task received] ${taskTitle}`);
     
     if (options.dryRun) {
       console.log('  📋 Dry run - not executing');
-      console.log(`  📄 Artifact: ${task.artifactTitle || task.artifactId}`);
-      console.log(`  📝 Content: ${task.content.substring(0, 100)}...`);
-      activeTasks.delete(task.taskId);
+      console.log(`  📄 Goal: ${goalTitle || goalId}`);
+      console.log(`  📝 Description: ${taskDescription.substring(0, 100)}...`);
+      activeTasks.delete(taskId);
       return;
     }
 
     console.log('  → Executing with Claude...');
 
     try {
-      // Build task context
+      // Build task context (v2)
       const taskContext: TaskContext = {
-        taskId: task.taskId,
-        heading: task.heading,
-        content: task.content,
-        artifactId: task.artifactId,
-        artifactTitle: task.artifactTitle,
+        id: taskId,
+        title: taskTitle,
+        description: taskDescription,
+        goalId: goalId,
+        goalTitle: goalTitle,
         priority: task.priority,
       };
 
@@ -491,13 +509,21 @@ async function runAgent(options: {
       if (result.success) {
         // Complete task via API (Claude may have already done this via MCP tool)
         try {
-          await completeTask({
+          const completionResult = await completeTask({
             baseUrl: options.baseUrl,
             apiKey: credentials.apiKey,
-            taskId: task.taskId,
+            taskId: taskId,
             output: result.output,
             summary: result.summary,
           });
+          
+          // v2: Log unblocked tasks if any
+          if (completionResult.unblocked_tasks && completionResult.unblocked_tasks.length > 0) {
+            console.log(`  → 🔓 Unblocked ${completionResult.unblocked_tasks.length} task(s):`);
+            for (const unblocked of completionResult.unblocked_tasks) {
+              console.log(`     - ${unblocked.title} (${unblocked.id})`);
+            }
+          }
         } catch (err) {
           // Ignore "already complete" - means Claude completed it via MCP
           const errMsg = err instanceof Error ? err.message : String(err);
@@ -514,14 +540,14 @@ async function runAgent(options: {
         await blockTask({
           baseUrl: options.baseUrl,
           apiKey: credentials.apiKey,
-          taskId: task.taskId,
+          taskId: taskId,
           reason: result.error || 'Execution failed',
         });
       }
     } catch (error) {
       console.error(`  → ❌ Error:`, error instanceof Error ? error.message : error);
     } finally {
-      activeTasks.delete(task.taskId);
+      activeTasks.delete(taskId);
     }
   });
 
@@ -556,13 +582,21 @@ async function runAgent(options: {
 // API Helpers
 // ============================================================================
 
+/**
+ * Complete task response type (v2)
+ */
+interface CompleteTaskResponse {
+  task?: { id: string; status: string };
+  unblocked_tasks?: Array<{ id: string; title: string }>;
+}
+
 async function completeTask(options: {
   baseUrl: string;
   apiKey: string;
   taskId: string;
   output: string;
   summary: string;
-}): Promise<void> {
+}): Promise<CompleteTaskResponse> {
   const response = await fetch(`${options.baseUrl}/tasks/${options.taskId}/complete`, {
     method: 'POST',
     headers: {
@@ -570,10 +604,8 @@ async function completeTask(options: {
       'Content-Type': 'application/json',
     },
     body: JSON.stringify({
-      task_status: 'done',
-      completed_at: new Date().toISOString(),
-      summary: options.summary,
-      output: options.output,
+      output_text: options.summary || options.output,
+      output_url: options.output?.startsWith('http') ? options.output : undefined,
     }),
   });
 
@@ -581,6 +613,8 @@ async function completeTask(options: {
     const error = await response.text();
     throw new Error(`Failed to complete task: ${error}`);
   }
+  
+  return response.json() as Promise<CompleteTaskResponse>;
 }
 
 async function blockTask(options: {
@@ -596,8 +630,7 @@ async function blockTask(options: {
       'Content-Type': 'application/json',
     },
     body: JSON.stringify({
-      task_status: 'blocked',
-      blocked_reason: options.reason,
+      reason: options.reason,
     }),
   });