@fitlab-ai/agent-infra 0.9.0 → 0.9.2

package/dist/lib/update.js

@@ -1,15 +1,13 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { normalizeAgentClients } from './agent-clients/config.js';
+import { applyAgentClientReconciliation, planAgentClientReconciliation } from './agent-clients/reconcile.js';
 import { info, ok, err } from './log.js';
 import { resolveTemplateDir } from './paths.js';
-import { renderFile, copySkillDir, KNOWN_PLATFORMS } from './render.js';
-import { isPathOwnedByDisabledTUI, resolveEnabledTUIs } from './builtin-tuis.js';
+import { renderFile, copySkillDir } from './render.js';
 const defaults = JSON.parse(fs.readFileSync(new URL('./defaults.json', import.meta.url), 'utf8'));
 const CONFIG_DIR = '.agents';
 const CONFIG_PATH = path.join(CONFIG_DIR, '.airc.json');
-const AGENT_INFRA_SANDBOX_TOOL = 'agent-infra';
-const LEGACY_DEFAULT_SANDBOX_TOOLS = ['claude-code', 'codex', 'gemini-cli', 'opencode'];
-const DEFAULT_SANDBOX_TOOLS = [AGENT_INFRA_SANDBOX_TOOL, ...LEGACY_DEFAULT_SANDBOX_TOOLS];
 // One-time migration of the legacy project-level PR switch to the three-state
 // `prFlow` preference. `true` (the old default / "PR flow on") maps to the
 // strong constraint `required`; `false` maps to `disabled`. A missing or
@@ -28,80 +26,6 @@ function migratePrFlow(config) {
     }
     return null;
 }
-function isLegacyDefaultSandboxTools(value) {
-    if (!Array.isArray(value) || value.length !== LEGACY_DEFAULT_SANDBOX_TOOLS.length) {
-        return false;
-    }
-    const tools = new Set(value);
-    return LEGACY_DEFAULT_SANDBOX_TOOLS.every((tool) => tools.has(tool));
-}
-function migrateSandboxTools(config) {
-    const tools = config.sandbox?.tools;
-    if (!isLegacyDefaultSandboxTools(tools)) {
-        return false;
-    }
-    config.sandbox = {
-        ...config.sandbox,
-        tools: [...DEFAULT_SANDBOX_TOOLS]
-    };
-    return true;
-}
-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 syncFileRegistry(config, platformType, enabledTUIs) {
-    config.files ||= {};
-    const before = JSON.stringify({
-        files: {
-            managed: config.files.managed || [],
-            merged: config.files.merged || [],
-            ejected: config.files.ejected || []
-        }
-    });
-    config.files.managed = config.files.managed || [];
-    config.files.merged = config.files.merged || [];
-    config.files.ejected = config.files.ejected || [];
-    const allExisting = [
-        ...config.files.managed,
-        ...config.files.merged,
-        ...config.files.ejected
-    ];
-    const added = { managed: [], merged: [] };
-    for (const entry of defaults.files.managed) {
-        if (isPathOwnedByOtherPlatform(entry, platformType))
-            continue;
-        if (isPathOwnedByDisabledTUI(entry, enabledTUIs))
-            continue;
-        if (!allExisting.includes(entry)) {
-            config.files.managed.push(entry);
-            added.managed.push(entry);
-        }
-    }
-    for (const entry of defaults.files.merged) {
-        if (isPathOwnedByOtherPlatform(entry, platformType))
-            continue;
-        if (isPathOwnedByDisabledTUI(entry, enabledTUIs))
-            continue;
-        if (!allExisting.includes(entry)) {
-            config.files.merged.push(entry);
-            added.merged.push(entry);
-        }
-    }
-    const after = JSON.stringify({
-        files: {
-            managed: config.files.managed,
-            merged: config.files.merged,
-            ejected: config.files.ejected
-        }
-    });
-    return { added, changed: before !== after };
-}
 async function cmdUpdate() {
     console.log('');
     console.log('  ai update');
@@ -126,22 +50,36 @@ async function cmdUpdate() {
     const config = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
     const { project, org, language } = config;
     const platformType = config.platform?.type || defaults.platform.type;
-    const enabledTUIs = resolveEnabledTUIs(config.tuis);
     const replacements = { project, org };
+    const normalizedOriginal = normalizeAgentClients(config);
+    const currentRegistry = {
+        managed: config.files?.managed || [],
+        merged: config.files?.merged || [],
+        ejected: config.files?.ejected || []
+    };
+    const platformAdded = !config.platform;
+    const sandboxAdded = !config.sandbox;
+    const taskAdded = !config.task;
+    const labelsAdded = !config.labels;
+    const prFlowMigrated = migratePrFlow(config);
+    if (platformAdded)
+        config.platform = structuredClone(defaults.platform);
+    if (sandboxAdded)
+        config.sandbox = structuredClone(defaults.sandbox);
+    if (taskAdded)
+        config.task = structuredClone(defaults.task);
+    if (labelsAdded)
+        config.labels = structuredClone(defaults.labels);
+    const workflowPlan = planAgentClientReconciliation({
+        config: config,
+        mutation: { type: 'replace-state', state: normalizedOriginal.state },
+        projectRoot: process.cwd(),
+        templateRoot: templateDir,
+        platformType,
+        language
+    });
     info(`Updating seed files for: ${project}`);
     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';
-    }
     // update skill
     copySkillDir(path.join(templateDir, '.agents', 'skills', 'update-agent-infra'), path.join('.agents', 'skills', 'update-agent-infra'), replacements, language, platformType);
     ok('Updated .agents/skills/update-agent-infra/');
@@ -153,54 +91,15 @@ async function cmdUpdate() {
     catch {
         // Ignore missing legacy script from pre-ESM installs.
     }
-    // update Claude command (only if enabled)
-    if (enabledTUIs.has('claude-code')) {
-        renderFile(path.join(templateDir, '.claude', 'commands', claudeSrc), path.join('.claude', 'commands', 'update-agent-infra.md'), replacements);
-        ok('Updated .claude/commands/update-agent-infra.md');
-    }
-    // update Gemini command (only if enabled)
-    if (enabledTUIs.has('gemini-cli')) {
-        renderFile(path.join(templateDir, '.gemini', 'commands', '_project_', geminiSrc), path.join('.gemini', 'commands', project, 'update-agent-infra.toml'), replacements);
-        ok(`Updated .gemini/commands/${project}/update-agent-infra.toml`);
-    }
-    // update OpenCode command (only if enabled)
-    if (enabledTUIs.has('opencode')) {
-        renderFile(path.join(templateDir, '.opencode', 'commands', opencodeSrc), path.join('.opencode', 'commands', 'update-agent-infra.md'), replacements);
-        ok('Updated .opencode/commands/update-agent-infra.md');
-    }
-    // sync file registry
-    const { added, changed } = syncFileRegistry(config, platformType, enabledTUIs);
+    const added = {
+        managed: workflowPlan.projectAssets.registry.managed.filter((entry) => !currentRegistry.managed.includes(entry)),
+        merged: workflowPlan.projectAssets.registry.merged.filter((entry) => !currentRegistry.merged.includes(entry))
+    };
     const hasNewEntries = added.managed.length > 0 || added.merged.length > 0;
-    const platformAdded = !config.platform;
-    const sandboxAdded = !config.sandbox;
-    const taskAdded = !config.task;
-    const labelsAdded = !config.labels;
-    const prFlowMigrated = migratePrFlow(config);
-    const sandboxToolsMigrated = !sandboxAdded && migrateSandboxTools(config);
-    let configChanged = changed;
-    if (platformAdded) {
-        config.platform = structuredClone(defaults.platform);
-        configChanged = true;
-    }
-    if (sandboxAdded) {
-        config.sandbox = structuredClone(defaults.sandbox);
-        configChanged = true;
-    }
-    if (taskAdded) {
-        config.task = structuredClone(defaults.task);
-        configChanged = true;
-    }
-    if (labelsAdded) {
-        config.labels = structuredClone(defaults.labels);
-        configChanged = true;
-    }
-    if (prFlowMigrated) {
-        configChanged = true;
-    }
-    if (sandboxToolsMigrated) {
-        configChanged = true;
-    }
-    if (configChanged) {
+    const reconcileResult = applyAgentClientReconciliation(workflowPlan);
+    for (const target of reconcileResult.applied)
+        ok(`Updated ${target}`);
+    if (reconcileResult.configUpdated) {
         console.log('');
         if (hasNewEntries) {
             info(`New file entries synced to ${CONFIG_PATH}:`);
@@ -227,9 +126,6 @@ async function cmdUpdate() {
             if (prFlowMigrated) {
                 info(`Migrated legacy requiresPullRequest to prFlow="${prFlowMigrated}" in ${CONFIG_PATH}.`);
             }
-            if (sandboxToolsMigrated) {
-                info(`Migrated default sandbox.tools to include ${AGENT_INFRA_SANDBOX_TOOL} in ${CONFIG_PATH}.`);
-            }
         }
         else {
             info(`File registry changed in ${CONFIG_PATH}.`);
@@ -249,37 +145,22 @@ async function cmdUpdate() {
         if (hasNewEntries && prFlowMigrated) {
             info(`Migrated legacy requiresPullRequest to prFlow="${prFlowMigrated}" in ${CONFIG_PATH}.`);
         }
-        if (hasNewEntries && sandboxToolsMigrated) {
-            info(`Migrated default sandbox.tools to include ${AGENT_INFRA_SANDBOX_TOOL} in ${CONFIG_PATH}.`);
-        }
-        fs.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf8');
         ok(`Updated ${CONFIG_PATH}`);
     }
     // done
     console.log('');
     ok('Seed files updated successfully!');
     console.log('');
-    if (enabledTUIs.size === 0) {
-        console.log('  No built-in TUI enabled (tuis: []).');
+    if (workflowPlan.nextSteps.length === 0) {
+        console.log('  No Agent Client project integration enabled.');
         console.log(`  Configure "customTUIs" in ${CONFIG_PATH} if needed.`);
         console.log('');
     }
     else {
         console.log('  Next step: run the full update in your AI TUI:');
         console.log('');
-        const claudeOrOpencode = [];
-        if (enabledTUIs.has('claude-code'))
-            claudeOrOpencode.push('Claude Code');
-        if (enabledTUIs.has('opencode'))
-            claudeOrOpencode.push('OpenCode');
-        if (claudeOrOpencode.length > 0) {
-            console.log(`    ${claudeOrOpencode.join(' / ')}:  /update-agent-infra`);
-        }
-        if (enabledTUIs.has('gemini-cli')) {
-            console.log(`    Gemini CLI:              /${project}:update-agent-infra`);
-        }
-        if (enabledTUIs.has('codex')) {
-            console.log('    Codex CLI:               $update-agent-infra');
+        for (const nextStep of workflowPlan.nextSteps) {
+            console.log(`    ${nextStep.displayName}: ${nextStep.command}`);
         }
         console.log('');
     }

package/lib/agent-client.ts

@@ -0,0 +1,214 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+import { AgentClientConfigError, normalizeAgentClients } from './agent-clients/config.ts';
+import {
+  applyAgentClientReconciliation,
+  planAgentClientReconciliation
+} from './agent-clients/reconcile.ts';
+import { listAgentClientAdapters } from './agent-clients/registry.ts';
+import { AGENT_CLIENT_IDS, isAgentClientId } from './agent-clients/types.ts';
+import type { AgentClientState } from './agent-clients/types.ts';
+import { closePrompt, multiSelect } from './prompt.ts';
+import { resolveTemplateDir } from './paths.ts';
+
+const USAGE = `Usage: ai agent-client <operation>
+
+Operations:
+  list                 List built-in Agent Clients
+  status               Show project integration and sandbox state
+  enable <client-id>   Enable project integration only
+  disable <client-id>  Disable project integration only
+  configure            Configure integration and sandbox state interactively
+`;
+
+class AgentClientCommandError extends Error {
+  readonly code: string;
+
+  constructor(code: string, message: string) {
+    super(`${code}: ${message}`);
+    this.name = 'AgentClientCommandError';
+    this.code = code;
+  }
+}
+
+function readConfig(projectRoot: string): Record<string, unknown> {
+  const configPath = path.join(projectRoot, '.agents', '.airc.json');
+  if (!fs.existsSync(configPath)) {
+    throw new AgentClientCommandError(
+      'AGENT_CLIENT_CONFIG_NOT_FOUND',
+      'No .agents/.airc.json found. Run "ai init" first.'
+    );
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+  } catch (error) {
+    throw new AgentClientCommandError(
+      'AGENT_CLIENT_CONFIG_INVALID',
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+    throw new AgentClientCommandError(
+      'AGENT_CLIENT_CONFIG_INVALID',
+      'configuration root must be an object'
+    );
+  }
+  return parsed as Record<string, unknown>;
+}
+
+function choices() {
+  return listAgentClientAdapters().map((adapter) => ({
+    id: adapter.id,
+    label: adapter.displayName
+  }));
+}
+
+function selected(state: AgentClientState, field: 'enabled' | 'installInSandbox'): string[] {
+  return AGENT_CLIENT_IDS.filter((id) => state[id][field]);
+}
+
+function workflowPlan(
+  projectRoot: string,
+  config: Record<string, unknown>,
+  mutation: Parameters<typeof planAgentClientReconciliation>[0]['mutation']
+) {
+  const templateRoot = resolveTemplateDir();
+  if (!templateRoot) {
+    throw new AgentClientCommandError('AGENT_CLIENT_TEMPLATE_NOT_FOUND', 'Template directory not found');
+  }
+  const platform = config.platform;
+  const platformType = typeof platform === 'object' && platform !== null && 'type' in platform
+    ? String(platform.type ?? 'github')
+    : 'github';
+  return planAgentClientReconciliation({
+    config,
+    mutation,
+    projectRoot,
+    templateRoot,
+    platformType,
+    language: String(config.language ?? 'en')
+  });
+}
+
+function printState(state: AgentClientState): void {
+  for (const adapter of listAgentClientAdapters()) {
+    const value = state[adapter.id];
+    process.stdout.write(
+      `  ${adapter.id}: enabled=${String(value.enabled)} installInSandbox=${String(value.installInSandbox)}\n`
+    );
+  }
+}
+
+async function cmdAgentClient(args: string[]): Promise<number> {
+  const operation = args[0];
+  if (!operation || operation === '--help' || operation === '-h' || operation === 'help') {
+    process.stdout.write(USAGE);
+    return 0;
+  }
+
+  if (operation === 'list') {
+    if (args.length !== 1) {
+      throw new AgentClientCommandError('AGENT_CLIENT_ARGUMENT_INVALID', 'list accepts no arguments');
+    }
+    for (const adapter of listAgentClientAdapters()) {
+      process.stdout.write(
+        `${adapter.id}\t${adapter.displayName}\t${adapter.invocation}\tcommands=${adapter.capabilities.commands.level}\tsandbox=${adapter.capabilities.sandbox.level}\n`
+      );
+    }
+    return 0;
+  }
+
+  const projectRoot = process.cwd();
+  const config = readConfig(projectRoot);
+  try {
+    if (operation === 'status') {
+      if (args.length !== 1) {
+        throw new AgentClientCommandError('AGENT_CLIENT_ARGUMENT_INVALID', 'status accepts no arguments');
+      }
+      const plan = workflowPlan(projectRoot, config, { type: 'none' });
+      process.stdout.write(`source: ${plan.source}\n`);
+      printState(plan.desired);
+      for (const seed of plan.seedOperations) {
+        process.stdout.write(`  seed ${seed.target}: ${seed.kind}\n`);
+      }
+      for (const diagnostic of plan.diagnostics) {
+        process.stdout.write(`  diagnostic ${diagnostic.code} at ${diagnostic.path}\n`);
+      }
+      return 0;
+    }
+
+    if (operation === 'enable' || operation === 'disable') {
+      if (args.length !== 2) {
+        throw new AgentClientCommandError(
+          'AGENT_CLIENT_ARGUMENT_INVALID',
+          `${operation} requires exactly one client id`
+        );
+      }
+      const id = args[1];
+      if (!isAgentClientId(id)) {
+        throw new AgentClientCommandError('UNKNOWN_AGENT_CLIENT', `Unknown Agent Client '${String(id)}'`);
+      }
+      const plan = workflowPlan(projectRoot, config, {
+        type: 'set-enabled',
+        id,
+        value: operation === 'enable'
+      });
+      process.stdout.write('Before:\n');
+      printState(plan.before);
+      const result = applyAgentClientReconciliation(plan);
+      process.stdout.write('After:\n');
+      printState(plan.desired);
+      process.stdout.write(
+        `Result: ${result.status}; applied=${result.applied.length}; protected=${result.protected.length}\n`
+      );
+      return 0;
+    }
+
+    if (operation === 'configure') {
+      if (args.length !== 1) {
+        throw new AgentClientCommandError('AGENT_CLIENT_ARGUMENT_INVALID', 'configure accepts no arguments');
+      }
+      const normalized = normalizeAgentClients(config);
+      let enabled: string[];
+      let installed: string[];
+      try {
+        enabled = await multiSelect(
+          'Agent Client project integrations',
+          choices(),
+          selected(normalized.state, 'enabled')
+        );
+        installed = await multiSelect(
+          'Agent Clients installed in sandbox',
+          choices(),
+          selected(normalized.state, 'installInSandbox')
+        );
+      } finally {
+        closePrompt();
+      }
+      const state = Object.fromEntries(AGENT_CLIENT_IDS.map((id) => [id, {
+        enabled: enabled.includes(id),
+        installInSandbox: installed.includes(id)
+      }])) as AgentClientState;
+      const plan = workflowPlan(projectRoot, config, { type: 'replace-state', state });
+      const result = applyAgentClientReconciliation(plan);
+      process.stdout.write(
+        `Result: ${result.status}; applied=${result.applied.length}; protected=${result.protected.length}\n`
+      );
+      return 0;
+    }
+
+    throw new AgentClientCommandError(
+      'AGENT_CLIENT_OPERATION_INVALID',
+      `Unknown operation '${operation}'`
+    );
+  } catch (error) {
+    if (error instanceof AgentClientConfigError) {
+      throw new AgentClientCommandError(error.code, error.message);
+    }
+    throw error;
+  }
+}
+
+export { AgentClientCommandError, cmdAgentClient };