@masslessai/push-todo 4.1.8 → 4.1.9

package/lib/api.js

@@ -381,4 +381,144 @@ export async function learnVocabulary(todoId, keywords) {
   return response.json();
 }
 
+// ==================== Phase 3: Extended Skill CLI ====================
+
+/**
+ * Report structured progress for a running task.
+ * Called by the agent during execution to push activity updates to Supabase.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {Object} options - Progress details
+ * @param {string} options.phase - Current phase (e.g., "testing", "implementing")
+ * @param {string} [options.detail] - Human-readable detail
+ * @returns {Promise<Object>}
+ */
+export async function reportProgress(todoId, { phase, detail }) {
+  const response = await apiRequest('update-task-execution', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      todoId,
+      event: {
+        type: 'progress',
+        timestamp: new Date().toISOString(),
+        summary: detail ? `${phase}: ${detail}` : phase,
+        phase
+      }
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to report progress: ${text}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Update execution status/phase for a running task.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {string} status - New phase label (e.g., "implementing", "testing", "reviewing")
+ * @returns {Promise<Object>}
+ */
+export async function updateStatus(todoId, status) {
+  const response = await apiRequest('update-task-execution', {
+    method: 'PATCH',
+    body: JSON.stringify({
+      todoId,
+      event: {
+        type: 'progress',
+        timestamp: new Date().toISOString(),
+        summary: `Phase: ${status}`
+      }
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to update status: ${text}`);
+  }
+
+  return response.json();
+}
+
+/**
+ * Check for messages from the human for a running task.
+ * Returns pending messages or empty array.
+ *
+ * @param {string} todoId - UUID of the task
+ * @returns {Promise<Object[]>} Array of pending messages
+ */
+export async function checkMessages(todoId) {
+  const params = new URLSearchParams({ todo_id: todoId, direction: 'to_agent' });
+  const response = await apiRequest(`task-messages?${params}`, {
+    method: 'GET'
+  });
+
+  if (!response.ok) {
+    // 404 = no task_messages table/function yet — return empty gracefully
+    if (response.status === 404) return [];
+    const text = await response.text();
+    throw new Error(`Failed to check messages: ${text}`);
+  }
+
+  const result = await response.json();
+  return result.messages || [];
+}
+
+/**
+ * Request input from the human for a running task.
+ * Posts a question and polls until the human responds or timeout.
+ *
+ * @param {string} todoId - UUID of the task
+ * @param {string} question - Question to ask the human
+ * @param {number} [timeoutMs=300000] - Timeout in ms (default 5 min)
+ * @returns {Promise<string|null>} Human's response or null if timeout
+ */
+export async function requestInput(todoId, question, timeoutMs = 300000) {
+  // Post the question
+  const postResponse = await apiRequest('task-messages', {
+    method: 'POST',
+    body: JSON.stringify({
+      todo_id: todoId,
+      direction: 'to_human',
+      message: question,
+      type: 'input_request'
+    })
+  });
+
+  if (!postResponse.ok) {
+    // 404 = task-messages endpoint not deployed yet
+    if (postResponse.status === 404) {
+      console.error('Message system not available yet. Use [push-confirm] pattern instead.');
+      return null;
+    }
+    const text = await postResponse.text();
+    throw new Error(`Failed to request input: ${text}`);
+  }
+
+  const { message_id } = await postResponse.json();
+
+  // Poll for response
+  const startTime = Date.now();
+  const pollInterval = 5000; // 5s
+
+  while (Date.now() - startTime < timeoutMs) {
+    await new Promise(resolve => setTimeout(resolve, pollInterval));
+
+    const checkResponse = await apiRequest(`task-messages?message_id=${message_id}&direction=to_agent`, {
+      method: 'GET'
+    });
+
+    if (checkResponse.ok) {
+      const result = await checkResponse.json();
+      const reply = (result.messages || []).find(m => m.in_reply_to === message_id);
+      if (reply) return reply.message;
+    }
+  }
+
+  return null; // Timeout
+}
+
 export { API_BASE };

package/lib/cli.js

@@ -68,6 +68,13 @@ ${bold('OPTIONS:')}
   --view-screenshot <idx>          Open screenshot for viewing (index or filename)
   --learn-vocabulary <uuid>        Contribute vocabulary for a task
   --keywords <terms>               Comma-separated vocabulary terms (with --learn-vocabulary)
+  --report-progress <uuid>         Report progress for a running task
+  --phase <name>                   Phase name (with --report-progress)
+  --detail <text>                  Detail text (with --report-progress)
+  --update-status <uuid>           Update execution phase for a running task
+  --check-messages <uuid>          Check for messages from the human
+  --request-input <uuid>           Request input from the human (blocking)
+  --question <text>                Question to ask (with --request-input)
   --set-batch-size <N>             Set max tasks for batch queue (1-20)
   --daemon-status                  Show daemon status
   --daemon-start                   Start daemon manually
@@ -175,6 +182,14 @@ const options = {
   'create-todo': { type: 'string' },
   'notify': { type: 'string' },
   'queue-execution': { type: 'string' },
+  // Skill CLI options (Phase 3)
+  'report-progress': { type: 'string' },
+  'phase': { type: 'string' },
+  'detail': { type: 'string' },
+  'update-status': { type: 'string' },
+  'check-messages': { type: 'string' },
+  'request-input': { type: 'string' },
+  'question': { type: 'string' },
 };
 
 /**
@@ -512,6 +527,91 @@ export async function run(argv) {
     return;
   }
 
+  // Handle --report-progress (report structured progress for a running task)
+  if (values['report-progress']) {
+    try {
+      const result = await api.reportProgress(values['report-progress'], {
+        phase: values.phase || 'progress',
+        detail: values.detail || undefined,
+      });
+      if (values.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(green('Progress reported.'));
+      }
+    } catch (error) {
+      console.error(red(`Failed to report progress: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --update-status (update execution phase for a running task)
+  if (values['update-status']) {
+    const status = positionals[0] || values.phase;
+    if (!status) {
+      console.error(red('Status required. Usage: --update-status <uuid> <status>'));
+      process.exit(1);
+    }
+    try {
+      const result = await api.updateStatus(values['update-status'], status);
+      if (values.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(green(`Status updated to: ${status}`));
+      }
+    } catch (error) {
+      console.error(red(`Failed to update status: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --check-messages (check for messages from the human)
+  if (values['check-messages']) {
+    try {
+      const messages = await api.checkMessages(values['check-messages']);
+      if (values.json) {
+        console.log(JSON.stringify(messages, null, 2));
+      } else if (messages.length === 0) {
+        console.log(dim('No pending messages.'));
+      } else {
+        for (const msg of messages) {
+          console.log(`[${msg.created_at || 'unknown'}] ${msg.message}`);
+        }
+      }
+    } catch (error) {
+      console.error(red(`Failed to check messages: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
+  // Handle --request-input (ask the human a question, poll for response)
+  if (values['request-input']) {
+    const question = values.question || positionals.slice(0).join(' ');
+    if (!question) {
+      console.error(red('--question required with --request-input'));
+      console.error('Usage: --request-input <uuid> --question "What should I do?"');
+      process.exit(1);
+    }
+    try {
+      console.log(dim('Waiting for human response (timeout: 5 min)...'));
+      const reply = await api.requestInput(values['request-input'], question);
+      if (values.json) {
+        console.log(JSON.stringify({ reply }, null, 2));
+      } else if (reply) {
+        console.log(green('Response:'), reply);
+      } else {
+        console.log(dim('No response received (timeout).'));
+      }
+    } catch (error) {
+      console.error(red(`Failed to request input: ${error.message}`));
+      process.exit(1);
+    }
+    return;
+  }
+
   // Auto-start daemon on every command (self-healing behavior)
   ensureDaemonRunning();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@masslessai/push-todo",
-  "version": "4.1.8",
+  "version": "4.1.9",
   "description": "Voice tasks from Push iOS app for Claude Code",
   "type": "module",
   "bin": {