goiabaseeds 1.0.0

package/src/state-manager.js

@@ -0,0 +1,280 @@
+import { copyFile, readFile, writeFile, mkdir, rm } from 'node:fs/promises';
+import { join, dirname } from 'node:path';
+
+/**
+ * StateManager — encapsulates all state.json read/write operations.
+ *
+ * Output matches the DepartmentState interface in dashboard/src/types/state.ts:
+ * {
+ *   department: string,
+ *   status: "idle" | "running" | "completed" | "checkpoint",
+ *   step: { current: number, total: number, label: string },
+ *   agents: Agent[],
+ *   handoff: Handoff | null,
+ *   approvals?: { pending: PendingApproval[] },
+ *   startedAt: string | null,
+ *   updatedAt: string,
+ *   completedAt?: string,
+ *   failedAt?: string
+ * }
+ */
+export class StateManager {
+  /**
+   * @param {object} options
+   * @param {string} options.departmentDir - Absolute path to the department directory
+   * @param {string} options.departmentCode - Department code identifier
+   * @param {Array<{id: string, name: string, icon: string}>} options.agents - Agent list from department-party.csv
+   * @param {number} options.totalSteps - Total number of pipeline steps
+   */
+  constructor({ departmentDir, departmentCode, agents, totalSteps }) {
+    this.departmentDir = departmentDir;
+    this.departmentCode = departmentCode;
+    this.totalSteps = totalSteps;
+    this.statePath = join(departmentDir, 'state.json');
+    this.startedAt = null;
+
+    // Build agents array with desk positions
+    // Formula from runner.pipeline.md: col = (index % 3) + 1, row = floor(index / 3) + 1
+    this.agents = agents.map((agent, index) => ({
+      id: agent.id,
+      name: agent.name,
+      icon: agent.icon,
+      status: 'idle',
+      deliverTo: null,
+      desk: {
+        col: (index % 3) + 1,
+        row: Math.floor(index / 3) + 1,
+      },
+      approval: null,
+    }));
+  }
+
+  /**
+   * Write initial idle state with all agents at desk positions.
+   */
+  async initialize() {
+    const state = {
+      department: this.departmentCode,
+      status: 'idle',
+      step: { current: 0, total: this.totalSteps, label: '' },
+      agents: this.agents.map(a => ({ ...a })),
+      handoff: null,
+      startedAt: null,
+      updatedAt: new Date().toISOString(),
+    };
+    await this._write(state);
+  }
+
+  /**
+   * Update state for a new step execution.
+   * Sets status to running, active agent to working, completed agents to done.
+   *
+   * @param {number} stepIndex - 0-based step index
+   * @param {string} label - Step ID / label
+   * @param {string} activeAgentId - Agent ID currently working
+   * @param {string[]} [completedAgentIds] - Agent IDs that have finished
+   */
+  async updateStep(stepIndex, label, activeAgentId, completedAgentIds = []) {
+    if (!this.startedAt) {
+      this.startedAt = new Date().toISOString();
+    }
+
+    const agents = this.agents.map(a => {
+      const copy = { ...a };
+      if (a.id === activeAgentId) {
+        copy.status = 'working';
+      } else if (completedAgentIds.includes(a.id)) {
+        copy.status = 'done';
+      } else {
+        copy.status = 'idle';
+      }
+      copy.deliverTo = null;
+      copy.approval = null;
+      return copy;
+    });
+
+    const state = {
+      department: this.departmentCode,
+      status: 'running',
+      step: { current: stepIndex + 1, total: this.totalSteps, label },
+      agents,
+      handoff: null,
+      startedAt: this.startedAt,
+      updatedAt: new Date().toISOString(),
+    };
+    await this._write(state);
+  }
+
+  /**
+   * Set delivering handoff animation (part 1).
+   * From agent status = "delivering" with deliverTo set.
+   *
+   * @param {string} fromId - Agent delivering
+   * @param {string} toId - Agent receiving
+   */
+  async setDelivering(fromId, toId) {
+    const current = await this._read();
+    if (!current) return;
+
+    for (const agent of current.agents) {
+      if (agent.id === fromId) {
+        agent.status = 'delivering';
+        agent.deliverTo = toId;
+      }
+    }
+
+    current.handoff = {
+      from: fromId,
+      to: toId,
+      startedAt: new Date().toISOString(),
+    };
+    current.updatedAt = new Date().toISOString();
+
+    await this._write(current);
+  }
+
+  /**
+   * Complete handoff animation (part 2).
+   * From agent = done, to agent = working.
+   *
+   * @param {string} fromId - Agent that delivered
+   * @param {string} toId - Agent now working
+   */
+  async setWorking(fromId, toId) {
+    const current = await this._read();
+    if (!current) return;
+
+    for (const agent of current.agents) {
+      if (agent.id === fromId) {
+        agent.status = 'done';
+        agent.deliverTo = null;
+      } else if (agent.id === toId) {
+        agent.status = 'working';
+      }
+    }
+
+    current.handoff = null;
+    current.updatedAt = new Date().toISOString();
+
+    await this._write(current);
+  }
+
+  /**
+   * Set checkpoint state with approval info.
+   *
+   * @param {string} agentId - Agent requesting approval
+   * @param {object} approval - Approval details
+   * @param {string} approval.step - Step ID
+   * @param {string} approval.question - Approval question
+   * @param {string} [approval.context] - Additional context
+   */
+  async setCheckpoint(agentId, approval) {
+    const current = await this._read();
+    if (!current) return;
+
+    current.status = 'checkpoint';
+
+    for (const agent of current.agents) {
+      if (agent.id === agentId) {
+        agent.status = 'waiting_approval';
+        agent.approval = {
+          needed: true,
+          step: approval.step,
+          question: approval.question,
+          context: approval.context || '',
+          requestedAt: new Date().toISOString(),
+        };
+      }
+    }
+
+    if (!current.approvals) current.approvals = { pending: [] };
+    current.approvals.pending.push({
+      agentId,
+      step: approval.step,
+      question: approval.question,
+      requestedAt: new Date().toISOString(),
+    });
+
+    current.updatedAt = new Date().toISOString();
+
+    await this._write(current);
+  }
+
+  /**
+   * Set pipeline as completed. All agents → done.
+   */
+  async complete() {
+    const current = await this._read();
+    if (!current) return;
+
+    current.status = 'completed';
+    current.completedAt = new Date().toISOString();
+    current.updatedAt = current.completedAt;
+    current.handoff = null;
+    current.approvals = undefined;
+
+    for (const agent of current.agents) {
+      agent.status = 'done';
+      agent.deliverTo = null;
+      agent.approval = null;
+    }
+
+    await this._write(current);
+  }
+
+  /**
+   * Set pipeline as failed.
+   * @param {string} reason - Failure reason
+   */
+  async fail(reason) {
+    const current = await this._read();
+    if (!current) return;
+
+    current.status = 'failed';
+    current.failedAt = new Date().toISOString();
+    current.updatedAt = current.failedAt;
+    current.error = reason;
+
+    await this._write(current);
+  }
+
+  /**
+   * Archive state.json to run output folder and delete working copy.
+   * @param {string} runId - Run ID (e.g., "2026-03-31-143022")
+   */
+  async archive(runId) {
+    const destDir = join(this.departmentDir, 'output', runId);
+    await mkdir(destDir, { recursive: true });
+    const destPath = join(destDir, 'state.json');
+    try {
+      await copyFile(this.statePath, destPath);
+    } catch {
+      // State file may not exist if pipeline failed early
+    }
+  }
+
+  /**
+   * Delete the working state.json.
+   */
+  async cleanup() {
+    try {
+      await rm(this.statePath);
+    } catch {
+      // Already deleted or doesn't exist
+    }
+  }
+
+  async _write(state) {
+    await mkdir(dirname(this.statePath), { recursive: true });
+    await writeFile(this.statePath, JSON.stringify(state, null, 2), 'utf-8');
+  }
+
+  async _read() {
+    try {
+      const raw = await readFile(this.statePath, 'utf-8');
+      return JSON.parse(raw);
+    } catch {
+      return null;
+    }
+  }
+}

package/src/tools.js

@@ -0,0 +1,158 @@
+import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { execSync } from 'node:child_process';
+
+/**
+ * Build AI SDK-compatible tools for a department run.
+ *
+ * @param {string[]} departmentSkills - Skills declared in department.yaml
+ * @param {string} targetDir - Project root directory
+ * @returns {Promise<object>} Map of tool name → AI SDK tool definition
+ */
+export async function buildTools(departmentSkills, targetDir) {
+  const { tool } = await import('ai');
+  const { z } = await import('zod');
+
+  const tools = {};
+
+  // Core tools — always available
+
+  tools.readFile = tool({
+    description: 'Read a file from disk. Returns the file content as a string.',
+    parameters: z.object({
+      path: z.string().describe('Absolute or relative file path to read'),
+    }),
+    execute: async ({ path }) => {
+      try {
+        const resolvedPath = join(targetDir, path);
+        return await readFile(resolvedPath, 'utf-8');
+      } catch (err) {
+        return `Error reading file: ${err.message}`;
+      }
+    },
+  });
+
+  tools.writeFile = tool({
+    description: 'Write content to a file. Creates parent directories if needed.',
+    parameters: z.object({
+      path: z.string().describe('Absolute or relative file path to write'),
+      content: z.string().describe('Content to write to the file'),
+    }),
+    execute: async ({ path, content }) => {
+      try {
+        const resolvedPath = join(targetDir, path);
+        await mkdir(dirname(resolvedPath), { recursive: true });
+        await writeFile(resolvedPath, content, 'utf-8');
+        return `File written: ${path}`;
+      } catch (err) {
+        return `Error writing file: ${err.message}`;
+      }
+    },
+  });
+
+  tools.listDirectory = tool({
+    description: 'List files and directories in a given path.',
+    parameters: z.object({
+      path: z.string().describe('Directory path to list'),
+    }),
+    execute: async ({ path }) => {
+      try {
+        const resolvedPath = join(targetDir, path);
+        const entries = await readdir(resolvedPath, { withFileTypes: true });
+        return entries
+          .map(e => `${e.isDirectory() ? '[DIR] ' : ''}${e.name}`)
+          .join('\n');
+      } catch (err) {
+        return `Error listing directory: ${err.message}`;
+      }
+    },
+  });
+
+  tools.bash = tool({
+    description: 'Execute a bash/shell command and return its output.',
+    parameters: z.object({
+      command: z.string().describe('The shell command to execute'),
+    }),
+    execute: async ({ command }) => {
+      try {
+        const output = execSync(command, {
+          cwd: targetDir,
+          encoding: 'utf-8',
+          timeout: 60_000,
+          maxBuffer: 1024 * 1024 * 5, // 5MB
+        });
+        return output || '(no output)';
+      } catch (err) {
+        return `Command failed (exit ${err.status}): ${err.stderr || err.message}`;
+      }
+    },
+  });
+
+  tools.webFetch = tool({
+    description: 'Fetch the text content of a URL.',
+    parameters: z.object({
+      url: z.string().url().describe('The URL to fetch'),
+    }),
+    execute: async ({ url }) => {
+      try {
+        const response = await fetch(url, {
+          headers: { 'User-Agent': 'GoiabaSeeds/1.0' },
+          signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok) {
+          return `HTTP ${response.status}: ${response.statusText}`;
+        }
+        const text = await response.text();
+        // Truncate to avoid overwhelming context
+        return text.length > 50_000 ? text.slice(0, 50_000) + '\n...(truncated)' : text;
+      } catch (err) {
+        return `Error fetching URL: ${err.message}`;
+      }
+    },
+  });
+
+  // Conditional tools — only if department declares the skill
+
+  if (departmentSkills.includes('web_search')) {
+    const tavilyKey = process.env.TAVILY_API_KEY;
+
+    tools.webSearch = tool({
+      description: 'Search the web for information. Returns search results with titles, URLs, and snippets.',
+      parameters: z.object({
+        query: z.string().describe('The search query'),
+        maxResults: z.number().optional().default(5).describe('Maximum number of results'),
+      }),
+      execute: async ({ query, maxResults }) => {
+        if (!tavilyKey) {
+          return 'Web search unavailable: TAVILY_API_KEY not set. Set it in your environment to enable web search.';
+        }
+        try {
+          const response = await fetch('https://api.tavily.com/search', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+              api_key: tavilyKey,
+              query,
+              max_results: maxResults,
+              include_answer: true,
+            }),
+            signal: AbortSignal.timeout(15_000),
+          });
+          if (!response.ok) {
+            return `Search API error: HTTP ${response.status}`;
+          }
+          const data = await response.json();
+          const results = (data.results || []).map(r =>
+            `**${r.title}**\n${r.url}\n${r.content || ''}`
+          );
+          const answer = data.answer ? `**Summary:** ${data.answer}\n\n` : '';
+          return answer + results.join('\n\n');
+        } catch (err) {
+          return `Search error: ${err.message}`;
+        }
+      },
+    });
+  }
+
+  return tools;
+}

package/src/update.js

@@ -0,0 +1,140 @@
+import { cp, mkdir, readFile, stat } from 'node:fs/promises';
+import { join, dirname, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadLocale, t } from './i18n.js';
+import { getTemplateEntries, loadSavedLocale } from './init.js';
+import { listAvailable as listAvailableSkills, listInstalled as listInstalledSkills, installSkill, getSkillMeta } from './skills.js';
+import { logEvent } from './logger.js';
+
+async function loadSavedIdes(targetDir) {
+  try {
+    const prefsPath = join(targetDir, '_goiabaseeds', '_memory', 'preferences.md');
+    const content = await readFile(prefsPath, 'utf-8');
+    const match = content.match(/\*\*IDEs:\*\*\s*(.+)/);
+    if (match) {
+      return match[1].trim().split(/,\s*/);
+    }
+  } catch {
+    // No preferences file
+  }
+  return ['claude-code'];
+}
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, '..', 'templates');
+
+const PROTECTED_PATHS = [
+  '_goiabaseeds/_memory',
+  '_goiabaseeds/_investigations',
+  'agents',
+  'departments',
+];
+
+function isProtected(relativePath) {
+  const normalized = relativePath.replaceAll('\\', '/');
+  return PROTECTED_PATHS.some(
+    (p) => normalized === p || normalized.startsWith(p + '/')
+  );
+}
+
+export async function update(targetDir) {
+  console.log('\n  🔄 GoiabaSeeds — Update\n');
+
+  // 1. Check initialized
+  try {
+    await stat(join(targetDir, '_goiabaseeds'));
+  } catch {
+    await loadLocale('English');
+    console.log(`  ${t('updateNotInitialized')}`);
+    return { success: false };
+  }
+
+  // 2. Load user's locale
+  await loadSavedLocale(targetDir);
+
+  // 3. Read versions
+  let currentVersion = null;
+  try {
+    currentVersion = (
+      await readFile(join(targetDir, '_goiabaseeds', '.goiabaseeds-version'), 'utf-8')
+    ).trim();
+  } catch {
+    // Legacy install — no version file
+  }
+
+  const newVersion = (
+    await readFile(join(TEMPLATES_DIR, '_goiabaseeds', '.goiabaseeds-version'), 'utf-8')
+  ).trim();
+
+  // 4. Announce
+  if (currentVersion) {
+    console.log(
+      `  ${t('updateStarting', { old: `v${currentVersion}`, new: `v${newVersion}` })}`
+    );
+  } else {
+    console.log(`  ${t('updateStartingUnknown', { new: `v${newVersion}` })}`);
+  }
+
+  // 5. Copy common templates, skipping protected paths and ide-templates/
+  const entries = await getTemplateEntries(TEMPLATES_DIR);
+  let count = 0;
+
+  for (const entry of entries) {
+    const relativePath = relative(TEMPLATES_DIR, entry);
+    if (isProtected(relativePath)) continue;
+    // Skip ide-templates — handled separately below
+    if (relativePath.replaceAll('\\', '/').startsWith('ide-templates/')) continue;
+
+    const destPath = join(targetDir, relativePath);
+    await mkdir(dirname(destPath), { recursive: true });
+    await cp(entry, destPath);
+    console.log(`  ${t('updatedFile', { path: relativePath.replaceAll('\\', '/') })}`);
+    count++;
+  }
+
+  // 6. Copy IDE-specific templates based on saved preferences
+  const ides = await loadSavedIdes(targetDir);
+  for (const ide of ides) {
+    const ideSrcDir = join(TEMPLATES_DIR, 'ide-templates', ide);
+    let ideEntries;
+    try {
+      ideEntries = await getTemplateEntries(ideSrcDir);
+    } catch {
+      continue; // no template dir for this IDE
+    }
+    for (const entry of ideEntries) {
+      const relPath = relative(ideSrcDir, entry);
+      if (isProtected(relPath)) continue;
+
+      const destPath = join(targetDir, relPath);
+      await mkdir(dirname(destPath), { recursive: true });
+      await cp(entry, destPath);
+      console.log(`  ${t('updatedFile', { path: relPath.replaceAll('\\', '/') })}`);
+      count++;
+    }
+  }
+
+  // 6b. Install new non-MCP, non-hybrid bundled skills not already present
+  const availableSkills = await listAvailableSkills();
+  const installedSkills = await listInstalledSkills(targetDir);
+  for (const id of availableSkills) {
+    if (id === 'goiabaseeds-skill-creator') continue;
+    if (installedSkills.includes(id)) continue;
+    const meta = await getSkillMeta(id);
+    if (!meta) continue;
+    if (meta.type === 'mcp' || meta.type === 'hybrid') continue;
+    await installSkill(id, targetDir);
+    console.log(`  ${t('createdFile', { path: `skills/${id}/SKILL.md` })}`);
+    count++;
+  }
+
+  // 7. Summary
+  console.log(`\n  ${t('updateFileCount', { count })}`);
+  console.log(`  ${t('updatePreserved')}`);
+  console.log(`  ${t('updateSuccess', { version: `v${newVersion}` })}`);
+  console.log(`\n  ${t('updateLatestHint')}\n`);
+
+  await logEvent('update', { from: currentVersion || 'unknown', to: newVersion }, targetDir);
+
+  return { success: true };
+}

package/templates/_goiabaseeds/.goiabaseeds-version

@@ -0,0 +1 @@
+1.0.0

package/templates/_goiabaseeds/config/playwright.config.json

@@ -0,0 +1,11 @@
+{
+  "browser": {
+    "browserName": "chromium",
+    "isolated": false,
+    "userDataDir": "_goiabaseeds/_browser_profile",
+    "launchOptions": {
+      "headless": true,
+      "channel": "chrome"
+    }
+  }
+}