@fitlab-ai/agent-infra 0.5.9 → 0.6.0

package/dist/bin/cli.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { VERSION } from "../lib/version.js";
+// Node.js version check
+const [major = 0] = process.versions.node.split('.').map((part) => parseInt(part, 10));
+if (major < 22) {
+    process.stderr.write(`agent-infra requires Node.js >= 22 (current: ${process.version})\n`);
+    process.exit(1);
+}
+const USAGE = `agent-infra - bootstrap AI collaboration infrastructure
+
+Usage:
+  agent-infra init        Initialize a new project with update-agent-infra seed command
+  agent-infra merge       Merge tasks from another workspace directory (active/blocked/completed/archive)
+  agent-infra update      Update seed files and sync file registry for an existing project
+  agent-infra sandbox     Manage Docker-based AI sandboxes
+  agent-infra version     Show version
+  agent-infra help        Show this help message
+
+Shorthand: ai (e.g. ai init)
+
+Install methods:
+  npm:   npm install -g @fitlab-ai/agent-infra
+  npx:   npx @fitlab-ai/agent-infra init
+  brew:  brew install fitlab-ai/tap/agent-infra  (macOS)
+  curl:  curl -fsSL https://raw.githubusercontent.com/fitlab-ai/agent-infra/main/install.sh | sh  (runs npm install -g internally)
+
+Examples:
+  cd my-project && agent-infra init
+  npx @fitlab-ai/agent-infra init
+`;
+const command = process.argv[2] || '';
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+async function importCommand(importPath) {
+    try {
+        return await import(__rewriteRelativeImportExtension(importPath));
+    }
+    catch (error) {
+        if (error && typeof error === 'object' && 'code' in error && error.code === 'ERR_MODULE_NOT_FOUND') {
+            process.stderr.write('Error: Missing npm dependency. Run npm install before using agent-infra from a development checkout.\n');
+            process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+            process.exitCode = 1;
+            return null;
+        }
+        throw error;
+    }
+}
+switch (command) {
+    case 'init': {
+        const imported = await importCommand('../lib/init.ts');
+        if (!imported)
+            break;
+        const { cmdInit } = imported;
+        await cmdInit().catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            process.exitCode = 1;
+        });
+        break;
+    }
+    case 'update': {
+        const imported = await importCommand('../lib/update.ts');
+        if (!imported)
+            break;
+        const { cmdUpdate } = imported;
+        await cmdUpdate().catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            process.exitCode = 1;
+        });
+        break;
+    }
+    case 'merge': {
+        const imported = await importCommand('../lib/merge.ts');
+        if (!imported)
+            break;
+        const { cmdMerge } = imported;
+        await cmdMerge(process.argv.slice(3)).catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            process.exitCode = 1;
+        });
+        break;
+    }
+    case 'sandbox': {
+        const imported = await importCommand('../lib/sandbox/index.ts');
+        if (!imported)
+            break;
+        const { runSandbox } = imported;
+        await runSandbox(process.argv.slice(3)).catch((e) => {
+            process.stderr.write(`Error: ${errorMessage(e)}\n`);
+            process.exitCode = 1;
+        });
+        break;
+    }
+    case 'version': {
+        console.log(`agent-infra ${VERSION}`);
+        break;
+    }
+    case 'help':
+    case '':
+        process.stdout.write(USAGE);
+        break;
+    default:
+        process.stderr.write(`Unknown command: ${command}\n\n`);
+        process.stdout.write(USAGE);
+        process.exitCode = 1;
+        break;
+}
+//# sourceMappingURL=cli.js.map

package/dist/lib/defaults.json

@@ -0,0 +1,61 @@
+{
+  "platform": {
+    "type": "github"
+  },
+  "sandbox": {
+    "engine": null,
+    "runtimes": [
+      "node20"
+    ],
+    "tools": [
+      "claude-code",
+      "codex",
+      "opencode",
+      "gemini-cli"
+    ],
+    "dockerfile": null,
+    "vm": {
+      "cpu": null,
+      "memory": null,
+      "disk": null
+    }
+  },
+  "labels": {
+    "in": {}
+  },
+  "files": {
+    "managed": [
+      ".agents/QUICKSTART.md",
+      ".agents/README.md",
+      ".agents/rules/",
+      ".agents/scripts/",
+      ".agents/skills/",
+      ".agents/templates/",
+      ".agents/workflows/",
+      ".agents/workspace/README.md",
+      ".claude/commands/",
+      ".claude/hooks/",
+      ".gemini/commands/",
+      ".git-hooks/check-version-format.sh",
+      ".github/scripts/",
+      ".opencode/commands/"
+    ],
+    "merged": [
+      "**/post-release.*",
+      "**/release.*",
+      "**/test-integration.*",
+      "**/test.*",
+      "**/upgrade-dependency.*",
+      ".agents/skills/post-release/SKILL.*",
+      ".agents/skills/release/SKILL.*",
+      ".agents/skills/test-integration/SKILL.*",
+      ".agents/skills/test/SKILL.*",
+      ".agents/skills/upgrade-dependency/SKILL.*",
+      ".claude/settings.json",
+      ".gemini/settings.json",
+      ".git-hooks/pre-commit",
+      ".gitignore"
+    ],
+    "ejected": []
+  }
+}

package/dist/lib/init.js

@@ -0,0 +1,238 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { platform } from 'node:os';
+import { info, ok, err } from "./log.js";
+import { prompt, select, closePrompt } from "./prompt.js";
+import { resolveTemplateDir } from "./paths.js";
+import { renderFile, copySkillDir, KNOWN_PLATFORMS } from "./render.js";
+import { enginesForPlatform } from "./sandbox/engines/index.js";
+import { VERSION } from "./version.js";
+const defaults = JSON.parse(fs.readFileSync(new URL('./defaults.json', import.meta.url), 'utf8'));
+const PLATFORM_DEFAULT_ENGINES = Object.freeze({
+    linux: 'native',
+    darwin: 'colima',
+    win32: 'wsl2'
+});
+function isPathOwnedByOtherPlatform(relativePath, platformType) {
+    const top = String(relativePath || '').replace(/\\/g, '/').replace(/^\.\//, '').split('/')[0] ?? '';
+    if (!top.startsWith('.'))
+        return false;
+    const candidate = top.slice(1);
+    if (!KNOWN_PLATFORMS.has(candidate))
+        return false;
+    return candidate !== platformType;
+}
+function buildDefaultFiles(platformType) {
+    return {
+        managed: (defaults.files.managed || []).filter((entry) => !isPathOwnedByOtherPlatform(entry, platformType)),
+        merged: (defaults.files.merged || []).filter((entry) => !isPathOwnedByOtherPlatform(entry, platformType)),
+        ejected: structuredClone(defaults.files.ejected || [])
+    };
+}
+function detectProjectName() {
+    try {
+        const url = execSync('git remote get-url origin', { stdio: ['pipe', 'pipe', 'pipe'] })
+            .toString().trim().replace(/\.git$/, '');
+        return path.basename(url);
+    }
+    catch {
+        return path.basename(process.cwd());
+    }
+}
+function detectOrgName() {
+    try {
+        const url = execSync('git remote get-url origin', { stdio: ['pipe', 'pipe', 'pipe'] })
+            .toString().trim().replace(/\.git$/, '');
+        // SSH: git@github.com:org/repo  →  org
+        // HTTPS: https://github.com/org/repo  →  org
+        const sshMatch = url.match(/:([^/]+)\//);
+        if (sshMatch?.[1])
+            return sshMatch[1];
+        const httpsMatch = url.match(/\/\/[^/]+\/([^/]+)\//);
+        if (httpsMatch?.[1])
+            return httpsMatch[1];
+    }
+    catch {
+        // no remote
+    }
+    return '';
+}
+const VALID_NAME_RE = /^[a-zA-Z0-9_.@-]+$/;
+function parseLocalSources(input) {
+    return input
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter(Boolean)
+        .map((entry) => ({ type: 'local', path: entry }));
+}
+async function cmdInit() {
+    console.log('');
+    console.log('  agent-infra init');
+    console.log('  ================================');
+    console.log('  Optional template and skill sources can be added now or later in .agents/.airc.json.');
+    console.log('');
+    // resolve templates
+    const templateDir = resolveTemplateDir();
+    if (!templateDir) {
+        err('Template directory not found.');
+        err('Install via npm: npm install -g @fitlab-ai/agent-infra');
+        process.exitCode = 1;
+        return;
+    }
+    const configPath = path.join('.agents', '.airc.json');
+    // check existing config
+    if (fs.existsSync(configPath)) {
+        err('This project already has agent-infra configuration.');
+        err('Use /update-agent-infra in your AI TUI to update.');
+        process.exitCode = 1;
+        return;
+    }
+    // collect project info
+    const defaultProject = detectProjectName();
+    const projectName = await prompt('Project name', defaultProject);
+    if (!projectName) {
+        err('Project name is required.');
+        closePrompt();
+        process.exitCode = 1;
+        return;
+    }
+    if (!VALID_NAME_RE.test(projectName)) {
+        err('Project name may only contain letters, digits, hyphens, underscores, dots, and @.');
+        err(`Got: ${projectName}`);
+        closePrompt();
+        process.exitCode = 1;
+        return;
+    }
+    const defaultOrg = detectOrgName();
+    const orgName = await prompt('Organization / owner (optional)', defaultOrg);
+    if (orgName && !VALID_NAME_RE.test(orgName)) {
+        err('Organization name may only contain letters, digits, hyphens, underscores, dots, and @.');
+        err(`Got: ${orgName}`);
+        closePrompt();
+        process.exitCode = 1;
+        return;
+    }
+    let language = await prompt('Language (en / zh)', 'zh');
+    if (language === 'zh')
+        language = 'zh-CN';
+    if (language !== 'en' && language !== 'zh-CN') {
+        closePrompt();
+        err(`Language must be 'en' or 'zh'. Got: ${language}`);
+        process.exitCode = 1;
+        return;
+    }
+    const currentPlatform = platform();
+    const defaultEngine = PLATFORM_DEFAULT_ENGINES[currentPlatform];
+    const engineChoices = enginesForPlatform(currentPlatform).sort((left, right) => {
+        if (left === defaultEngine)
+            return -1;
+        if (right === defaultEngine)
+            return 1;
+        return 0;
+    });
+    let sandboxEngine = null;
+    if (engineChoices.length > 0) {
+        sandboxEngine = await select(`Sandbox engine (${currentPlatform})`, engineChoices, defaultEngine);
+    }
+    const platformChoices = [...KNOWN_PLATFORMS, 'other'];
+    let platformType = await select('Platform', platformChoices, 'github');
+    if (platformType === 'other') {
+        platformType = (await prompt('Custom platform type', '')).trim();
+        if (!platformType) {
+            closePrompt();
+            err('Custom platform type is required.');
+            process.exitCode = 1;
+            return;
+        }
+    }
+    if (!/^[a-z0-9][a-z0-9-]*$/.test(platformType)) {
+        closePrompt();
+        err(`Platform type must match /^[a-z0-9][a-z0-9-]*$/. Got: ${platformType}`);
+        process.exitCode = 1;
+        return;
+    }
+    if (!KNOWN_PLATFORMS.has(platformType)) {
+        info(`Custom platform '${platformType}' selected. Built-in templates are only complete for github;`
+            + ` provide matching '.${platformType}.' or generic templates before running update-agent-infra.`);
+    }
+    const templateSources = parseLocalSources(await prompt('Template sources (optional, comma-separated local paths, e.g. ~/my-templates; Enter to skip)', ''));
+    const skillSources = parseLocalSources(await prompt('Skill sources (optional, comma-separated local paths, e.g. ~/my-skills; Enter to skip)', ''));
+    closePrompt();
+    const project = projectName;
+    const replacements = { project, org: orgName };
+    console.log('');
+    if (orgName) {
+        info(`Installing update-agent-infra seed command for: ${projectName} (${orgName})`);
+    }
+    else {
+        info(`Installing update-agent-infra seed command for: ${projectName}`);
+    }
+    console.log('');
+    // select language-specific template filenames
+    let claudeSrc, geminiSrc, opencodeSrc;
+    if (language === 'zh-CN') {
+        claudeSrc = 'update-agent-infra.zh-CN.md';
+        geminiSrc = 'update-agent-infra.zh-CN.toml';
+        opencodeSrc = 'update-agent-infra.zh-CN.md';
+    }
+    else {
+        claudeSrc = 'update-agent-infra.en.md';
+        geminiSrc = 'update-agent-infra.en.toml';
+        opencodeSrc = 'update-agent-infra.en.md';
+    }
+    // install skill
+    copySkillDir(path.join(templateDir, '.agents', 'skills', 'update-agent-infra'), path.join('.agents', 'skills', 'update-agent-infra'), replacements, language, platformType);
+    ok('Installed .agents/skills/update-agent-infra/');
+    // install Claude command
+    renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
+    ok('Installed .claude/commands/update-agent-infra.md');
+    // install Gemini command
+    renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
+    ok(`Installed .gemini/commands/${project}/update-agent-infra.toml`);
+    // install OpenCode command
+    renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
+    ok('Installed .opencode/commands/update-agent-infra.md');
+    // generate .agents/.airc.json
+    const config = {
+        project: projectName,
+        org: orgName,
+        language,
+        platform: { type: platformType },
+        templateVersion: VERSION,
+        sandbox: structuredClone(defaults.sandbox),
+        labels: structuredClone(defaults.labels),
+        files: buildDefaultFiles(platformType)
+    };
+    if (sandboxEngine) {
+        config.sandbox.engine = sandboxEngine;
+    }
+    if (templateSources.length > 0) {
+        config.templates = {
+            sources: templateSources
+        };
+    }
+    if (skillSources.length > 0) {
+        config.skills = {
+            sources: skillSources
+        };
+    }
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf8');
+    ok(`Generated ${configPath}`);
+    // done
+    console.log('');
+    ok('Project initialized successfully!');
+    console.log('');
+    console.log('  Next step: open this project in any AI TUI and run:');
+    console.log('');
+    console.log('    Claude Code / OpenCode:  /update-agent-infra');
+    console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
+    console.log('    Codex CLI:               $update-agent-infra');
+    console.log('');
+    console.log('  This will render all templates and set up the full');
+    console.log('  AI collaboration infrastructure.');
+    console.log('');
+}
+export { cmdInit };
+//# sourceMappingURL=init.js.map

package/dist/lib/log.js

@@ -0,0 +1,18 @@
+import pc from 'picocolors';
+function info(...args) {
+    const msg = args.join(' ');
+    process.stdout.write(`  ${pc.bold(pc.blue('>'))} ${msg}\n`);
+}
+function ok(...args) {
+    const msg = args.join(' ');
+    process.stdout.write(`  ${pc.bold(pc.green('\u2713'))} ${msg}\n`);
+}
+function err(...args) {
+    const msg = args.join(' ');
+    process.stderr.write(`  ${pc.bold(pc.red('\u2717'))} ${msg}\n`);
+}
+function ask(text) {
+    process.stdout.write(`  ${pc.bold(pc.yellow('?'))} ${text}`);
+}
+export { info, ok, err, ask };
+//# sourceMappingURL=log.js.map