goiabaseeds 1.0.0

package/src/agents-cli.js

@@ -0,0 +1,158 @@
+import { createInterface } from 'node:readline';
+import { stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { listInstalled, installAgent, removeAgent, getAgentMeta, getLocalizedDescription } from './agents.js';
+import { loadLocale, t, getLocaleCode } from './i18n.js';
+import { loadSavedLocale } from './init.js';
+import { logEvent } from './logger.js';
+
+async function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim().toLowerCase());
+    });
+  });
+}
+
+export async function agentsCli(subcommand, args, targetDir) {
+  // Require initialized project
+  try {
+    await stat(join(targetDir, '_goiabaseeds'));
+  } catch {
+    await loadLocale('English');
+    console.log(`\n  ${t('agentsNotInitialized')}\n`);
+    return { success: false };
+  }
+
+  await loadSavedLocale(targetDir);
+
+  try {
+    if (subcommand === 'list' || !subcommand) {
+      await runList(targetDir);
+    } else if (subcommand === 'install') {
+      const installed = await runInstall(args[0], targetDir);
+      if (installed === false) return { success: false };
+    } else if (subcommand === 'remove') {
+      const removed = await runRemove(args[0], targetDir);
+      if (removed === false) return { success: false };
+    } else if (subcommand === 'update') {
+      await runUpdate(targetDir);
+    } else if (subcommand === 'update-one') {
+      await runUpdateOne(args[0], targetDir);
+    } else {
+      console.log(`\n  ${t('agentsUnknownCommand', { cmd: subcommand })}\n`);
+      return { success: false };
+    }
+  } catch (err) {
+    console.log(`\n  ${t('agentsError', { message: err.message })}\n`);
+    return { success: false };
+  }
+
+  return { success: true };
+}
+
+async function runList(targetDir) {
+  console.log(`\n  GoiabaSeeds Agents\n`);
+
+  const installed = await listInstalled(targetDir);
+
+  if (installed.length > 0) {
+    console.log(`  ${t('agentsInstalledHeader')}`);
+    for (const id of installed) {
+      const meta = await getAgentMeta(id);
+      if (meta) {
+        const desc = getLocalizedDescription(meta, getLocaleCode());
+        const parts = [meta.name];
+        if (meta.icon) parts.unshift(meta.icon);
+        if (meta.category) parts.push(`(${meta.category})`);
+        parts.push(`- ${desc.split('.')[0]}`);
+        console.log(`    ${parts.join(' ')}`);
+      } else {
+        console.log(`    ${id}`);
+      }
+    }
+  } else {
+    console.log(`  ${t('agentsNoneInstalled')}`);
+  }
+
+  console.log(`\n  Browse available agents at: https://github.com/netoribeiro/goiabaseeds/tree/main/agents\n`);
+}
+
+async function runInstall(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: goiabaseeds agents install <id>\n');
+    return false;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (installed.includes(id)) {
+    const answer = await confirm(`\n  ${t('agentsAlreadyInstalled', { id })}`);
+    // Accept 'y' (English) or 's' (Portuguese "sim") as affirmative answers
+    if (answer !== 'y' && answer !== 's') return false;
+    console.log(`  ${t('agentsInstalling', { id })}`);
+    await installAgent(id, targetDir);
+    console.log(`  ${t('agentsReinstalled', { id })}\n`);
+    await logEvent('agent:install', { name: id, reinstall: true }, targetDir);
+    return;
+  }
+
+  console.log(`\n  ${t('agentsInstalling', { id })}`);
+  await installAgent(id, targetDir);
+  console.log(`  ${t('agentsInstalled', { id })}\n`);
+  await logEvent('agent:install', { name: id }, targetDir);
+}
+
+async function runRemove(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: goiabaseeds agents remove <id>\n');
+    return false;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (!installed.includes(id)) {
+    console.log(`\n  ${t('agentsNotInstalled', { id })}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('agentsRemoving', { id })}`);
+  await removeAgent(id, targetDir);
+  await logEvent('agent:remove', { name: id }, targetDir);
+  console.log(`  ${t('agentsRemoved', { id })}\n`);
+}
+
+async function runUpdate(targetDir) {
+  const installed = await listInstalled(targetDir);
+  if (installed.length === 0) {
+    console.log(`\n  ${t('agentsUpdateNone')}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('agentsUpdating')}`);
+  for (const id of installed) {
+    console.log(`  ${t('agentsInstalling', { id })}`);
+    await installAgent(id, targetDir);
+    console.log(`  ${t('agentsInstalled', { id })}`);
+  }
+  await logEvent('agent:update', { count: installed.length }, targetDir);
+  console.log(`\n  ${t('agentsUpdateDone', { count: installed.length })}\n`);
+}
+
+async function runUpdateOne(id, targetDir) {
+  if (!id) {
+    console.log('\n  Usage: goiabaseeds update <name>\n');
+    return;
+  }
+
+  const installed = await listInstalled(targetDir);
+  if (!installed.includes(id)) {
+    console.log(`\n  ${t('agentsNotInstalled', { id })}\n`);
+    return;
+  }
+
+  console.log(`\n  ${t('agentsInstalling', { id })}`);
+  await installAgent(id, targetDir);
+  await logEvent('agent:update', { name: id }, targetDir);
+  console.log(`  ${t('agentsInstalled', { id })}\n`);
+}

package/src/agents.js

@@ -0,0 +1,134 @@
+import { copyFile, mkdir, readdir, readFile, rm } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const BUNDLED_AGENTS_DIR = join(__dirname, '..', 'agents');
+
+const metaCache = new Map();
+
+export async function listInstalled(targetDir) {
+  try {
+    const agentsDir = join(targetDir, 'agents');
+    const entries = await readdir(agentsDir, { withFileTypes: true });
+    return entries
+      .filter((e) => e.isFile() && e.name.endsWith('.agent.md'))
+      .map((e) => e.name.replace(/\.agent\.md$/, ''));
+  } catch (err) {
+    if (err.code === 'ENOENT') return [];
+    throw err;
+  }
+}
+
+export async function listAvailable() {
+  try {
+    const entries = await readdir(BUNDLED_AGENTS_DIR, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+
+export async function getAgentMeta(id) {
+  if (metaCache.has(id)) return metaCache.get(id);
+  try {
+    const raw = await readFile(join(BUNDLED_AGENTS_DIR, id, 'AGENT.md'), 'utf-8');
+    const content = raw.replace(/\r\n/g, '\n');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return { name: id, description: '', descriptions: {}, category: '', icon: '', version: '' };
+
+    const fm = fmMatch[1];
+    const name = fm.match(/^name:\s*(.+)$/m)?.[1]?.trim() || id;
+    const category = fm.match(/^category:\s*(.+)$/m)?.[1]?.trim() || '';
+    const icon = fm.match(/^icon:\s*(.+)$/m)?.[1]?.trim() || '';
+    const version = fm.match(/^version:\s*(.+)$/m)?.[1]?.trim() || '';
+
+    // description may use YAML folded scalar (>)
+    let description = '';
+    const descBlock = fm.match(/^description:\s*>\s*\n((?:\s{2,}.+\n?)+)/m);
+    if (descBlock) {
+      description = descBlock[1].replace(/\n\s*/g, ' ').trim();
+    } else {
+      const descInline = fm.match(/^description:\s*(.+)$/m);
+      if (descInline) description = descInline[1].trim();
+    }
+
+    // localized descriptions: description_pt-BR, description_es, etc.
+    const descriptions = {};
+    for (const code of ['pt-BR', 'es']) {
+      const key = `description_${code}`;
+      // folded scalar
+      const blockMatch = fm.match(new RegExp(`^${key}:\\s*>\\s*\\n((?:\\s{2,}.+\\n?)+)`, 'm'));
+      if (blockMatch) {
+        descriptions[code] = blockMatch[1].replace(/\n\s*/g, ' ').trim();
+      } else {
+        // inline
+        const inlineMatch = fm.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
+        if (inlineMatch) descriptions[code] = inlineMatch[1].trim();
+      }
+    }
+
+    const result = { name, description, descriptions, category, icon, version };
+    metaCache.set(id, result);
+    return result;
+  } catch (err) {
+    if (err.code === 'ENOENT') {
+      metaCache.set(id, null);
+      return null;
+    }
+    throw err;
+  }
+}
+
+function validateAgentId(id) {
+  if (!/^[a-z0-9][a-z0-9-]*$/.test(id)) {
+    throw new Error(`Invalid agent id: '${id}'`);
+  }
+}
+
+export async function installAgent(id, targetDir) {
+  validateAgentId(id);
+  const srcFile = join(BUNDLED_AGENTS_DIR, id, 'AGENT.md');
+  try {
+    await readFile(srcFile);
+  } catch (err) {
+    if (err.code === 'ENOENT') throw new Error(`Agent '${id}' not found in registry`, { cause: err });
+    throw err;
+  }
+  const destDir = join(targetDir, 'agents');
+  await mkdir(destDir, { recursive: true });
+  await copyFile(srcFile, join(destDir, `${id}.agent.md`));
+  metaCache.delete(id);
+}
+
+export async function removeAgent(id, targetDir) {
+  validateAgentId(id);
+  const agentFile = join(targetDir, 'agents', `${id}.agent.md`);
+  await rm(agentFile, { force: true });
+  metaCache.delete(id);
+}
+
+export function clearMetaCache() {
+  metaCache.clear();
+}
+
+export async function getAgentVersion(id, targetDir) {
+  try {
+    const agentPath = join(targetDir, 'agents', `${id}.agent.md`);
+    const content = await readFile(agentPath, 'utf-8');
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) return null;
+    const versionMatch = fmMatch[1].match(/^version:\s*(.+)$/m);
+    return versionMatch ? versionMatch[1].trim() : null;
+  } catch (err) {
+    if (err.code === 'ENOENT') return null;
+    throw err;
+  }
+}
+
+export function getLocalizedDescription(meta, localeCode) {
+  if (localeCode && localeCode !== 'en' && meta.descriptions?.[localeCode]) {
+    return meta.descriptions[localeCode];
+  }
+  return meta.description;
+}

package/src/bundle-detector.js

@@ -0,0 +1,75 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+/**
+ * Detect if current working directory is a bundled department
+ * @param {string} cwd - Current working directory
+ * @returns {boolean} True if bundled, false otherwise
+ */
+export function isBundled(cwd) {
+  return existsSync(join(cwd, '_bundle'));
+}
+
+/**
+ * Get the base path for resolving dependencies
+ * @param {string} cwd - Current working directory
+ * @returns {string} Path to resolve dependencies from
+ */
+export function getBasePath(cwd) {
+  if (isBundled(cwd)) {
+    return join(cwd, '_bundle');
+  }
+  // For project mode, we need to find parent _goiabaseeds
+  // This assumes cwd is a department directory under departments/
+  return join(cwd, '..', '..', '_goiabaseeds');
+}
+
+/**
+ * Resolve a path based on execution mode (bundled or project)
+ * @param {string} relativePath - Path relative to project root (e.g., "_goiabaseeds/core/runner.pipeline.md")
+ * @param {string} cwd - Current working directory (department directory)
+ * @returns {string} Resolved absolute path
+ */
+export function resolvePath(relativePath, cwd) {
+  if (!isBundled(cwd)) {
+    // Project mode: resolve relative to parent project
+    // Assuming cwd is departments/{name}/
+    const projectRoot = join(cwd, '..', '..');
+    return join(projectRoot, relativePath);
+  }
+
+  // Bundle mode: translate paths
+  if (relativePath.startsWith('_goiabaseeds/')) {
+    // _goiabaseeds/ → _bundle/_goiabaseeds/
+    const bundlePath = relativePath.replace('_goiabaseeds/', '_bundle/_goiabaseeds/');
+    return join(cwd, bundlePath);
+  }
+
+  if (relativePath.startsWith('skills/')) {
+    // skills/ → _bundle/skills/
+    const bundlePath = relativePath.replace('skills/', '_bundle/skills/');
+    return join(cwd, bundlePath);
+  }
+
+  if (relativePath.startsWith('_config/')) {
+    // _config/ paths stay the same
+    return join(cwd, relativePath);
+  }
+
+  // Default: treat as relative to bundle root
+  return join(cwd, relativePath);
+}
+
+/**
+ * Get mode information for debugging/logging
+ * @param {string} cwd - Current working directory
+ * @returns {Object} Mode info
+ */
+export function getModeInfo(cwd) {
+  const bundled = isBundled(cwd);
+  return {
+    mode: bundled ? 'bundle' : 'project',
+    isBundled: bundled,
+    basePath: getBasePath(cwd)
+  };
+}

package/src/bundle.js

@@ -0,0 +1,286 @@
+import { copyFile, mkdir, readFile, writeFile, readdir } from 'node:fs/promises';
+import { join, resolve, relative } from 'node:path';
+import { existsSync } from 'node:fs';
+
+/**
+ * Bundle a department into a self-contained package
+ * @param {string} departmentName - Name of department to bundle
+ * @param {string} projectDir - Project root directory
+ * @param {Object} options - Bundle options
+ * @param {string} [options.output] - Custom output path (defaults to departments/{dept}/dist/)
+ * @param {boolean} [options.zip] - Create ZIP file (not implemented yet)
+ * @returns {Object} Result with success status and path
+ */
+export async function bundleDepartment(departmentName, projectDir, options = {}) {
+  try {
+    const departmentPath = join(projectDir, 'departments', departmentName);
+    const outputPath = options.output || join(projectDir, 'departments', departmentName, 'dist');
+    const bundlePath = join(outputPath, departmentName);
+
+    // Verify department exists
+    if (!existsSync(departmentPath)) {
+      return { success: false, error: `Department not found: ${departmentName}` };
+    }
+
+    // Verify department.yaml exists
+    const deptYamlPath = join(departmentPath, 'department.yaml');
+    if (!existsSync(deptYamlPath)) {
+      return { success: false, error: `department.yaml not found in ${departmentName}` };
+    }
+
+    console.log(`\n📦 Bundling department: ${departmentName}`);
+
+    // Create bundle directory structure
+    await mkdir(join(bundlePath, '_bundle', '_goiabaseeds', 'core', 'best-practices'), { recursive: true });
+    await mkdir(join(bundlePath, '_bundle', '_goiabaseeds', 'core', 'agents'), { recursive: true });
+    await mkdir(join(bundlePath, '_bundle', 'skills'), { recursive: true });
+    await mkdir(join(bundlePath, '_config'), { recursive: true });
+
+    console.log(`  ✓ Created bundle directory structure`);
+
+    // Step 1: Copy core runner
+    const runnerSource = join(projectDir, '_goiabaseeds', 'core', 'runner.pipeline.md');
+    const runnerDest = join(bundlePath, '_bundle', '_goiabaseeds', 'core', 'runner.pipeline.md');
+    if (existsSync(runnerSource)) {
+      await copyFile(runnerSource, runnerDest);
+      console.log(`  ✓ Bundled pipeline runner`);
+    }
+
+    // Step 2: Copy best practices
+    const bestPracticesSource = join(projectDir, '_goiabaseeds', 'core', 'best-practices');
+    if (existsSync(bestPracticesSource)) {
+      const files = await readdir(bestPracticesSource);
+      for (const file of files) {
+        const src = join(bestPracticesSource, file);
+        const dst = join(bundlePath, '_bundle', '_goiabaseeds', 'core', 'best-practices', file);
+        await copyFile(src, dst);
+      }
+      console.log(`  ✓ Bundled best practices (${files.length} files)`);
+    }
+
+    // Step 3: Copy base agents
+    const agentsSource = join(projectDir, '_goiabaseeds', 'core', 'agents');
+    if (existsSync(agentsSource)) {
+      const files = await readdir(agentsSource);
+      for (const file of files) {
+        const src = join(agentsSource, file);
+        const dst = join(bundlePath, '_bundle', '_goiabaseeds', 'core', 'agents', file);
+        await copyFile(src, dst);
+      }
+      console.log(`  ✓ Bundled base agents (${files.length} files)`);
+    }
+
+    // Step 4: Copy and analyze department.yaml to find skills
+    const deptYamlContent = await readFile(deptYamlPath, 'utf-8');
+    const skills = extractSkillsFromYaml(deptYamlContent);
+
+    // Step 5: Copy skills
+    const skillsDir = join(projectDir, 'skills');
+    for (const skill of skills) {
+      const skillSource = join(skillsDir, skill);
+      if (existsSync(skillSource)) {
+        await copyDirRecursive(skillSource, join(bundlePath, '_bundle', 'skills', skill));
+      }
+    }
+    console.log(`  ✓ Bundled ${skills.length} skill(s)`);
+
+    // Step 6: Copy company context and preferences
+    const companySource = join(projectDir, '_goiabaseeds', '_memory', 'company.md');
+    const prefsSource = join(projectDir, '_goiabaseeds', '_memory', 'preferences.md');
+
+    if (existsSync(companySource)) {
+      await copyFile(companySource, join(bundlePath, '_config', 'company.md'));
+    }
+    if (existsSync(prefsSource)) {
+      await copyFile(prefsSource, join(bundlePath, '_config', 'preferences.md'));
+    }
+    console.log(`  ✓ Bundled company context and preferences`);
+
+    // Step 7: Copy all department files (agents, pipeline, data, memory, output)
+    const dirsToCopy = ['agents', 'pipeline', '_memory', 'output'];
+    const filesToCopy = ['department-party.csv'];
+
+    for (const dir of dirsToCopy) {
+      const src = join(departmentPath, dir);
+      if (existsSync(src)) {
+        const dst = join(bundlePath, dir);
+        await copyDirRecursive(src, dst);
+      }
+    }
+
+    // Copy individual files
+    for (const file of filesToCopy) {
+      const src = join(departmentPath, file);
+      if (existsSync(src)) {
+        const dst = join(bundlePath, file);
+        await copyFile(src, dst);
+      }
+    }
+    console.log(`  ✓ Copied department files and structure`);
+
+    // Step 8: Rewrite department.yaml with bundle paths
+    const updatedYaml = rewriteYamlPaths(deptYamlContent);
+    await writeFile(join(bundlePath, 'department.yaml'), updatedYaml);
+
+    // Step 9: Create bundle metadata
+    const versionFile = join(projectDir, '_goiabaseeds', '.goiabaseeds-version');
+    let version = 'unknown';
+    if (existsSync(versionFile)) {
+      version = (await readFile(versionFile, 'utf-8')).trim();
+    }
+
+    const metadata = {
+      bundleVersion: 1,
+      departmentName,
+      createdAt: new Date().toISOString(),
+      goiabaseeds_version: version,
+      skills: skills.sort(),
+      author: 'GoiabaSeeds Bundle Generator'
+    };
+
+    await writeFile(
+      join(bundlePath, '_bundle', '.meta.json'),
+      JSON.stringify(metadata, null, 2)
+    );
+    console.log(`  ✓ Created bundle metadata`);
+
+    // Step 10: Create a README for the bundle
+    const readmeContent = `# ${departmentName} — GoiabaSeeds Bundle
+
+This is a self-contained GoiabaSeeds department bundle created on ${new Date().toLocaleDateString()}.
+
+## Quick Start
+
+1. **Unzip this folder** (if it came as a ZIP)
+2. **Navigate to the department directory:**
+   \`\`\`bash
+   cd ${departmentName}
+   \`\`\`
+3. **Run the department:**
+   \`\`\`bash
+   npx goiabaseeds run
+   \`\`\`
+
+## About This Bundle
+
+- **Created**: ${new Date().toLocaleString()}
+- **GoiabaSeeds Version**: ${version}
+- **Included Skills**: ${skills.join(', ') || 'None (uses native skills only)'}
+- **Department**: ${departmentName}
+
+## What's Inside
+
+\`\`\`
+${departmentName}/
+├── _bundle/              # Bundled GoiabaSeeds runtime and dependencies
+│   ├── _goiabaseeds/     # Core execution engine
+│   └── skills/          # Bundled custom skills
+├── _config/             # Department-specific configuration
+│   ├── company.md       # Company context
+│   └── preferences.md   # User preferences
+├── agents/              # Custom agent definitions
+├── pipeline/            # Department pipeline and data
+├── _memory/             # Execution memory and learnings
+├── department.yaml      # Department configuration
+├── department-party.csv # Agent roster
+└── output/              # Execution artifacts
+\`\`\`
+
+## Using This Bundle
+
+Once you extract and run this department, it will:
+1. Load all agents from the orchestration
+2. Execute the complete pipeline with all agents working together
+3. Store outputs and memory locally
+4. Can be shared again or customized by your team
+
+## Support
+
+For questions about GoiabaSeeds, visit: https://github.com/netoribeiro/goiabaseeds
+
+---
+
+*This bundle is self-contained and can be moved, shared, and run on any machine with Node.js >= 20.0.0*
+`;
+
+    await writeFile(join(bundlePath, 'README.md'), readmeContent);
+    console.log(`  ✓ Created README`);
+
+    console.log(`\n✅ Bundle created successfully!\n  Location: ${bundlePath}\n`);
+
+    return {
+      success: true,
+      path: bundlePath,
+      bundleSize: skills.length,
+      department: departmentName
+    };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Extract skill names from department.yaml content
+ */
+function extractSkillsFromYaml(yamlContent) {
+  const skills = new Set();
+  const skillsMatch = yamlContent.match(/skills:\s*\n([\s\S]*?)(?:\n\w+:|$)/);
+
+  if (skillsMatch) {
+    const skillsBlock = skillsMatch[1];
+    const skillLines = skillsBlock.split('\n').filter(line => line.trim().startsWith('-'));
+    skillLines.forEach(line => {
+      const match = line.match(/- (.+?)(?:\s*#|$)/);
+      if (match) {
+        const skill = match[1].trim();
+        // Don't include native skills
+        if (!['web_search', 'web_fetch'].includes(skill)) {
+          skills.add(skill);
+        }
+      }
+    });
+  }
+
+  return Array.from(skills);
+}
+
+/**
+ * Rewrite YAML paths for bundled mode
+ */
+function rewriteYamlPaths(yamlContent) {
+  let updated = yamlContent;
+
+  // Replace company path
+  updated = updated.replace(
+    /company:\s*['"]?_goiabaseeds\/_memory\/company\.md['"]?/,
+    'company: "_config/company.md"'
+  );
+
+  // Replace preferences path
+  updated = updated.replace(
+    /preferences:\s*['"]?_goiabaseeds\/_memory\/preferences\.md['"]?/,
+    'preferences: "_config/preferences.md"'
+  );
+
+  return updated;
+}
+
+/**
+ * Recursively copy directory
+ */
+async function copyDirRecursive(src, dst) {
+  const entries = await readdir(src, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const srcPath = join(src, entry.name);
+    const dstPath = join(dst, entry.name);
+
+    if (entry.isDirectory()) {
+      await mkdir(dstPath, { recursive: true });
+      await copyDirRecursive(srcPath, dstPath);
+    } else {
+      await mkdir(dst, { recursive: true });
+      await copyFile(srcPath, dstPath);
+    }
+  }
+}