opencastle 0.1.0

package/src/cli/manifest.ts

@@ -0,0 +1,45 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import type { Manifest } from './types.js';
+
+const MANIFEST_FILE = '.opencastle.json';
+
+/**
+ * Read the project's OpenCastle manifest, or null if not installed.
+ */
+export async function readManifest(
+  projectRoot: string
+): Promise<Manifest | null> {
+  try {
+    const content = await readFile(
+      resolve(projectRoot, MANIFEST_FILE),
+      'utf8'
+    );
+    return JSON.parse(content) as Manifest;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write the manifest to the project root.
+ */
+export async function writeManifest(
+  projectRoot: string,
+  manifest: Manifest
+): Promise<void> {
+  const path = resolve(projectRoot, MANIFEST_FILE);
+  await writeFile(path, JSON.stringify(manifest, null, 2) + '\n');
+}
+
+/**
+ * Create a fresh manifest object.
+ */
+export function createManifest(version: string, ide: string): Manifest {
+  return {
+    version,
+    ide,
+    installedAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+}

package/src/cli/mcp.ts

@@ -0,0 +1,49 @@
+import { resolve, dirname } from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { getOrchestratorRoot } from './copy.js';
+import { getIncludedMcpServers } from './stack-config.js';
+import type { ScaffoldResult, StackConfig } from './types.js';
+
+/**
+ * Scaffold the MCP server config into the target project.
+ *
+ * Reads the template from `opencastle/src/orchestrator/mcp.json`,
+ * writes it to `<projectRoot>/<destRelPath>` (e.g. `.vscode/mcp.json`).
+ *
+ * When a StackConfig is provided, only servers relevant to the chosen
+ * CMS/DB stack (plus core servers) are included.
+ *
+ * This is a customizable file — scaffolded once, never overwritten on update.
+ */
+export async function scaffoldMcpConfig(
+  pkgRoot: string,
+  projectRoot: string,
+  destRelPath: string,
+  stack?: StackConfig
+): Promise<ScaffoldResult> {
+  const destPath = resolve(projectRoot, destRelPath);
+
+  if (existsSync(destPath)) {
+    return { path: destPath, action: 'skipped' };
+  }
+
+  const srcRoot = getOrchestratorRoot(pkgRoot);
+  const templatePath = resolve(srcRoot, 'mcp.json');
+  const content = await readFile(templatePath, 'utf8');
+
+  const template = JSON.parse(content) as { servers: Record<string, unknown> };
+
+  // Filter servers based on stack config
+  if (stack) {
+    const included = getIncludedMcpServers(stack);
+    template.servers = Object.fromEntries(
+      Object.entries(template.servers).filter(([key]) => included.has(key))
+    );
+  }
+
+  await mkdir(dirname(destPath), { recursive: true });
+  await writeFile(destPath, JSON.stringify(template, null, 2) + '\n');
+
+  return { path: destPath, action: 'created' };
+}

package/src/cli/prompt.ts

@@ -0,0 +1,115 @@
+import { createInterface, type Interface } from 'node:readline/promises';
+import { stdin, stdout } from 'node:process';
+import type { SelectOption } from './types.js';
+
+// ── Line-buffered readline ────────────────────────────────────────
+// readline.question() drops lines that arrived between calls because
+// it only listens for the NEXT 'line' event.  When piped input
+// delivers multiple lines in one chunk (e.g. `printf 'y\n3\n' | …`),
+// the second line fires before the second question() is registered.
+//
+// We solve this with a permanent 'line' listener that pushes into a
+// queue.  nextLine() either pops from the queue or awaits the next
+// event — no data is ever lost.
+
+let _rl: Interface | null = null;
+const _lineBuffer: string[] = [];
+let _lineResolver: ((_line: string) => void) | null = null;
+
+function ensureRL(): void {
+  if (_rl) return;
+  _rl = createInterface({ input: stdin, output: stdout });
+  _rl.on('line', (line: string) => {
+    if (_lineResolver) {
+      const resolve = _lineResolver;
+      _lineResolver = null;
+      resolve(line);
+    } else {
+      _lineBuffer.push(line);
+    }
+  });
+  _rl.on('close', () => {
+    _rl = null;
+    // Resolve any pending prompt with empty string → triggers defaults
+    if (_lineResolver) {
+      const resolve = _lineResolver;
+      _lineResolver = null;
+      resolve('');
+    }
+  });
+}
+
+/**
+ * Read the next line from stdin, displaying a prompt first.
+ * Consumes from the internal buffer when piped input delivered
+ * multiple lines in a single chunk.
+ */
+async function nextLine(prompt: string): Promise<string> {
+  ensureRL();
+  stdout.write(prompt);
+  if (_lineBuffer.length > 0) {
+    const line = _lineBuffer.shift()!;
+    // Echo the buffered answer for non-TTY so logs read naturally
+    if (!stdin.isTTY) stdout.write(line + '\n');
+    return line;
+  }
+  return new Promise<string>((resolve) => {
+    _lineResolver = resolve;
+  });
+}
+
+/** Close the shared readline interface. Call once at command end. */
+export function closePrompts(): void {
+  if (_rl) {
+    _rl.close();
+    _rl = null;
+    _lineBuffer.length = 0;
+    _lineResolver = null;
+  }
+}
+
+/**
+ * Interactive single-choice selection prompt.
+ */
+export async function select(
+  message: string,
+  options: SelectOption[]
+): Promise<string> {
+  console.log(`\n  ${message}\n`);
+  options.forEach((opt, i) => {
+    const hint = opt.hint ? ` — ${opt.hint}` : '';
+    console.log(`    ${i + 1}) ${opt.label}${hint}`);
+  });
+
+  let choice: SelectOption | undefined;
+  while (!choice) {
+    const answer = await nextLine(`\n  Select [1-${options.length}]: `);
+    // Handle EOF — stdin closed without valid selection
+    if (answer === '' && (!_rl || !stdin.isTTY)) {
+      console.error('\n  ✗ No input received (stdin closed). Aborting.');
+      process.exit(1);
+    }
+    const num = parseInt(answer, 10);
+    if (num >= 1 && num <= options.length) {
+      choice = options[num - 1];
+    } else {
+      console.log(`    Please enter a number between 1 and ${options.length}`);
+    }
+  }
+
+  return choice.value;
+}
+
+/**
+ * Yes/No confirmation prompt.
+ */
+export async function confirm(
+  message: string,
+  defaultYes = true
+): Promise<boolean> {
+  const hint = defaultYes ? '[Y/n]' : '[y/N]';
+  const answer = await nextLine(`  ${message} ${hint} `);
+
+  if (!answer.trim()) return defaultYes;
+  return answer.trim().toLowerCase().startsWith('y');
+}

package/src/cli/run/adapters/claude-code.ts

@@ -0,0 +1,95 @@
+import { spawn } from 'node:child_process'
+import type { Task, ExecuteOptions, ExecuteResult } from '../../types.js'
+
+/** Adapter name */
+export const name = 'claude-code'
+
+/**
+ * Check if the `claude` CLI is available on the system PATH.
+ */
+export async function isAvailable(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn('which', ['claude'], { stdio: 'pipe' })
+    proc.on('close', (code) => resolve(code === 0))
+    proc.on('error', () => resolve(false))
+  })
+}
+
+/**
+ * Execute a task by invoking the Claude Code CLI in print mode.
+ */
+export async function execute(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  let prompt = `You are a ${task.agent}. ${task.prompt}`
+
+  if (task.files && task.files.length > 0) {
+    prompt += `\n\nOnly modify files under: ${task.files.join(', ')}`
+  }
+
+  const args = [
+    '-p',
+    prompt,
+    '--output-format',
+    'json',
+    '--max-turns',
+    '50',
+  ]
+
+  return new Promise((resolve) => {
+    const proc = spawn('claude', args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+      cwd: process.cwd(),
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    proc.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString()
+      if (options.verbose) {
+        process.stdout.write(chunk)
+      }
+    })
+
+    proc.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString()
+      if (options.verbose) {
+        process.stderr.write(chunk)
+      }
+    })
+
+    proc.on('close', (code) => {
+      const output = [stdout, stderr].filter(Boolean).join('\n')
+      resolve({
+        success: code === 0,
+        output: output.slice(0, 10000), // Cap output size
+        exitCode: code ?? -1,
+      })
+    })
+
+    proc.on('error', (err) => {
+      resolve({
+        success: false,
+        output: `Failed to spawn claude: ${err.message}`,
+        exitCode: -1,
+      })
+    })
+
+    // Store process ref for potential timeout kill
+    task._process = proc
+  })
+}
+
+/**
+ * Kill the process associated with a task (used by timeout enforcement).
+ */
+export function kill(task: Task): void {
+  if (task._process && !task._process.killed) {
+    task._process.kill('SIGTERM')
+    setTimeout(() => {
+      if (task._process && !task._process.killed) {
+        task._process.kill('SIGKILL')
+      }
+    }, 5000)
+  }
+}

package/src/cli/run/adapters/copilot.ts

@@ -0,0 +1,97 @@
+import { spawn } from 'node:child_process'
+import type { Task, ExecuteOptions, ExecuteResult } from '../../types.js'
+
+/** Adapter name */
+export const name = 'copilot'
+
+/**
+ * Check if the `copilot` CLI is available on the system PATH.
+ */
+export async function isAvailable(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn('which', ['copilot'], { stdio: 'pipe' })
+    proc.on('close', (code) => resolve(code === 0))
+    proc.on('error', () => resolve(false))
+  })
+}
+
+/**
+ * Execute a task by invoking the Copilot CLI in autopilot mode.
+ */
+export async function execute(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  let prompt = `You are a ${task.agent}. ${task.prompt}`
+
+  if (task.files && task.files.length > 0) {
+    prompt += `\n\nOnly modify files under: ${task.files.join(', ')}`
+  }
+
+  const args = [
+    '-p',
+    prompt,
+    '--autopilot',
+    '--allow-all-tools',
+    '--no-ask-user',
+    '-s',
+    '--max-autopilot-continues',
+    '50',
+  ]
+
+  return new Promise((resolve) => {
+    const proc = spawn('copilot', args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+      cwd: process.cwd(),
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    proc.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString()
+      if (options.verbose) {
+        process.stdout.write(chunk)
+      }
+    })
+
+    proc.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString()
+      if (options.verbose) {
+        process.stderr.write(chunk)
+      }
+    })
+
+    proc.on('close', (code) => {
+      const output = [stdout, stderr].filter(Boolean).join('\n')
+      resolve({
+        success: code === 0,
+        output: output.slice(0, 10000), // Cap output size
+        exitCode: code ?? -1,
+      })
+    })
+
+    proc.on('error', (err) => {
+      resolve({
+        success: false,
+        output: `Failed to spawn copilot: ${err.message}`,
+        exitCode: -1,
+      })
+    })
+
+    // Store process ref for potential timeout kill
+    task._process = proc
+  })
+}
+
+/**
+ * Kill the process associated with a task (used by timeout enforcement).
+ */
+export function kill(task: Task): void {
+  if (task._process && !task._process.killed) {
+    task._process.kill('SIGTERM')
+    setTimeout(() => {
+      if (task._process && !task._process.killed) {
+        task._process.kill('SIGKILL')
+      }
+    }, 5000)
+  }
+}

package/src/cli/run/adapters/cursor.ts

@@ -0,0 +1,94 @@
+import { spawn } from 'node:child_process'
+import type { Task, ExecuteOptions, ExecuteResult } from '../../types.js'
+
+/** Adapter name */
+export const name = 'cursor'
+
+/**
+ * Check if the Cursor CLI (`agent`) is available on the system PATH.
+ */
+export async function isAvailable(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn('which', ['agent'], { stdio: 'pipe' })
+    proc.on('close', (code) => resolve(code === 0))
+    proc.on('error', () => resolve(false))
+  })
+}
+
+/**
+ * Execute a task by invoking the Cursor CLI in non-interactive print mode.
+ */
+export async function execute(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  let prompt = `You are a ${task.agent}. ${task.prompt}`
+
+  if (task.files && task.files.length > 0) {
+    prompt += `\n\nOnly modify files under: ${task.files.join(', ')}`
+  }
+
+  const args = [
+    '-p',
+    prompt,
+    '--force',
+    '--output-format',
+    'json',
+  ]
+
+  return new Promise((resolve) => {
+    const proc = spawn('agent', args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+      cwd: process.cwd(),
+    })
+
+    let stdout = ''
+    let stderr = ''
+
+    proc.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString()
+      if (options.verbose) {
+        process.stdout.write(chunk)
+      }
+    })
+
+    proc.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString()
+      if (options.verbose) {
+        process.stderr.write(chunk)
+      }
+    })
+
+    proc.on('close', (code) => {
+      const output = [stdout, stderr].filter(Boolean).join('\n')
+      resolve({
+        success: code === 0,
+        output: output.slice(0, 10000), // Cap output size
+        exitCode: code ?? -1,
+      })
+    })
+
+    proc.on('error', (err) => {
+      resolve({
+        success: false,
+        output: `Failed to spawn cursor agent CLI: ${err.message}`,
+        exitCode: -1,
+      })
+    })
+
+    // Store process ref for potential timeout kill
+    task._process = proc
+  })
+}
+
+/**
+ * Kill the process associated with a task (used by timeout enforcement).
+ */
+export function kill(task: Task): void {
+  if (task._process && !task._process.killed) {
+    task._process.kill('SIGTERM')
+    setTimeout(() => {
+      if (task._process && !task._process.killed) {
+        task._process.kill('SIGKILL')
+      }
+    }, 5000)
+  }
+}

package/src/cli/run/adapters/index.ts

@@ -0,0 +1,40 @@
+import type { AgentAdapter } from '../../types.js'
+
+/**
+ * Adapter registry for agent runtimes.
+ */
+const ADAPTERS: Record<string, () => Promise<AgentAdapter>> = {
+  'claude-code': () => import('./claude-code.js') as Promise<AgentAdapter>,
+  copilot: () => import('./copilot.js') as Promise<AgentAdapter>,
+  cursor: () => import('./cursor.js') as Promise<AgentAdapter>,
+}
+
+/**
+ * Get an adapter module by name.
+ * @throws If adapter is not registered
+ */
+export async function getAdapter(name: string): Promise<AgentAdapter> {
+  const loader = ADAPTERS[name]
+  if (!loader) {
+    const available = Object.keys(ADAPTERS).join(', ')
+    throw new Error(
+      `Unknown adapter "${name}". Available adapters: ${available}`
+    )
+  }
+  return loader()
+}
+
+/**
+ * List all registered adapters with their availability status.
+ */
+export async function listAdapters(): Promise<Array<{ name: string; available: boolean }>> {
+  const result: Array<{ name: string; available: boolean }> = []
+  for (const [name, loader] of Object.entries(ADAPTERS)) {
+    const mod = await loader()
+    result.push({
+      name,
+      available: await mod.isAvailable(),
+    })
+  }
+  return result
+}