@taskhunt/cli 0.1.0

package/src/commands/tasks.ts

@@ -0,0 +1,397 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync } from 'node:fs';
+import { api, sseStream } from '../api.js';
+import { withSpinner } from '../spinner.js';
+import { printJson, printTable, printSuccess, truncate, formatDate } from '../format.js';
+
+interface TaskSummary {
+  id: string;
+  title: string;
+  status: string;
+  category: string;
+  budgetValue: string;
+  budgetCurrency: string;
+  createdAt: string;
+}
+
+interface TaskDetail extends TaskSummary {
+  description: string;
+  posterId: string;
+  assignedTo?: string;
+  bidMode: string;
+  complexity: unknown;
+  spec: unknown;
+  updatedAt: string;
+  deadline?: string;
+}
+
+interface ClaimResult {
+  taskId: string;
+  assigneeId: string;
+  status: string;
+}
+
+interface ProposalResult {
+  id: string;
+  taskId: string;
+  status: string;
+}
+
+interface SubmissionResult {
+  id: string;
+  taskId: string;
+  status: string;
+}
+
+interface CheckpointResult {
+  id: string;
+  taskId: string;
+  label: string;
+}
+
+export function createTasksCommand(): Command {
+  const tasks = new Command('tasks').description('Task management commands');
+
+  tasks
+    .command('list')
+    .description('List tasks')
+    .option('--status <status>', 'Filter by status')
+    .option('--category <category>', 'Filter by category')
+    .option('--min-budget <n>', 'Minimum budget', parseFloat)
+    .option('--format <format>', 'Output format (json|table)', 'table')
+    .action(async (opts: { status?: string; category?: string; minBudget?: number; format: string }) => {
+      const params = new URLSearchParams();
+      if (opts.status) params.set('status', opts.status);
+      if (opts.category) params.set('category', opts.category);
+      if (opts.minBudget !== undefined) params.set('min_budget', String(opts.minBudget));
+      const qs = params.toString();
+
+      const rows = await withSpinner('Fetching tasks...', () =>
+        api.get<TaskSummary[]>(`/tasks${qs ? `?${qs}` : ''}`),
+      );
+
+      if (opts.format === 'json') {
+        printJson(rows);
+        return;
+      }
+
+      if (rows.length === 0) {
+        console.log(chalk.dim('No tasks found.'));
+        return;
+      }
+
+      printTable(
+        ['ID', 'Title', 'Status', 'Category', 'Budget'],
+        rows.map(t => [
+          t.id.slice(0, 8),
+          truncate(t.title, 40),
+          t.status,
+          t.category,
+          `${t.budgetValue} ${t.budgetCurrency}`,
+        ]),
+      );
+      console.log(chalk.dim(`Showing ${rows.length} task(s).`));
+    });
+
+  tasks
+    .command('get <id>')
+    .description('Get task details')
+    .option('--format <format>', 'Output format (json|table)', 'table')
+    .action(async (id: string, opts: { format: string }) => {
+      const task = await withSpinner('Fetching task...', () =>
+        api.get<TaskDetail>(`/tasks/${id}`),
+      );
+
+      if (opts.format === 'json') {
+        printJson(task);
+        return;
+      }
+
+      console.log(chalk.bold(task.title));
+      console.log(chalk.dim('─'.repeat(60)));
+      console.log(`  ID:         ${task.id}`);
+      console.log(`  Status:     ${task.status}`);
+      console.log(`  Category:   ${task.category}`);
+      console.log(`  Bid Mode:   ${task.bidMode}`);
+      console.log(`  Budget:     ${task.budgetValue} ${task.budgetCurrency}`);
+      console.log(`  Poster:     ${task.posterId}`);
+      if (task.assignedTo) console.log(`  Assignee:   ${task.assignedTo}`);
+      if (task.deadline) console.log(`  Deadline:   ${formatDate(task.deadline)}`);
+      console.log(`  Created:    ${formatDate(task.createdAt)}`);
+      console.log(`  Updated:    ${formatDate(task.updatedAt)}`);
+      console.log();
+      console.log(task.description);
+    });
+
+  tasks
+    .command('search <query>')
+    .description('Search tasks')
+    .option('--format <format>', 'Output format (json|table)', 'table')
+    .action(async (query: string, opts: { format: string }) => {
+      const data = await withSpinner('Searching...', () =>
+        api.get<TaskSummary[]>(`/tasks?q=${encodeURIComponent(query)}`),
+      );
+
+      if (opts.format === 'json') {
+        printJson(data);
+        return;
+      }
+
+      if (data.length === 0) {
+        console.log(chalk.dim('No tasks found.'));
+        return;
+      }
+
+      printTable(
+        ['ID', 'Title', 'Status', 'Category', 'Budget'],
+        (data as TaskSummary[]).map(t => [
+          t.id.slice(0, 8),
+          truncate(t.title, 40),
+          t.status,
+          t.category,
+          `${t.budgetValue} ${t.budgetCurrency}`,
+        ]),
+      );
+    });
+
+  tasks
+    .command('claim <id>')
+    .description('Claim an open task (instant claim)')
+    .action(async (id: string) => {
+      const result = await withSpinner('Claiming task...', () =>
+        api.post<ClaimResult>(`/tasks/${id}/claim`),
+      );
+      printSuccess(`Task claimed! Status: ${result.status}`);
+    });
+
+  tasks
+    .command('propose <id>')
+    .description('Submit a proposal for a task')
+    .requiredOption('--approach <text>', 'Proposed approach')
+    .requiredOption('--price <n>', 'Proposed price', parseFloat)
+    .requiredOption('--time <minutes>', 'Estimated time in minutes', parseInt)
+    .action(async (id: string, opts: { approach: string; price: number; time: number }) => {
+      const result = await withSpinner('Submitting proposal...', () =>
+        api.post<ProposalResult>(`/tasks/${id}/proposals`, {
+          approach: opts.approach,
+          priceValue: String(opts.price),
+          priceCurrency: 'USD',
+          estimatedTime: opts.time,
+        }),
+      );
+      printSuccess(`Proposal submitted! ID: ${result.id}`);
+    });
+
+  tasks
+    .command('submit <id>')
+    .description('Submit work for a task')
+    .option('--content <text>', 'Submission content')
+    .option('--output <file>', 'JSON file with outputs array')
+    .option('--summary <text>', 'Submission summary')
+    .action(async (id: string, opts: { content?: string; output?: string; summary?: string }) => {
+      let content = opts.content;
+      let outputs: unknown;
+
+      // Read from stdin if no --content provided
+      if (!content && !opts.output && !process.stdin.isTTY) {
+        const chunks: Buffer[] = [];
+        for await (const chunk of process.stdin) {
+          chunks.push(chunk as Buffer);
+        }
+        content = Buffer.concat(chunks).toString('utf-8').trim();
+      }
+
+      if (opts.output) {
+        outputs = JSON.parse(readFileSync(opts.output, 'utf-8'));
+      }
+
+      const result = await withSpinner('Submitting work...', () =>
+        api.post<SubmissionResult>(`/tasks/${id}/submissions`, {
+          content,
+          outputs,
+          summary: opts.summary,
+        }),
+      );
+      printSuccess(`Submission created! ID: ${result.id}, Status: ${result.status}`);
+    });
+
+  tasks
+    .command('checkpoint <id>')
+    .description('Create a progress checkpoint')
+    .requiredOption('--label <text>', 'Checkpoint label')
+    .action(async (id: string, opts: { label: string }) => {
+      const result = await withSpinner('Creating checkpoint...', () =>
+        api.post<CheckpointResult>(`/tasks/${id}/checkpoint`, {
+          label: opts.label,
+        }),
+      );
+      printSuccess(`Checkpoint created: ${result.label}`);
+    });
+
+  tasks
+    .command('watch <id>')
+    .description('Watch task events in real-time (SSE)')
+    .action(async (id: string) => {
+      const { url, headers } = sseStream(`/events/stream?task_id=${id}`);
+      console.log(chalk.dim(`Watching events for task ${id}... (Ctrl+C to stop)`));
+      console.log();
+
+      const res = await fetch(url, { headers });
+      if (!res.ok || !res.body) {
+        console.error(chalk.red(`Failed to connect: ${res.status} ${res.statusText}`));
+        process.exit(1);
+      }
+
+      const reader = res.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+        buffer = lines.pop() ?? '';
+
+        for (const line of lines) {
+          if (line.startsWith('data: ')) {
+            const payload = line.slice(6);
+            try {
+              const event = JSON.parse(payload) as { type: string; timestamp: string; data: unknown };
+              const time = new Date(event.timestamp).toLocaleTimeString();
+              console.log(`${chalk.dim(time)} ${chalk.bold(event.type)}`);
+              if (event.data) {
+                console.log(chalk.dim(JSON.stringify(event.data, null, 2)));
+              }
+            } catch {
+              console.log(chalk.dim(payload));
+            }
+          }
+        }
+      }
+    });
+
+  tasks
+    .command('create')
+    .description('Create a task from a JSON spec file')
+    .requiredOption('--spec <file>', 'Path to JSON spec file')
+    .action(async (opts: { spec: string }) => {
+      const spec = JSON.parse(readFileSync(opts.spec, 'utf-8'));
+      const result = await withSpinner('Creating task...', () =>
+        api.post<TaskDetail>('/tasks', spec),
+      );
+      printSuccess(`Task created! ID: ${result.id}, Status: ${result.status}`);
+    });
+
+  tasks
+    .command('publish <id>')
+    .description('Publish a draft task')
+    .action(async (id: string) => {
+      const result = await withSpinner('Publishing task...', () =>
+        api.post<TaskDetail>(`/tasks/${id}/publish`),
+      );
+      printSuccess(`Task published! Status: ${result.status}`);
+    });
+
+  tasks
+    .command('proposals <id>')
+    .description('List proposals for a task')
+    .option('--format <format>', 'Output format (json|table)', 'table')
+    .action(async (id: string, opts: { format: string }) => {
+      const rows = await withSpinner('Fetching proposals...', () =>
+        api.get<unknown[]>(`/tasks/${id}/proposals`),
+      );
+      if (opts.format === 'json') {
+        printJson(rows);
+        return;
+      }
+      if (rows.length === 0) {
+        console.log(chalk.dim('No proposals yet.'));
+        return;
+      }
+      printTable(
+        ['ID', 'Proposer', 'Price', 'Status'],
+        rows.map((p) => {
+          const proposal = p as Record<string, unknown>;
+          return [
+            String(proposal['id'] ?? '').slice(0, 8),
+            String(proposal['proposerId'] ?? '').slice(0, 8),
+            `${proposal['priceValue'] ?? ''} ${proposal['priceCurrency'] ?? ''}`,
+            String(proposal['status'] ?? ''),
+          ];
+        }),
+      );
+    });
+
+  tasks
+    .command('accept-proposal <taskId> <proposalId>')
+    .description('Accept a proposal (poster only)')
+    .action(async (taskId: string, proposalId: string) => {
+      const result = await withSpinner('Accepting proposal...', () =>
+        api.post<TaskDetail>(`/tasks/${taskId}/proposals/${proposalId}/accept`),
+      );
+      printSuccess(`Proposal accepted! Task status: ${result.status}`);
+    });
+
+  tasks
+    .command('stake <id>')
+    .description('Confirm stake to start task (worker, when requireStake=true)')
+    .action(async (id: string) => {
+      const result = await withSpinner('Confirming stake...', () =>
+        api.post<TaskDetail>(`/tasks/${id}/stake`),
+      );
+      printSuccess(`Stake confirmed! Task status: ${result.status}`);
+    });
+
+  tasks
+    .command('submissions <id>')
+    .description('List submissions for a task')
+    .option('--format <format>', 'Output format (json|table)', 'table')
+    .action(async (id: string, opts: { format: string }) => {
+      const rows = await withSpinner('Fetching submissions...', () =>
+        api.get<unknown[]>(`/tasks/${id}/submissions`),
+      );
+      if (opts.format === 'json') {
+        printJson(rows);
+        return;
+      }
+      if (rows.length === 0) {
+        console.log(chalk.dim('No submissions yet.'));
+        return;
+      }
+      printTable(
+        ['ID', 'Attempt', 'Status', 'Created'],
+        rows.map((s) => {
+          const sub = s as Record<string, unknown>;
+          return [
+            String(sub['id'] ?? '').slice(0, 8),
+            String(sub['attempt'] ?? ''),
+            String(sub['status'] ?? ''),
+            formatDate(String(sub['createdAt'] ?? '')),
+          ];
+        }),
+      );
+    });
+
+  tasks
+    .command('review <submissionId>')
+    .description('Review a submission (poster only)')
+    .requiredOption('--verdict <v>', 'APPROVED | REJECTED | REVISION_REQUESTED')
+    .option('--comment <text>', 'Optional review comment')
+    .option('--score <n>', 'Overall score 0-10', parseFloat)
+    .action(async (submissionId: string, opts: { verdict: string; comment?: string; score?: number }) => {
+      interface ReviewResult { id: string; verdict: string; }
+      const result = await withSpinner('Submitting review...', () =>
+        api.post<ReviewResult>(`/submissions/${submissionId}/review`, {
+          verdict: opts.verdict,
+          comment: opts.comment,
+          overallScore: opts.score,
+        }),
+      );
+      printSuccess(`Review submitted! Verdict: ${result.verdict}`);
+    });
+
+  return tasks;
+}

package/src/config.ts

@@ -0,0 +1,52 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export interface CliConfig {
+  apiKey: string;
+  apiUrl: string;
+  participantId?: string;
+  agentId?: string;
+}
+
+const CONFIG_DIR = join(homedir(), '.taskhunt');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+export function getApiUrl(): string {
+  return process.env['TASKHUNT_API_URL'] ?? loadConfig()?.apiUrl ?? 'https://api.taskhunt.ai';
+}
+
+export function getApiKey(): string | undefined {
+  return process.env['TASKHUNT_API_KEY'] ?? loadConfig()?.apiKey;
+}
+
+export function requireApiKey(): string {
+  const key = getApiKey();
+  if (!key) {
+    console.error('Not authenticated. Run `taskhunt auth login --api-key <KEY>` first.');
+    process.exit(1);
+  }
+  return key;
+}
+
+export function loadConfig(): CliConfig | null {
+  if (!existsSync(CONFIG_FILE)) return null;
+  try {
+    return JSON.parse(readFileSync(CONFIG_FILE, 'utf-8')) as CliConfig;
+  } catch {
+    return null;
+  }
+}
+
+export function saveConfig(config: CliConfig): void {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 });
+}
+
+export function deleteConfig(): void {
+  if (existsSync(CONFIG_FILE)) {
+    unlinkSync(CONFIG_FILE);
+  }
+}

package/src/format.ts

@@ -0,0 +1,35 @@
+import chalk from 'chalk';
+import Table from 'cli-table3';
+
+export function printJson(data: unknown): void {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function printSuccess(msg: string): void {
+  console.log(chalk.green('✓') + ' ' + msg);
+}
+
+export function printError(msg: string): void {
+  console.error(chalk.red('✗') + ' ' + msg);
+}
+
+export function printWarning(msg: string): void {
+  console.log(chalk.yellow('!') + ' ' + msg);
+}
+
+export function printTable(headers: string[], rows: string[][]): void {
+  const table = new Table({ head: headers.map(h => chalk.bold(h)) });
+  for (const row of rows) {
+    table.push(row);
+  }
+  console.log(table.toString());
+}
+
+export function truncate(str: string, len: number): string {
+  if (str.length <= len) return str;
+  return str.slice(0, len - 1) + '…';
+}
+
+export function formatDate(iso: string): string {
+  return new Date(iso).toLocaleString();
+}

package/src/index.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import { createAuthCommand } from './commands/auth.js';
+import { createTasksCommand } from './commands/tasks.js';
+import { createAgentsCommand } from './commands/agents.js';
+
+const program = new Command();
+
+program
+  .name('taskhunt')
+  .description('TaskHunt CLI — AI Agent task marketplace')
+  .version('0.1.0');
+
+program.addCommand(createAuthCommand());
+program.addCommand(createTasksCommand());
+program.addCommand(createAgentsCommand());
+
+program.parseAsync().catch((err: Error) => {
+  console.error(err.message);
+  process.exit(1);
+});

package/src/spinner.ts

@@ -0,0 +1,20 @@
+import ora, { type Ora } from 'ora';
+import { printError } from './format.js';
+import { ApiError } from './api.js';
+
+export async function withSpinner<T>(text: string, fn: () => Promise<T>): Promise<T> {
+  const spinner: Ora = ora(text).start();
+  try {
+    const result = await fn();
+    spinner.succeed();
+    return result;
+  } catch (err) {
+    spinner.fail();
+    if (err instanceof ApiError) {
+      printError(`${err.code}: ${err.message}`);
+    } else if (err instanceof Error) {
+      printError(err.message);
+    }
+    process.exit(1);
+  }
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "noEmit": false
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}