@masslessai/push-todo 3.0.0

package/lib/api.js

@@ -0,0 +1,325 @@
+/**
+ * Supabase API client for Push CLI.
+ *
+ * Handles all HTTP requests to the Push backend.
+ */
+
+import { getApiKey } from './config.js';
+
+const API_BASE = 'https://jxuzqcbqhiaxmfitzxlo.supabase.co/functions/v1';
+
+/**
+ * Make an authenticated API request.
+ *
+ * @param {string} endpoint - API endpoint (without base URL)
+ * @param {Object} options - Fetch options
+ * @returns {Promise<Response>}
+ */
+async function apiRequest(endpoint, options = {}) {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error('No API key configured. Run "push-todo connect" first.');
+  }
+
+  const url = endpoint.startsWith('http') ? endpoint : `${API_BASE}/${endpoint}`;
+
+  const response = await fetch(url, {
+    ...options,
+    headers: {
+      'Authorization': `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+      ...options.headers
+    }
+  });
+
+  return response;
+}
+
+/**
+ * Fetch tasks from the API.
+ *
+ * @param {string|null} gitRemote - Git remote to filter by (null for all projects)
+ * @param {Object} options - Query options
+ * @param {boolean} options.backlogOnly - Only return backlog items
+ * @param {boolean} options.includeBacklog - Include backlog items
+ * @param {boolean} options.completedOnly - Only return completed items
+ * @param {boolean} options.includeCompleted - Include completed items
+ * @returns {Promise<Object[]>} Array of todo objects
+ */
+export async function fetchTasks(gitRemote, options = {}) {
+  const params = new URLSearchParams();
+
+  if (gitRemote) {
+    params.set('git_remote', gitRemote);
+  }
+  if (options.backlogOnly) {
+    params.set('later_only', 'true');
+  }
+  if (options.includeBacklog) {
+    params.set('include_later', 'true');
+  }
+  if (options.completedOnly) {
+    params.set('completed_only', 'true');
+  }
+  if (options.includeCompleted) {
+    params.set('include_completed', 'true');
+  }
+
+  const queryString = params.toString();
+  const endpoint = queryString ? `synced-todos?${queryString}` : 'synced-todos';
+
+  const response = await apiRequest(endpoint);
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new Error('Invalid API key. Run "push-todo connect" to re-authenticate.');
+    }
+    if (response.status === 404) {
+      return [];
+    }
+    const text = await response.text();
+    throw new Error(`API error (${response.status}): ${text}`);
+  }
+
+  const data = await response.json();
+  return data.todos || [];
+}
+
+/**
+ * Fetch a specific task by display number.
+ *
+ * @param {number} displayNumber - The task's display number
+ * @returns {Promise<Object|null>} Task object or null if not found
+ */
+export async function fetchTaskByNumber(displayNumber) {
+  const response = await apiRequest(`synced-todos?display_number=${displayNumber}`);
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new Error('Invalid API key. Run "push-todo connect" to re-authenticate.');
+    }
+    if (response.status === 404) {
+      return null;
+    }
+    const text = await response.text();
+    throw new Error(`API error (${response.status}): ${text}`);
+  }
+
+  const data = await response.json();
+  const todos = data.todos || [];
+  return todos.length > 0 ? todos[0] : null;
+}
+
+/**
+ * Mark a task as completed.
+ *
+ * @param {string} taskId - UUID of the task
+ * @param {string} comment - Completion comment
+ * @returns {Promise<boolean>} True if successful
+ */
+export async function markTaskCompleted(taskId, comment = '') {
+  const response = await apiRequest('mark-todo-completed', {
+    method: 'POST',
+    body: JSON.stringify({
+      todo_id: taskId,
+      completion_comment: comment
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to mark task completed: ${text}`);
+  }
+
+  return true;
+}
+
+/**
+ * Queue a task for daemon execution.
+ *
+ * @param {number} displayNumber - The task's display number
+ * @returns {Promise<boolean>} True if successful
+ */
+export async function queueTask(displayNumber) {
+  const response = await apiRequest('queue-task', {
+    method: 'POST',
+    body: JSON.stringify({
+      display_number: displayNumber
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to queue task: ${text}`);
+  }
+
+  return true;
+}
+
+/**
+ * Queue multiple tasks for daemon execution.
+ *
+ * @param {number[]} displayNumbers - Array of display numbers
+ * @returns {Promise<Object>} Result with success/failure counts
+ */
+export async function queueTasks(displayNumbers) {
+  const results = {
+    success: [],
+    failed: []
+  };
+
+  for (const num of displayNumbers) {
+    try {
+      await queueTask(num);
+      results.success.push(num);
+    } catch (error) {
+      results.failed.push({ num, error: error.message });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Search tasks by query.
+ *
+ * @param {string} query - Search query
+ * @param {string|null} gitRemote - Git remote to filter by
+ * @returns {Promise<Object[]>} Array of matching tasks
+ */
+export async function searchTasks(query, gitRemote = null) {
+  const params = new URLSearchParams();
+  params.set('query', query);
+  if (gitRemote) {
+    params.set('git_remote', gitRemote);
+  }
+
+  const response = await apiRequest(`search-todos?${params}`);
+
+  if (!response.ok) {
+    if (response.status === 401) {
+      throw new Error('Invalid API key. Run "push-todo connect" to re-authenticate.');
+    }
+    const text = await response.text();
+    throw new Error(`Search failed: ${text}`);
+  }
+
+  const data = await response.json();
+  return data.results || [];
+}
+
+/**
+ * Update task execution status.
+ *
+ * @param {Object} payload - Execution update payload
+ * @returns {Promise<boolean>} True if successful
+ */
+export async function updateTaskExecution(payload) {
+  const response = await apiRequest('update-task-execution', {
+    method: 'POST',
+    body: JSON.stringify(payload)
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to update execution: ${text}`);
+  }
+
+  return true;
+}
+
+/**
+ * Validate API key.
+ *
+ * @returns {Promise<Object>} Validation result with user info
+ */
+export async function validateApiKey() {
+  try {
+    const response = await apiRequest('validate-api-key');
+
+    if (!response.ok) {
+      if (response.status === 401) {
+        return { valid: false, reason: 'invalid_key' };
+      }
+      return { valid: false, reason: 'api_error' };
+    }
+
+    const data = await response.json();
+    return {
+      valid: true,
+      userId: data.user_id,
+      email: data.email
+    };
+  } catch (error) {
+    return { valid: false, reason: 'network_error', error: error.message };
+  }
+}
+
+/**
+ * Register a project with the backend.
+ *
+ * @param {string} gitRemote - Normalized git remote
+ * @param {string[]} keywords - Project keywords
+ * @param {string} description - Project description
+ * @returns {Promise<boolean>} True if successful
+ */
+export async function registerProject(gitRemote, keywords = [], description = '') {
+  const response = await apiRequest('register-project', {
+    method: 'POST',
+    body: JSON.stringify({
+      git_remote: gitRemote,
+      keywords,
+      description
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Failed to register project: ${text}`);
+  }
+
+  return true;
+}
+
+/**
+ * Validate machine registration.
+ *
+ * @param {string} machineId - Machine identifier
+ * @returns {Promise<Object>} Validation result
+ */
+export async function validateMachine(machineId) {
+  const response = await apiRequest('validate-machine', {
+    method: 'POST',
+    body: JSON.stringify({
+      machine_id: machineId
+    })
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Machine validation failed: ${text}`);
+  }
+
+  const data = await response.json();
+  return data;
+}
+
+/**
+ * Get the current CLI version from the server.
+ *
+ * @returns {Promise<string>} Latest version string
+ */
+export async function getLatestVersion() {
+  try {
+    const response = await fetch('https://raw.githubusercontent.com/MasslessAI/push-todo-cli/main/npm/push-todo/package.json');
+    if (!response.ok) {
+      return null;
+    }
+    const data = await response.json();
+    return data.version;
+  } catch {
+    return null;
+  }
+}
+
+export { API_BASE };

package/lib/cli.js

@@ -0,0 +1,191 @@
+/**
+ * CLI argument parsing and command routing for Push CLI.
+ *
+ * Handles all command-line options and dispatches to appropriate handlers.
+ */
+
+import { parseArgs } from 'util';
+import * as fetch from './fetch.js';
+import { runConnect } from './connect.js';
+import { startWatch } from './watch.js';
+import { showSettings, toggleSetting } from './config.js';
+import { bold, red, cyan, dim } from './utils/colors.js';
+
+const VERSION = '3.0.0';
+
+const HELP_TEXT = `
+${bold('push-todo')} - Voice tasks from Push iOS app for Claude Code
+
+${bold('USAGE:')}
+  push-todo [options]              List active tasks
+  push-todo <number>               Show specific task
+  push-todo connect                Run connection doctor
+  push-todo search <query>         Search tasks
+  push-todo review                 Review completed tasks
+
+${bold('OPTIONS:')}
+  --all-projects, -a               List tasks from all projects
+  --backlog, -b                    Only show backlog items
+  --include-backlog                Include backlog items in listing
+  --completed, -c                  Only show completed items
+  --include-completed              Include completed items in listing
+  --queue <numbers>                Queue tasks for daemon (comma-separated)
+  --queue-batch                    Auto-queue a batch of tasks
+  --mark-completed <uuid>          Mark a task as completed
+  --completion-comment <text>      Comment for completion
+  --search <query>                 Search tasks
+  --status                         Show connection and daemon status
+  --watch, -w                      Live terminal UI
+  --setting [name]                 Show or toggle settings
+  --json                           Output as JSON
+  --version, -v                    Show version
+  --help, -h                       Show this help
+
+${bold('EXAMPLES:')}
+  push-todo                        List active tasks for current project
+  push-todo 427                    Show task #427
+  push-todo -a                     List all tasks across projects
+  push-todo --queue 1,2,3          Queue tasks 1, 2, 3 for daemon
+  push-todo search "auth bug"      Search for tasks matching "auth bug"
+  push-todo connect                Run connection diagnostics
+
+${bold('SETTINGS:')}
+  push-todo setting                Show all settings
+  push-todo setting auto-commit    Toggle auto-commit
+
+${dim('Documentation:')} https://pushto.do/docs/cli
+`;
+
+const options = {
+  'all-projects': { type: 'boolean', short: 'a' },
+  'backlog': { type: 'boolean', short: 'b' },
+  'include-backlog': { type: 'boolean' },
+  'completed': { type: 'boolean', short: 'c' },
+  'include-completed': { type: 'boolean' },
+  'queue': { type: 'string' },
+  'queue-batch': { type: 'boolean' },
+  'mark-completed': { type: 'string' },
+  'completion-comment': { type: 'string' },
+  'search': { type: 'string' },
+  'status': { type: 'boolean' },
+  'watch': { type: 'boolean', short: 'w' },
+  'setting': { type: 'string' },
+  'json': { type: 'boolean' },
+  'version': { type: 'boolean', short: 'v' },
+  'help': { type: 'boolean', short: 'h' }
+};
+
+/**
+ * Parse command line arguments.
+ *
+ * @param {string[]} argv - Command line arguments
+ * @returns {Object} Parsed arguments with values and positionals
+ */
+function parseArguments(argv) {
+  try {
+    return parseArgs({
+      args: argv,
+      options,
+      allowPositionals: true
+    });
+  } catch (error) {
+    console.error(red(`Error: ${error.message}`));
+    console.log(`Run ${cyan('push-todo --help')} for usage.`);
+    process.exit(1);
+  }
+}
+
+/**
+ * Main CLI entry point.
+ *
+ * @param {string[]} argv - Command line arguments (without node and script path)
+ */
+export async function run(argv) {
+  const { values, positionals } = parseArguments(argv);
+
+  // Help
+  if (values.help) {
+    console.log(HELP_TEXT);
+    return;
+  }
+
+  // Version
+  if (values.version) {
+    console.log(`push-todo ${VERSION}`);
+    return;
+  }
+
+  // Get the command (first positional)
+  const command = positionals[0];
+
+  // Connect command
+  if (command === 'connect') {
+    return runConnect(values);
+  }
+
+  // Review command
+  if (command === 'review') {
+    return fetch.runReview(values);
+  }
+
+  // Search command (positional form)
+  if (command === 'search' && positionals[1]) {
+    return fetch.searchTasks(positionals.slice(1).join(' '), values);
+  }
+
+  // Search option
+  if (values.search) {
+    return fetch.searchTasks(values.search, values);
+  }
+
+  // Watch mode
+  if (values.watch) {
+    return startWatch(values);
+  }
+
+  // Status
+  if (values.status) {
+    return fetch.showStatus(values);
+  }
+
+  // Settings
+  if ('setting' in values) {
+    const settingName = values.setting;
+    if (settingName && settingName !== 'true') {
+      return toggleSetting(settingName);
+    }
+    return showSettings();
+  }
+
+  // Queue tasks
+  if (values.queue) {
+    return fetch.queueForExecution(values.queue);
+  }
+
+  // Queue batch
+  if (values['queue-batch']) {
+    return fetch.offerBatch(values);
+  }
+
+  // Mark completed
+  if (values['mark-completed']) {
+    const comment = values['completion-comment'] || '';
+    return fetch.markComplete(values['mark-completed'], comment);
+  }
+
+  // Specific task by number
+  if (command && /^\d+$/.test(command)) {
+    const displayNumber = parseInt(command, 10);
+    return fetch.showTask(displayNumber, values);
+  }
+
+  // Unknown command
+  if (command && !/^\d+$/.test(command)) {
+    console.error(red(`Unknown command: ${command}`));
+    console.log(`Run ${cyan('push-todo --help')} for usage.`);
+    process.exit(1);
+  }
+
+  // Default: list tasks
+  return fetch.listTasks(values);
+}