taskode 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "taskode",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Taskode - Symphony-aligned Node orchestrator for AI issue execution",
   "type": "module",
   "files": [
@@ -14,7 +14,7 @@
     "taskode": "bin/taskode.js"
   },
   "scripts": {
-    "start": "node ./bin/taskode.js ./WORKFLOW.md",
+    "start": "node ./bin/taskode.js",
     "test": "npm run test:unit && npm run test:integration && npm run test:e2e",
     "test:unit": "node --test test/*.test.js",
     "test:integration": "node test/integration/orchestrator-flow.test.js && node test/integration/recovery-and-cleanup.test.js",

package/src/cli.js

@@ -3,16 +3,28 @@ import path from 'node:path';
 import { TaskodeStore } from './store.js';
 import { createServer } from './server.js';
 import { WorkflowStore } from './workflow-store.js';
+import { ensureProjectWorkflow, runInitCommand } from './init.js';
 import { createTracker } from './tracker/index.js';
 import { WorkspaceManager } from './workspace.js';
 import { AgentRunner } from './runner.js';
 import { Orchestrator } from './orchestrator.js';
 
 export async function runCli(args) {
-  const command = args[0] || 'start';
+  if (args.includes('--help') || args.includes('-h') || args[0] === 'help') {
+    runHelp();
+    return;
+  }
+
+  const command = ['init', 'doctor'].includes(args[0]) ? args[0] : 'start';
 
   if (command === 'init') {
-    runInit(process.cwd());
+    const options = parseOptions(args.slice(1));
+    await runInitCommand({
+      cwd: process.cwd(),
+      initMode: options.initMode,
+      input: process.stdin,
+      output: process.stdout
+    });
     return;
   }
 
@@ -22,7 +34,13 @@ export async function runCli(args) {
   }
 
   const options = parseOptions(args);
-  const workflowPath = path.resolve(process.cwd(), options.workflowPath || 'WORKFLOW.md');
+  const { workflowPath } = await ensureProjectWorkflow({
+    cwd: process.cwd(),
+    explicitPath: options.workflowPath,
+    initMode: options.initMode,
+    input: process.stdin,
+    output: process.stdout
+  });
   const workflowRuntime = new WorkflowStore({ workflowPath, cliOptions: options });
   const config = workflowRuntime.getConfig();
 
@@ -65,82 +83,6 @@ function ensureSeedTaskIfEmpty(store, config) {
   });
 }
 
-function runInit(cwd) {
-  const workflowPath = path.join(cwd, 'WORKFLOW.md');
-  if (fs.existsSync(workflowPath)) {
-    console.log('[taskode] WORKFLOW.md already exists');
-    return;
-  }
-
-  fs.writeFileSync(
-    workflowPath,
-    [
-      '---',
-      'tracker:',
-      '  kind: local',
-      'workspace:',
-      '  root: ./.taskode/workspaces',
-      '  seed_from_project: true',
-      '  copy_ignore: [".git", ".taskode", "node_modules"]',
-      'agent:',
-      '  poll_interval_ms: 3000',
-      '  max_concurrent_agents: 2',
-      '  max_retry_attempts: 5',
-      '  max_retry_backoff_ms: 60000',
-      '  max_concurrent_agents_by_state: {}',
-      '  max_turns: 20',
-      'worker:',
-      '  ssh_hosts: []',
-      '  max_concurrent_agents_per_host:',
-      'codex:',
-      '  mode: shell',
-      '  command: echo "simulated codex run"',
-      '  timeout_ms: 120000',
-      '  read_timeout_ms: 5000',
-      '  turn_timeout_ms: 3600000',
-      '  stall_timeout_ms: 300000',
-      '  approval_policy:',
-      '    reject:',
-      '      sandbox_approval: true',
-      '      rules: true',
-      '      mcp_elicitations: true',
-      '  thread_sandbox: workspace-write',
-      'hooks:',
-      '  after_create:',
-      '  before_run:',
-      '  after_run:',
-      '  before_remove:',
-      '  timeout_ms: 60000',
-      'policy:',
-      '  allow_commands: ["*"]',
-      '  deny_commands: []',
-      'review:',
-      '  auto_cleanup_approved: true',
-      'auth:',
-      '  token: $TASKODE_API_TOKEN',
-      'server:',
-      '  host: 127.0.0.1',
-      '  port: 4317',
-      '---',
-      '',
-      'You are working on issue {{ issue.identifier }}.',
-      '',
-      'Title: {{ issue.title }}',
-      'Body: {{ issue.description }}',
-      '',
-      'Deliverables:',
-      '1) Plan',
-      '2) Implementation',
-      '3) Tests',
-      '4) Summary',
-      ''
-    ].join('\n'),
-    'utf8'
-  );
-
-  console.log('[taskode] created WORKFLOW.md');
-}
-
 function runDoctor() {
   console.log(`[taskode] node: ${process.version}`);
   console.log(`[taskode] LINEAR_API_KEY: ${process.env.LINEAR_API_KEY ? 'set' : 'not set'}`);
@@ -150,11 +92,17 @@ function runDoctor() {
 }
 
 function parseOptions(args) {
-  const options = { workflowPath: null, port: null, logsRoot: null };
+  const options = { workflowPath: null, port: null, logsRoot: null, initMode: 'prompt' };
 
   for (let index = 0; index < args.length; index += 1) {
     const value = args[index];
 
+    if (value === '--workflow') {
+      options.workflowPath = args[index + 1];
+      index += 1;
+      continue;
+    }
+
     if (value === '--port') {
       options.port = Number(args[index + 1]);
       index += 1;
@@ -167,6 +115,16 @@ function parseOptions(args) {
       continue;
     }
 
+    if (value === '--default') {
+      options.initMode = 'default';
+      continue;
+    }
+
+    if (value === '--custom') {
+      options.initMode = 'custom';
+      continue;
+    }
+
     if (!value.startsWith('-') && value !== 'start' && !options.workflowPath) {
       options.workflowPath = value;
     }
@@ -174,3 +132,16 @@ function parseOptions(args) {
 
   return options;
 }
+
+function runHelp() {
+  console.log('Usage:');
+  console.log('  taskode');
+  console.log('  taskode start [--workflow <path>] [--port <port>] [--logs-root <path>]');
+  console.log('  taskode init [--default|--custom]');
+  console.log('  taskode doctor');
+  console.log('');
+  console.log('Behavior:');
+  console.log('  - prefers .taskode/WORKFLOW.md');
+  console.log('  - falls back to legacy WORKFLOW.md');
+  console.log('  - initializes .taskode/WORKFLOW.md on first run when missing');
+}

package/src/init.js

@@ -0,0 +1,351 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import readline from 'node:readline/promises';
+import { stdin as defaultInput, stdout as defaultOutput } from 'node:process';
+
+export const TASKODE_DIRNAME = '.taskode';
+export const DEFAULT_WORKFLOW_FILENAME = 'WORKFLOW.md';
+export const DEFAULT_WORKFLOW_RELATIVE_PATH = path.join(TASKODE_DIRNAME, DEFAULT_WORKFLOW_FILENAME);
+const LEGACY_WORKFLOW_FILENAME = 'WORKFLOW.md';
+const DEFAULT_COPY_IGNORE = ['.git', '.taskode', 'node_modules'];
+
+export function findWorkflowPath(cwd, explicitPath = null) {
+  if (explicitPath) {
+    const resolvedPath = path.resolve(cwd, explicitPath);
+    return fs.existsSync(resolvedPath) ? resolvedPath : null;
+  }
+
+  const preferredPath = path.resolve(cwd, DEFAULT_WORKFLOW_RELATIVE_PATH);
+  if (fs.existsSync(preferredPath)) return preferredPath;
+
+  const legacyPath = path.resolve(cwd, LEGACY_WORKFLOW_FILENAME);
+  return fs.existsSync(legacyPath) ? legacyPath : null;
+}
+
+export async function ensureProjectWorkflow({
+  cwd,
+  explicitPath = null,
+  initMode = 'prompt',
+  input = defaultInput,
+  output = defaultOutput
+}) {
+  const existingPath = findWorkflowPath(cwd, explicitPath);
+  if (existingPath) {
+    return { workflowPath: existingPath, created: false, createdWith: null };
+  }
+
+  if (explicitPath) {
+    throw new Error(`WORKFLOW file not found: ${path.resolve(cwd, explicitPath)}`);
+  }
+
+  const workflowPath = path.resolve(cwd, DEFAULT_WORKFLOW_RELATIVE_PATH);
+  const createdWith = await resolveInitMode({ initMode, input, output });
+  const profile = createdWith === 'custom'
+    ? await promptCustomProfile({ input, output })
+    : defaultInitProfile();
+
+  writeWorkflowFiles({ cwd, workflowPath, profile });
+
+  output.write(`[taskode] initialized ${path.relative(cwd, workflowPath) || DEFAULT_WORKFLOW_RELATIVE_PATH}\n`);
+  output.write('[taskode] config lives in .taskode/, runtime data will stay under the same folder\n');
+
+  return { workflowPath, created: true, createdWith };
+}
+
+export async function runInitCommand({
+  cwd,
+  initMode = 'prompt',
+  input = defaultInput,
+  output = defaultOutput
+}) {
+  const existingPath = findWorkflowPath(cwd);
+  if (existingPath) {
+    output.write(`[taskode] workflow already exists: ${path.relative(cwd, existingPath) || existingPath}\n`);
+    return { workflowPath: existingPath, created: false, createdWith: null };
+  }
+
+  return ensureProjectWorkflow({ cwd, initMode, input, output });
+}
+
+export function buildWorkflowDocument(profileInput = {}) {
+  const profile = { ...defaultInitProfile(), ...profileInput };
+  const lines = [
+    '---',
+    'tracker:',
+    `  kind: ${profile.trackerKind}`
+  ];
+
+  if (profile.trackerKind === 'linear') {
+    lines.push(`  api_key: $${profile.linearApiEnv}`);
+    lines.push(`  project_slug: ${yamlString(profile.linearProjectSlug)}`);
+  }
+
+  if (profile.trackerKind === 'github') {
+    lines.push(`  github_token: $${profile.githubTokenEnv}`);
+    lines.push(`  github_owner: ${yamlString(profile.githubOwner)}`);
+    lines.push(`  github_repo: ${yamlString(profile.githubRepo)}`);
+    lines.push(`  github_labels: ${yamlArray(profile.githubLabels)}`);
+  }
+
+  lines.push(
+    'workspace:',
+    '  root: ./.taskode/workspaces',
+    '  seed_from_project: true',
+    `  copy_ignore: ${yamlArray(DEFAULT_COPY_IGNORE)}`,
+    'agent:',
+    `  poll_interval_ms: ${profile.pollIntervalMs}`,
+    `  max_concurrent_agents: ${profile.maxConcurrentAgents}`,
+    `  max_retry_attempts: ${profile.maxRetryAttempts}`,
+    `  max_retry_backoff_ms: ${profile.maxRetryBackoffMs}`,
+    '  max_concurrent_agents_by_state: {}',
+    `  max_turns: ${profile.maxTurns}`,
+    'worker:',
+    '  ssh_hosts: []',
+    '  max_concurrent_agents_per_host:',
+    'codex:',
+    `  mode: ${profile.codexMode}`,
+    `  command: ${yamlString(profile.codexCommand)}`,
+    `  timeout_ms: ${profile.timeoutMs}`,
+    `  read_timeout_ms: ${profile.readTimeoutMs}`,
+    `  turn_timeout_ms: ${profile.turnTimeoutMs}`,
+    `  stall_timeout_ms: ${profile.stallTimeoutMs}`,
+    '  approval_policy:',
+    '    reject:',
+    '      sandbox_approval: true',
+    '      rules: true',
+    '      mcp_elicitations: true',
+    '  thread_sandbox: workspace-write',
+    'hooks:',
+    '  after_create:',
+    '  before_run:',
+    '  after_run:',
+    '  before_remove:',
+    '  timeout_ms: 60000',
+    'policy:',
+    '  allow_commands: ["*"]',
+    '  deny_commands: []',
+    'review:',
+    `  auto_cleanup_approved: ${profile.autoCleanupApproved ? 'true' : 'false'}`,
+    'auth:',
+    `  token: ${profile.authTokenEnv ? `$${profile.authTokenEnv}` : ''}`,
+    'server:',
+    '  host: 127.0.0.1',
+    `  port: ${profile.serverPort}`,
+    '---',
+    '',
+    'You are working on issue {{ issue.identifier }}.',
+    '',
+    'Title: {{ issue.title }}',
+    'Body: {{ issue.description }}',
+    '',
+    'Deliverables:',
+    '1) Plan',
+    '2) Implementation',
+    '3) Tests',
+    '4) Summary',
+    ''
+  );
+
+  return lines.join('\n');
+}
+
+function writeWorkflowFiles({ cwd, workflowPath, profile }) {
+  const taskodeDir = path.join(cwd, TASKODE_DIRNAME);
+  fs.mkdirSync(taskodeDir, { recursive: true });
+  fs.writeFileSync(workflowPath, buildWorkflowDocument(profile), 'utf8');
+
+  const gitignorePath = path.join(taskodeDir, '.gitignore');
+  if (!fs.existsSync(gitignorePath)) {
+    fs.writeFileSync(
+      gitignorePath,
+      [
+        'data.json',
+        'logs/',
+        'workspaces/'
+      ].join('\n') + '\n',
+      'utf8'
+    );
+  }
+}
+
+async function resolveInitMode({ initMode, input, output }) {
+  if (initMode === 'default' || initMode === 'custom') return initMode;
+  if (!canPrompt(input, output)) {
+    output.write(`[taskode] no workflow config found, creating ${DEFAULT_WORKFLOW_RELATIVE_PATH} with defaults\n`);
+    return 'default';
+  }
+
+  const rl = readline.createInterface({ input, output });
+  try {
+    output.write('[taskode] no workflow config found for this project\n');
+    return askChoice(rl, {
+      title: 'Initialize Taskode',
+      choices: [
+        { value: 'default', label: 'Default', description: 'Create a ready-to-run local setup' },
+        { value: 'custom', label: 'Custom', description: 'Interactively choose tracker and runtime settings' }
+      ],
+      defaultValue: 'default'
+    });
+  } finally {
+    rl.close();
+  }
+}
+
+async function promptCustomProfile({ input, output }) {
+  if (!canPrompt(input, output)) {
+    throw new Error('interactive initialization requires a TTY');
+  }
+
+  const rl = readline.createInterface({ input, output });
+
+  try {
+    const trackerKind = await askChoice(rl, {
+      title: 'Tracker',
+      choices: [
+        { value: 'local', label: 'Local', description: 'Use Taskode web board as the source of truth' },
+        { value: 'linear', label: 'Linear', description: 'Sync tasks from Linear' },
+        { value: 'github', label: 'GitHub', description: 'Sync tasks from GitHub Issues' }
+      ],
+      defaultValue: 'local'
+    });
+
+    const codexMode = await askChoice(rl, {
+      title: 'Execution Mode',
+      choices: [
+        { value: 'shell', label: 'Shell', description: 'Run a single shell command per task' },
+        { value: 'app-server', label: 'App Server', description: 'Keep a JSON-RPC app-server session per run' }
+      ],
+      defaultValue: 'shell'
+    });
+
+    const profile = defaultInitProfile({
+      trackerKind,
+      codexMode
+    });
+
+    if (trackerKind === 'linear') {
+      profile.linearProjectSlug = await askRequired(rl, 'Linear project slug', 'ENG');
+      profile.linearApiEnv = await askText(rl, 'Linear API key env var', 'LINEAR_API_KEY');
+    }
+
+    if (trackerKind === 'github') {
+      profile.githubOwner = await askRequired(rl, 'GitHub owner', 'acme');
+      profile.githubRepo = await askRequired(rl, 'GitHub repo', 'project');
+      profile.githubTokenEnv = await askText(rl, 'GitHub token env var', 'GITHUB_TOKEN');
+      profile.githubLabels = parseList(await askText(rl, 'GitHub labels (comma separated)', 'taskode, ready'));
+    }
+
+    profile.codexCommand = await askRequired(
+      rl,
+      codexMode === 'app-server' ? 'App-server launch command' : 'Shell command',
+      codexMode === 'app-server' ? 'codex app-server' : 'echo "simulated codex run"'
+    );
+    profile.serverPort = await askInteger(rl, 'Web port', 4317);
+    profile.authTokenEnv = await askText(rl, 'API token env var (blank disables auth)', 'TASKODE_API_TOKEN');
+    profile.autoCleanupApproved = await askBoolean(rl, 'Auto-clean approved workspaces?', true);
+
+    return profile;
+  } finally {
+    rl.close();
+  }
+}
+
+function canPrompt(input, output) {
+  return Boolean(input?.isTTY && output?.isTTY);
+}
+
+function defaultInitProfile(overrides = {}) {
+  return {
+    trackerKind: 'local',
+    linearProjectSlug: 'ENG',
+    linearApiEnv: 'LINEAR_API_KEY',
+    githubOwner: 'acme',
+    githubRepo: 'project',
+    githubLabels: ['taskode', 'ready'],
+    githubTokenEnv: 'GITHUB_TOKEN',
+    pollIntervalMs: 3000,
+    maxConcurrentAgents: 2,
+    maxRetryAttempts: 5,
+    maxRetryBackoffMs: 60000,
+    maxTurns: 20,
+    codexMode: 'shell',
+    codexCommand: 'echo "simulated codex run"',
+    timeoutMs: 120000,
+    readTimeoutMs: 5000,
+    turnTimeoutMs: 3600000,
+    stallTimeoutMs: 300000,
+    autoCleanupApproved: true,
+    authTokenEnv: 'TASKODE_API_TOKEN',
+    serverPort: 4317,
+    ...overrides
+  };
+}
+
+async function askChoice(rl, { title, choices, defaultValue }) {
+  const defaultIndex = Math.max(0, choices.findIndex((choice) => choice.value === defaultValue));
+
+  while (true) {
+    rl.output.write(`${title}\n`);
+    choices.forEach((choice, index) => {
+      rl.output.write(`  ${index + 1}. ${choice.label} - ${choice.description}\n`);
+    });
+
+    const answer = (await rl.question(`Select [${defaultIndex + 1}]: `)).trim();
+    if (!answer) return choices[defaultIndex].value;
+
+    const choice = choices[Number(answer) - 1];
+    if (choice) return choice.value;
+
+    rl.output.write('Please enter one of the listed numbers.\n');
+  }
+}
+
+async function askText(rl, label, fallback = '') {
+  const prompt = fallback ? `${label} [${fallback}]: ` : `${label}: `;
+  const answer = (await rl.question(prompt)).trim();
+  return answer || fallback;
+}
+
+async function askRequired(rl, label, fallback = '') {
+  while (true) {
+    const value = await askText(rl, label, fallback);
+    if (value.trim()) return value.trim();
+    rl.output.write('This value is required.\n');
+  }
+}
+
+async function askInteger(rl, label, fallback) {
+  while (true) {
+    const value = await askText(rl, label, String(fallback));
+    const parsed = Number(value);
+    if (Number.isInteger(parsed) && parsed >= 0) return parsed;
+    rl.output.write('Please enter a non-negative integer.\n');
+  }
+}
+
+async function askBoolean(rl, label, fallback) {
+  const fallbackLabel = fallback ? 'Y/n' : 'y/N';
+
+  while (true) {
+    const answer = (await rl.question(`${label} [${fallbackLabel}]: `)).trim().toLowerCase();
+    if (!answer) return fallback;
+    if (['y', 'yes'].includes(answer)) return true;
+    if (['n', 'no'].includes(answer)) return false;
+    rl.output.write('Please answer yes or no.\n');
+  }
+}
+
+function parseList(value) {
+  return [...new Set(String(value || '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter(Boolean))];
+}
+
+function yamlArray(values) {
+  return `[${(values || []).map((value) => yamlString(value)).join(', ')}]`;
+}
+
+function yamlString(value) {
+  return JSON.stringify(String(value ?? ''));
+}