goiabaseeds 1.0.0

package/src/pipeline-runner.js

@@ -0,0 +1,478 @@
+import { readFile, readdir, mkdir, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { StateManager } from './state-manager.js';
+import { AgentSession } from './agent-session.js';
+import { composeAgentContext, parseFrontmatter } from './context.js';
+import { buildTools } from './tools.js';
+
+/**
+ * PipelineRunner — programmatic pipeline execution engine.
+ *
+ * Translates the 400-line runner.pipeline.md LLM instructions
+ * into deterministic Node.js code.
+ */
+export class PipelineRunner {
+  /**
+   * @param {object} options
+   * @param {string} options.targetDir - Project root directory
+   * @param {string} options.departmentName - Department directory name
+   * @param {object} options.provider - Provider instance from createProvider()
+   * @param {(msg: string) => void} [options.onLog] - Logging callback
+   * @param {() => Promise<string>} [options.onCheckpoint] - Checkpoint approval callback
+   */
+  constructor({ targetDir, departmentName, provider, onLog, onCheckpoint }) {
+    this.targetDir = targetDir;
+    this.departmentName = departmentName;
+    this.departmentDir = join(targetDir, 'departments', departmentName);
+    this.provider = provider;
+    this.onLog = onLog || ((msg) => console.log(`  ${msg}`));
+    this.onCheckpoint = onCheckpoint;
+    this.stateManager = null;
+    this.runId = null;
+    this.completedAgentIds = [];
+    this.mainSession = null;
+    this.versionCache = new Map();
+  }
+
+  /**
+   * Execute the full pipeline.
+   * @returns {Promise<{success: boolean, runId: string}>}
+   */
+  async run() {
+    // --- INITIALIZATION ---
+    const { department, agents, pipeline, skills } = await this._loadDepartment();
+
+    this.onLog(`🏢 ${department.name || this.departmentName}`);
+    this.onLog(`📋 ${pipeline.steps.length} steps | ${agents.length} agents`);
+
+    // Generate run ID
+    this.runId = await this._generateRunId();
+    await mkdir(join(this.departmentDir, 'output', this.runId), { recursive: true });
+    this.onLog(`📁 Run: ${this.runId}`);
+
+    // Initialize state manager
+    this.stateManager = new StateManager({
+      departmentDir: this.departmentDir,
+      departmentCode: department.code || this.departmentName,
+      agents,
+      totalSteps: pipeline.steps.length,
+    });
+    await this.stateManager.initialize();
+
+    // Build tools
+    const tools = await buildTools(skills, this.targetDir);
+
+    // --- STEP EXECUTION LOOP ---
+    try {
+      for (let i = 0; i < pipeline.steps.length; i++) {
+        const stepFile = pipeline.steps[i];
+        const stepPath = join(this.departmentDir, 'pipeline', 'steps', stepFile);
+        const stepContent = await readFile(stepPath, 'utf-8');
+        const { meta: stepMeta, body: stepBody } = parseFrontmatter(stepContent);
+
+        const stepId = stepMeta.step_id || stepFile.replace(/\.md$/, '');
+        const agentId = stepMeta.agent;
+        const execution = stepMeta.execution || 'subagent';
+        const modelTier = stepMeta.model_tier || 'powerful';
+
+        this.onLog('');
+        this.onLog(`━━━ Step ${i + 1}/${pipeline.steps.length}: ${stepId} ━━━`);
+
+        // --- DASHBOARD HANDOFF (between steps) ---
+        if (i > 0 && agentId) {
+          const prevStep = pipeline.steps[i - 1];
+          const prevContent = await readFile(
+            join(this.departmentDir, 'pipeline', 'steps', prevStep), 'utf-8'
+          );
+          const { meta: prevMeta } = parseFrontmatter(prevContent);
+          const prevAgentId = prevMeta.agent;
+
+          if (prevAgentId && prevAgentId !== agentId) {
+            await this.stateManager.setDelivering(prevAgentId, agentId);
+            await sleep(3000);
+            await this.stateManager.setWorking(prevAgentId, agentId);
+          }
+        }
+
+        // --- CHECKPOINT ---
+        if (stepMeta.type === 'checkpoint') {
+          await this._executeCheckpoint(stepMeta, stepBody, i, agentId);
+          continue;
+        }
+
+        // --- UPDATE STATE ---
+        await this.stateManager.updateStep(i, stepId, agentId, this.completedAgentIds);
+
+        // --- RESOLVE AGENT ---
+        const agentPath = this._resolveAgentPath(agentId, agents);
+
+        // --- COMPOSE CONTEXT ---
+        const systemPrompt = await composeAgentContext({
+          agentPath,
+          stepMeta,
+          departmentDir: this.departmentDir,
+          targetDir: this.targetDir,
+        });
+
+        // --- BUILD USER PROMPT ---
+        const userPrompt = await this._buildUserPrompt(stepMeta, stepBody);
+
+        // --- EXECUTE ---
+        if (execution === 'subagent') {
+          await this._executeSubagent({
+            stepMeta, systemPrompt, userPrompt, modelTier, tools, agentId, stepId,
+          });
+        } else {
+          // inline
+          await this._executeInline({
+            stepMeta, systemPrompt, userPrompt, modelTier, tools, agentId, stepId,
+          });
+        }
+
+        // Track completed agent
+        if (agentId && !this.completedAgentIds.includes(agentId)) {
+          this.completedAgentIds.push(agentId);
+        }
+      }
+
+      // --- POST-COMPLETION ---
+      await this.stateManager.complete();
+      await this.stateManager.archive(this.runId);
+
+      this.onLog('');
+      this.onLog('✅ Pipeline completed!');
+      this.onLog(`📁 Output: departments/${this.departmentName}/output/${this.runId}/`);
+
+      // Wait 10s for dashboard to show completed state, then clean up
+      await sleep(10_000);
+      await this.stateManager.cleanup();
+
+      return { success: true, runId: this.runId };
+
+    } catch (err) {
+      await this.stateManager.fail(err.message);
+      this.onLog(`\n❌ Pipeline failed: ${err.message}`);
+      return { success: false, runId: this.runId };
+    }
+  }
+
+  // ── Execution modes ──────────────────────────────────────────
+
+  async _executeSubagent({ stepMeta, systemPrompt, userPrompt, modelTier, tools, agentId, stepId }) {
+    const agentInfo = this._findAgent(agentId);
+    this.onLog(`🔍 ${agentInfo?.icon || '🤖'} ${agentInfo?.name || agentId} is working in the background...`);
+
+    const model = this.provider.getModel(modelTier);
+    const session = new AgentSession({ model, systemPrompt, tools });
+    const result = await session.run(userPrompt);
+
+    // Verify output file if specified
+    if (stepMeta.outputFile) {
+      const outputPath = this._transformOutputPath(stepMeta.outputFile);
+      await this._verifyOrWriteOutput(outputPath, result);
+    }
+
+    // Veto condition check
+    if (stepMeta.veto) {
+      await this._checkVeto(result, stepMeta, systemPrompt, tools, modelTier);
+    }
+
+    this.onLog(`✓ ${agentInfo?.name || agentId} completed`);
+  }
+
+  async _executeInline({ stepMeta, systemPrompt, userPrompt, modelTier, tools, agentId, stepId }) {
+    const agentInfo = this._findAgent(agentId);
+    this.onLog(`${agentInfo?.icon || '🤖'} ${agentInfo?.name || agentId} is working...`);
+
+    const model = this.provider.getModel(modelTier);
+
+    // Inline steps share the main session
+    if (!this.mainSession) {
+      this.mainSession = new AgentSession({ model, systemPrompt, tools });
+    } else {
+      // Update system prompt for new agent
+      this.mainSession.systemPrompt = systemPrompt;
+      this.mainSession.model = model;
+    }
+
+    const result = await this.mainSession.runStreaming(userPrompt, (chunk) => {
+      process.stdout.write(chunk);
+    });
+    console.log(''); // newline after streaming
+
+    if (stepMeta.outputFile) {
+      const outputPath = this._transformOutputPath(stepMeta.outputFile);
+      await this._verifyOrWriteOutput(outputPath, result);
+    }
+
+    this.onLog(`✓ ${agentInfo?.name || agentId} completed`);
+  }
+
+  async _executeCheckpoint(stepMeta, stepBody, stepIndex, agentId) {
+    const question = stepMeta.approval_question || stepBody.trim() || 'Approve and continue?';
+
+    this.onLog(`⏸️  Checkpoint: ${stepMeta.step_id || 'approval'}`);
+
+    // Set checkpoint state for dashboard
+    if (agentId) {
+      await this.stateManager.setCheckpoint(agentId, {
+        step: stepMeta.step_id || `step-${stepIndex}`,
+        question,
+        context: stepBody,
+      });
+    }
+
+    // Get approval — CLI or dashboard
+    let response;
+    if (this.onCheckpoint) {
+      response = await this.onCheckpoint(question, stepMeta);
+    } else {
+      response = await this._cliCheckpoint(question);
+    }
+
+    this.onLog(`✓ Checkpoint resolved: ${response.action}`);
+
+    // Write response to outputFile if specified (run_id injection only, no version folder)
+    if (stepMeta.outputFile) {
+      const outputPath = this._transformOutputPathStep1Only(stepMeta.outputFile);
+      const { writeFile: fsWriteFile } = await import('node:fs/promises');
+      const { dirname: pathDirname } = await import('node:path');
+      const { mkdir: fsMkdir } = await import('node:fs/promises');
+      await fsMkdir(pathDirname(outputPath), { recursive: true });
+      await fsWriteFile(outputPath, response.instruction || response.action, 'utf-8');
+    }
+
+    // Update state back to running
+    await this.stateManager.updateStep(stepIndex, stepMeta.step_id || '', agentId, this.completedAgentIds);
+  }
+
+  async _cliCheckpoint(question) {
+    const { default: selectFn } = await import('@inquirer/select');
+    const action = await selectFn({
+      message: question,
+      choices: [
+        { name: 'Approve', value: 'approve' },
+        { name: 'Revise', value: 'revise' },
+      ],
+    });
+
+    let instruction = '';
+    if (action === 'revise') {
+      const { default: inputFn } = await import('@inquirer/input');
+      instruction = await inputFn({ message: 'Revision instructions:' });
+    }
+
+    return { action, instruction };
+  }
+
+  // ── Veto conditions ──────────────────────────────────────────
+
+  async _checkVeto(output, stepMeta, systemPrompt, tools, modelTier) {
+    // Simple veto check using fast model
+    const model = this.provider.getModel('fast');
+    const vetoSession = new AgentSession({
+      model,
+      systemPrompt: 'You are a quality checker. Evaluate if the output violates any veto conditions. Reply with PASS if all conditions are met, or FAIL: <reason> if any are violated.',
+      tools: {},
+    });
+
+    const vetoPrompt = `## Veto Conditions\n${stepMeta.veto}\n\n## Output to Check\n${output}`;
+    const result = await vetoSession.run(vetoPrompt);
+
+    if (result.toUpperCase().startsWith('FAIL')) {
+      this.onLog(`⚠️  Veto triggered: ${result}`);
+      // Could implement retry logic here (max 2 attempts per runner.pipeline.md)
+    }
+  }
+
+  // ── Output path transformation ───────────────────────────────
+
+  /**
+   * Apply full output path transformation (Step 1 + Step 2).
+   * Step 1: Insert run_id after departments/{name}/output/
+   * Step 2: Insert version folder (v1, v2, etc.) before filename
+   */
+  _transformOutputPath(rawPath) {
+    let path = this._transformOutputPathStep1Only(rawPath);
+
+    // Step 2: Version folder
+    const parts = path.replace(/\\/g, '/').split('/');
+    const filename = parts.pop();
+    const groupDir = parts.join('/');
+
+    // Check cache for this group
+    if (this.versionCache.has(groupDir)) {
+      return join(groupDir, this.versionCache.get(groupDir), filename);
+    }
+
+    // Detect existing versions
+    let version = 'v1';
+    try {
+      const { readdirSync } = require('node:fs');
+      const entries = readdirSync(groupDir);
+      const versions = entries
+        .filter(e => /^v\d+$/.test(e))
+        .map(e => parseInt(e.slice(1)))
+        .sort((a, b) => a - b);
+      if (versions.length > 0) {
+        version = `v${versions[versions.length - 1] + 1}`;
+      }
+    } catch {
+      // Directory doesn't exist yet — v1
+    }
+
+    this.versionCache.set(groupDir, version);
+    return join(groupDir, version, filename);
+  }
+
+  /**
+   * Step 1 only: Insert run_id after departments/{name}/output/
+   * Used for checkpoint files (no version folder).
+   */
+  _transformOutputPathStep1Only(rawPath) {
+    const normalized = rawPath.replace(/\\/g, '/');
+    const outputPrefix = `departments/${this.departmentName}/output/`;
+
+    if (normalized.startsWith(outputPrefix)) {
+      const rest = normalized.slice(outputPrefix.length);
+      return join(this.targetDir, outputPrefix, this.runId, rest);
+    }
+
+    // If path doesn't match pattern, resolve relative to targetDir
+    return join(this.targetDir, normalized);
+  }
+
+  // ── Helper methods ───────────────────────────────────────────
+
+  async _loadDepartment() {
+    const { parse } = await import('yaml');
+
+    // Read department.yaml
+    const deptYaml = await readFile(join(this.departmentDir, 'department.yaml'), 'utf-8');
+    const department = parse(deptYaml);
+
+    // Read department-party.csv for agent info
+    const agents = await this._parsePartyCSV();
+
+    // Read pipeline.yaml
+    const pipelineYaml = await readFile(
+      join(this.departmentDir, 'pipeline', 'pipeline.yaml'), 'utf-8'
+    );
+    const pipelineRaw = parse(pipelineYaml);
+
+    // Extract step file list from pipeline
+    const steps = [];
+    if (Array.isArray(pipelineRaw?.steps)) {
+      for (const step of pipelineRaw.steps) {
+        if (typeof step === 'string') {
+          steps.push(step);
+        } else if (step?.file) {
+          steps.push(step.file);
+        }
+      }
+    }
+
+    // Extract skills list
+    const skills = department.skills || [];
+
+    return { department, agents, pipeline: { steps }, skills };
+  }
+
+  async _parsePartyCSV() {
+    const partyPath = join(this.departmentDir, 'department-party.csv');
+    try {
+      const content = await readFile(partyPath, 'utf-8');
+      const lines = content.split('\n').filter(l => l.trim());
+
+      // Skip header if present
+      const startIdx = lines[0]?.includes('id,') || lines[0]?.includes('id\t') ? 1 : 0;
+
+      return lines.slice(startIdx).map(line => {
+        const [id, name, icon] = line.split(',').map(s => s?.trim());
+        return { id: id || '', name: name || id || '', icon: icon || '🤖' };
+      });
+    } catch {
+      // No party CSV — fallback to department.yaml agents
+      const deptYaml = await readFile(join(this.departmentDir, 'department.yaml'), 'utf-8');
+      const { parse } = await import('yaml');
+      const dept = parse(deptYaml);
+      return (dept.agents || []).map((a, i) => {
+        const id = typeof a === 'string' ? a : Object.keys(a)[0];
+        return { id, name: id, icon: '🤖' };
+      });
+    }
+  }
+
+  _resolveAgentPath(agentId, agents) {
+    // Try standard location
+    return join(this.departmentDir, 'agents', `${agentId}.agent.md`);
+  }
+
+  _findAgent(agentId) {
+    if (!this.stateManager) return null;
+    return this.stateManager.agents.find(a => a.id === agentId);
+  }
+
+  async _buildUserPrompt(stepMeta, stepBody) {
+    const parts = [stepBody];
+
+    // Include input file content if specified
+    if (stepMeta.inputFile) {
+      try {
+        const inputPath = join(this.targetDir, stepMeta.inputFile);
+        const inputContent = await readFile(inputPath, 'utf-8');
+        parts.push(`\n--- INPUT ---\n${inputContent}`);
+      } catch {
+        parts.push(`\n--- INPUT ---\n(Input file not found: ${stepMeta.inputFile})`);
+      }
+    }
+
+    // Include transformed output path
+    if (stepMeta.outputFile) {
+      const outputPath = this._transformOutputPath(stepMeta.outputFile);
+      parts.push(`\n--- OUTPUT PATH ---\nWrite your output to: ${outputPath}`);
+    }
+
+    return parts.join('\n');
+  }
+
+  async _verifyOrWriteOutput(outputPath, content) {
+    const { writeFile: fsWrite } = await import('node:fs/promises');
+    const { dirname: pathDirname } = await import('node:path');
+    const dir = pathDirname(outputPath);
+    await mkdir(dir, { recursive: true });
+
+    // Check if the agent already wrote the file via tools
+    try {
+      await stat(outputPath);
+      return; // File exists — agent wrote it
+    } catch {
+      // Agent didn't write it — write the response text as output
+      await fsWrite(outputPath, content, 'utf-8');
+    }
+  }
+
+  async _generateRunId() {
+    const now = new Date();
+    const pad = (n) => String(n).padStart(2, '0');
+    let baseId = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}-${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+
+    const outputDir = join(this.departmentDir, 'output');
+    try {
+      const entries = await readdir(outputDir);
+      let id = baseId;
+      let suffix = 2;
+      while (entries.includes(id)) {
+        id = `${baseId}-${suffix}`;
+        suffix++;
+      }
+      return id;
+    } catch {
+      return baseId;
+    }
+  }
+}
+
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/prompt.js

@@ -0,0 +1,46 @@
+import { t } from './i18n.js';
+
+export function createPrompt() {
+  return {
+    async ask(question) {
+      const { default: input } = await import('@inquirer/input');
+      return input({ message: question });
+    },
+    async choose(question, options) {
+      const { default: select } = await import('@inquirer/select');
+
+      const choices = options.map(opt => ({
+        name: opt.label,
+        value: opt,
+      }));
+
+      return select({
+        message: `  ${question}`,
+        choices,
+        loop: false,
+      });
+    },
+    async multiChoose(question, options, { validate } = {}) {
+      const { default: checkbox, Separator } = await import('@inquirer/checkbox');
+
+      const choices = options.map(opt => {
+        if (opt.separator) return new Separator(opt.label);
+        return {
+          name: opt.label,
+          value: opt.value,
+          checked: opt.checked ?? false,
+          disabled: opt.disabled ? t('comingSoon') : false,
+        };
+      });
+
+      return checkbox({
+        message: `  ${question}`,
+        choices,
+        loop: false,
+        validate: validate ?? ((selected) =>
+          selected.length > 0 || t('atLeastOneIde')),
+      });
+    },
+    close() {},
+  };
+}

package/src/provider.js

@@ -0,0 +1,156 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const CONFIG_PATH = '_goiabaseeds/config.yaml';
+
+const PROVIDER_PACKAGES = {
+  anthropic: '@ai-sdk/anthropic',
+  openai: '@ai-sdk/openai',
+  google: '@ai-sdk/google',
+  'github-copilot': '@ai-sdk/openai',
+};
+
+const ENV_KEYS = {
+  anthropic: 'ANTHROPIC_API_KEY',
+  openai: 'OPENAI_API_KEY',
+  google: 'GOOGLE_GENERATIVE_AI_API_KEY',
+  'github-copilot': 'GITHUB_TOKEN',
+};
+
+const DEFAULT_CONFIG = {
+  runtime: 'standalone',
+  default_provider: 'anthropic',
+  providers: {
+    anthropic: {
+      models: {
+        powerful: 'claude-sonnet-4-20250514',
+        fast: 'claude-haiku-4-5-20251001',
+      },
+    },
+    openai: {
+      models: {
+        powerful: 'gpt-4o',
+        fast: 'gpt-4o-mini',
+      },
+    },
+    google: {
+      models: {
+        powerful: 'gemini-2.5-pro',
+        fast: 'gemini-2.0-flash',
+      },
+    },
+    'github-copilot': {
+      models: {
+        powerful: 'gpt-4o',
+        fast: 'gpt-4o-mini',
+      },
+    },
+  },
+};
+
+/**
+ * Parse a simple YAML config file.
+ * Uses the `yaml` package for nested structures.
+ */
+export async function loadProviderConfig(targetDir) {
+  const configPath = join(targetDir, CONFIG_PATH);
+  try {
+    const raw = await readFile(configPath, 'utf-8');
+    const { parse } = await import('yaml');
+    const parsed = parse(raw);
+    return {
+      runtime: parsed?.runtime || DEFAULT_CONFIG.runtime,
+      default_provider: parsed?.default_provider || DEFAULT_CONFIG.default_provider,
+      providers: { ...DEFAULT_CONFIG.providers, ...parsed?.providers },
+    };
+  } catch (err) {
+    if (err.code === 'ENOENT') return { ...DEFAULT_CONFIG };
+    throw err;
+  }
+}
+
+/**
+ * Create a provider instance with model resolution.
+ *
+ * @param {object} config - The provider config from loadProviderConfig()
+ * @returns {{ getModel(tier: string): object, getProviderName(): string, listModels(): object, getEnvKey(): string }}
+ */
+export async function createProvider(config) {
+  const providerName = config.default_provider;
+  const providerConfig = config.providers[providerName];
+
+  if (!providerConfig) {
+    throw new Error(`Provider "${providerName}" not found in config. Available: ${Object.keys(config.providers).join(', ')}`);
+  }
+
+  const envKey = ENV_KEYS[providerName];
+  const apiKey = process.env[envKey];
+
+  if (!apiKey) {
+    throw new Error(
+      `Missing API key for ${providerName}. Set the ${envKey} environment variable.\n` +
+      `  Example: export ${envKey}=your-key-here`
+    );
+  }
+
+  // Dynamic import — only load the SDK package for the configured provider
+  const pkgName = PROVIDER_PACKAGES[providerName];
+  let sdkModule;
+  try {
+    sdkModule = await import(pkgName);
+  } catch {
+    throw new Error(
+      `Provider package "${pkgName}" not installed.\n` +
+      `  Run: npm install ${pkgName}`
+    );
+  }
+
+  // Build the provider factory
+  let providerInstance;
+
+  if (providerName === 'github-copilot') {
+    // Copilot uses OpenAI SDK with custom endpoint
+    const { createOpenAI } = sdkModule;
+    providerInstance = createOpenAI({
+      apiKey,
+      baseURL: 'https://api.githubcopilot.com',
+    });
+  } else if (providerName === 'anthropic') {
+    const { createAnthropic } = sdkModule;
+    providerInstance = createAnthropic({ apiKey });
+  } else if (providerName === 'openai') {
+    const { createOpenAI } = sdkModule;
+    providerInstance = createOpenAI({ apiKey });
+  } else if (providerName === 'google') {
+    const { createGoogleGenerativeAI } = sdkModule;
+    providerInstance = createGoogleGenerativeAI({ apiKey });
+  }
+
+  return {
+    /**
+     * Get an AI SDK model instance for the given tier.
+     * @param {'fast'|'powerful'} tier
+     * @returns {object} AI SDK model instance
+     */
+    getModel(tier) {
+      const modelId = tier === 'fast'
+        ? providerConfig.models.fast
+        : providerConfig.models.powerful;
+      return providerInstance(modelId);
+    },
+
+    getProviderName() {
+      return providerName;
+    },
+
+    getEnvKey() {
+      return envKey;
+    },
+
+    listModels() {
+      return { ...providerConfig.models };
+    },
+  };
+}
+
+export { DEFAULT_CONFIG, ENV_KEYS, PROVIDER_PACKAGES };