@aifabrix/builder 2.54.1 → 2.55.2

package/lib/agent-kit/remote-prompts.js

@@ -0,0 +1,272 @@
+/**
+ * Interactive prompts for agent-kit init and remote create.
+ * @fileoverview TTY host, org, visibility, and confirm; injectable for tests
+ */
+
+'use strict';
+
+const { execFileSync } = require('child_process');
+const { ALL_HOSTS, HOST_LABELS, normalizeHosts } = require('./hosts');
+const { APPROVE_HOSTS, parseApproveAll } = require('./host-approve');
+
+/**
+ * @param {{ execFileSync?: Function }} [options]
+ * @returns {string}
+ */
+function detectGithubLogin(options = {}) {
+  const exec = options.execFileSync || execFileSync;
+  try {
+    const out = exec('gh', ['api', 'user', '-q', '.login'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    return String(out || '').trim();
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * @param {string[]} argv
+ * @param {string} flag
+ * @returns {boolean}
+ */
+function argvHasFlag(argv, flag) {
+  return argv.includes(flag) || argv.some((a) => a.startsWith(`${flag}=`));
+}
+
+/**
+ * Ask which AI coding hosts to install for (TTY only when --host not set).
+ * @param {object} options
+ * @param {{ interactive?: boolean, inquirer?: object, argv?: string[] }} [deps]
+ * @returns {Promise<object>}
+ */
+async function enrichInitHostOptions(options, deps = {}) {
+  const interactive = Boolean(deps.interactive);
+  const argv = deps.argv || process.argv;
+  if (!interactive || argvHasFlag(argv, '--host')) {
+    return options;
+  }
+  const inquirer = deps.inquirer || require('inquirer');
+  const { host } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'host',
+      message: 'Which AI coding platforms should Agent Kit support?',
+      default: 'all',
+      choices: [
+        {
+          name: `All (${ALL_HOSTS.map((h) => HOST_LABELS[h] || h).join(', ')})`,
+          value: 'all'
+        },
+        ...ALL_HOSTS.map((h) => ({
+          name: HOST_LABELS[h] || h,
+          value: h
+        }))
+      ]
+    }
+  ]);
+  return { ...options, host: host || 'all' };
+}
+
+/**
+ * @param {object} deps
+ * @returns {Promise<import('inquirer').Answers>}
+ */
+async function askRemoteFields(deps) {
+  const inquirer = deps.inquirer || require('inquirer');
+  const defaultOrg = deps.defaultOrg || '';
+  return inquirer.prompt([
+    {
+      type: 'input',
+      name: 'org',
+      message: 'GitHub org or user:',
+      default: defaultOrg || undefined,
+      when: () => !deps.org,
+      validate: (v) => (String(v || '').trim() ? true : 'Org or user is required')
+    },
+    {
+      type: 'list',
+      name: 'visibility',
+      message: 'Repository visibility:',
+      choices: [
+        { name: 'private (recommended)', value: 'private' },
+        { name: 'public', value: 'public' }
+      ],
+      default: 'private',
+      when: () => !deps.visibilitySet
+    },
+    {
+      type: 'confirm',
+      name: 'confirmed',
+      message: (answers) => {
+        const org = deps.org || answers.org;
+        const vis = deps.visibility || answers.visibility || 'private';
+        const full = `${org}/${deps.name}`;
+        return `Create github:${full} (${vis}) and push?`;
+      },
+      default: false,
+      when: () => !deps.yes
+    }
+  ]);
+}
+
+/**
+ * Fill org/visibility and confirm on TTY. Non-interactive requires --org.
+ * @param {object} options
+ * @param {{ interactive?: boolean, name?: string, inquirer?: object, execFileSync?: Function, argv?: string[] }} [deps]
+ * @returns {Promise<object>}
+ */
+async function enrichRemoteOptions(options, deps = {}) {
+  const interactive = Boolean(deps.interactive);
+  const name = deps.name || options.name || 'repo';
+  const argv = deps.argv || process.argv;
+  const visibilitySet = argvHasFlag(argv, '--visibility');
+  let org = options.org;
+  let visibility = options.visibility || 'private';
+
+  if (!interactive) {
+    if (!org) {
+      throw new Error('Non-interactive remote create requires --org <owner>.');
+    }
+    return { ...options, org, visibility, name };
+  }
+
+  const defaultOrg = org || detectGithubLogin({ execFileSync: deps.execFileSync });
+  const answers = await askRemoteFields({
+    inquirer: deps.inquirer,
+    org,
+    name,
+    visibility,
+    visibilitySet,
+    defaultOrg,
+    yes: Boolean(options.yes)
+  });
+  org = String(org || answers.org || '').trim();
+  if (answers.visibility) {
+    visibility = answers.visibility;
+  }
+  if (!org) {
+    throw new Error('Org or user is required.');
+  }
+  if (options.yes !== true && answers.confirmed === false) {
+    return { ...options, org, visibility, name, cancelled: true };
+  }
+  return { ...options, org, visibility, name, remote: true };
+}
+
+/**
+ * On TTY without --remote/--no-remote, ask whether to create a remote.
+ * @param {object} options
+ * @param {{ interactive?: boolean, inquirer?: object, execFileSync?: Function, workspaceName?: string }} [deps]
+ * @returns {Promise<object>}
+ */
+async function enrichInitRemoteOptions(options, deps = {}) {
+  const interactive = Boolean(deps.interactive);
+  const remoteExplicit = options.remote === true;
+  const noRemote = options.noRemote === true || options.remote === false;
+
+  if (noRemote || !interactive) {
+    return options;
+  }
+
+  let wantRemote = remoteExplicit;
+  if (!remoteExplicit) {
+    const inquirer = deps.inquirer || require('inquirer');
+    const { createRemote } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'createRemote',
+        message: 'Create a private GitHub remote and push now?',
+        default: false
+      }
+    ]);
+    wantRemote = Boolean(createRemote);
+  }
+  if (!wantRemote) {
+    return { ...options, remote: false };
+  }
+
+  return enrichRemoteOptions(
+    { ...options, remote: true },
+    {
+      interactive: true,
+      name: deps.workspaceName || options.nameOrPath,
+      inquirer: deps.inquirer,
+      execFileSync: deps.execFileSync
+    }
+  );
+}
+
+/**
+ * @param {object} inquirer
+ * @param {string[]} eligible
+ * @returns {Promise<true|false|string>}
+ */
+async function askApproveAllChoice(inquirer, eligible) {
+  if (eligible.length === 1) {
+    const host = eligible[0];
+    const { approveAll } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'approveAll',
+        message: `Auto-approve ${HOST_LABELS[host] || host} tool permissions in this workspace?`,
+        default: true
+      }
+    ]);
+    return Boolean(approveAll);
+  }
+  const { approveAll } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'approveAll',
+      message: 'Which coding host should auto-approve tools in this workspace?',
+      default: 'all',
+      choices: [
+        { name: 'Both Claude Code and Codex', value: 'all' },
+        { name: 'Claude Code only', value: 'claude' },
+        { name: 'Codex only', value: 'codex' },
+        { name: 'Skip (the coding app will ask each time)', value: 'skip' }
+      ]
+    }
+  ]);
+  return approveAll === 'skip' ? false : approveAll;
+}
+
+/**
+ * TTY asks; --approve-all [host] / --yes / non-TTY auto-approve; --skip-approve-all skips.
+ * @param {object} options
+ * @param {{ interactive?: boolean, inquirer?: object, ask?: boolean }} [deps]
+ * @returns {Promise<object>}
+ */
+async function enrichApproveAllOptions(options, deps = {}) {
+  const hosts = normalizeHosts(options.host);
+  const eligible = hosts.filter((h) => APPROVE_HOSTS.includes(h));
+  if (!eligible.length || options.skipApproveAll) {
+    return { ...options, approveAll: false };
+  }
+  if (options.approveAll) {
+    parseApproveAll(options.approveAll);
+    return options;
+  }
+  if (options.yes) {
+    return { ...options, approveAll: true };
+  }
+  if (deps.ask === false) {
+    return { ...options, approveAll: false };
+  }
+  if (!deps.interactive) {
+    return { ...options, approveAll: true };
+  }
+  const inquirer = deps.inquirer || require('inquirer');
+  const approveAll = await askApproveAllChoice(inquirer, eligible);
+  return { ...options, approveAll };
+}
+
+module.exports = {
+  detectGithubLogin,
+  enrichInitHostOptions,
+  enrichRemoteOptions,
+  enrichInitRemoteOptions,
+  enrichApproveAllOptions
+};

package/lib/agent-kit/render-host-markdown.js

@@ -0,0 +1,40 @@
+/**
+ * Render Agent Kit markdown for the selected coding hosts.
+ * @fileoverview Handlebars host flags for AGENTKIT.md
+ */
+
+'use strict';
+
+const Handlebars = require('handlebars');
+const { ALL_HOSTS } = require('./hosts');
+
+/**
+ * @param {string[]} hosts
+ * @returns {object}
+ */
+function hostMarkdownContext(hosts) {
+  const selected = Array.isArray(hosts) && hosts.length ? hosts : ALL_HOSTS.slice();
+  const cursor = selected.includes('cursor');
+  const claude = selected.includes('claude');
+  const codex = selected.includes('codex');
+  const hostFlag = selected.length === ALL_HOSTS.length ? 'all' : selected.join(',');
+  return {
+    cursor,
+    claude,
+    codex,
+    autoApprove: claude || codex,
+    hostFlag
+  };
+}
+
+/**
+ * @param {string} source
+ * @param {string[]} hosts
+ * @returns {string}
+ */
+function renderHostMarkdown(source, hosts) {
+  const template = Handlebars.compile(String(source || ''), { noEscape: true });
+  return template(hostMarkdownContext(hosts)).replace(/\n{3,}/g, '\n\n');
+}
+
+module.exports = { hostMarkdownContext, renderHostMarkdown };

package/lib/agent-kit/repo-guard.js

@@ -0,0 +1,47 @@
+/**
+ * Git repository root guard for Agent Kit install.
+ * @fileoverview Refuse home, filesystem root, and non-git directories
+ */
+
+'use strict';
+
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+/**
+ * @param {string} resolved
+ * @returns {boolean}
+ */
+function isUnsafeRoot(resolved) {
+  const home = path.resolve(os.homedir());
+  const root = path.resolve(resolved);
+  if (root === path.parse(root).root) {
+    return true;
+  }
+  return root === home;
+}
+
+/**
+ * @param {string} cwd
+ * @returns {string}
+ */
+function resolveGitRoot(cwd) {
+  let output;
+  try {
+    output = execFileSync('git', ['rev-parse', '--show-toplevel'], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+  } catch {
+    throw new Error('Agent Kit commands must run inside a git repository.');
+  }
+  const resolved = path.resolve(output);
+  if (isUnsafeRoot(resolved)) {
+    throw new Error('Refusing to install the Agent Kit into a filesystem root or home directory.');
+  }
+  return resolved;
+}
+
+module.exports = { isUnsafeRoot, resolveGitRoot };

package/lib/agent-kit/report.js

@@ -0,0 +1,107 @@
+/**
+ * Human and JSON reports for Agent Kit commands.
+ * @fileoverview Status envelope without ANSI in JSON
+ */
+
+'use strict';
+
+const { ACTION, KIT_STATE } = require('./constants');
+const { hostLabel } = require('./hosts');
+
+/**
+ * @param {object[]} ops
+ * @returns {string[]}
+ */
+function conflictPaths(ops) {
+  return ops.filter((op) => op.action === ACTION.CONFLICT).map((op) => op.targetRel);
+}
+
+/**
+ * @param {object[]} ops
+ * @returns {number}
+ */
+function countInstalledSkills(ops) {
+  return (ops || []).filter((op) => {
+    const rel = op.targetRel || '';
+    const skillFile = rel.includes('.agents/skills/') && rel.endsWith('SKILL.md');
+    return skillFile && op.action !== ACTION.DELETE && op.action !== ACTION.CONFLICT;
+  }).length;
+}
+
+/**
+ * @param {object|null} state
+ * @param {object} kit
+ * @param {object[]} ops
+ * @returns {string}
+ */
+function kitStateName(state, kit, ops) {
+  if (!state) {
+    return KIT_STATE.NOT_INSTALLED;
+  }
+  if (conflictPaths(ops).length > 0) {
+    return KIT_STATE.CONFLICTS;
+  }
+  if (state.kitVersion !== kit.manifest.kitVersion) {
+    return KIT_STATE.UPDATE_AVAILABLE;
+  }
+  const applied = new Set([ACTION.CREATE, ACTION.REPLACE, ACTION.APPEND_SECTION]);
+  const missing = ops.some((op) => {
+    return op.fileState === 'MISSING' && op.mode !== 'obsolete' && !applied.has(op.action);
+  });
+  return missing ? KIT_STATE.UPDATE_AVAILABLE : KIT_STATE.CURRENT;
+}
+
+/**
+ * @param {object} params
+ * @returns {object}
+ */
+function buildJsonReport(params) {
+  const { command, kit, state, hosts, ops, dryRun, builderVersion, kitState, approvals } = params;
+  return {
+    success: conflictPaths(ops).length === 0,
+    command,
+    dryRun: Boolean(dryRun),
+    state: kitState,
+    kitVersion: kit.manifest.kitVersion,
+    installedKitVersion: state ? state.kitVersion : null,
+    builderVersion,
+    skills: {
+      expected: (kit.manifest.skills || []).length,
+      installed: countInstalledSkills(ops)
+    },
+    hosts,
+    files: (ops || []).map((op) => ({
+      path: op.targetRel,
+      classification: op.fileState,
+      action: op.action
+    })),
+    conflicts: conflictPaths(ops),
+    approvals: approvals || { requested: false, files: [] }
+  };
+}
+
+/**
+ * @param {object} json
+ * @returns {string}
+ */
+function formatHumanStatus(json) {
+  const installed = json.installedKitVersion || '—';
+  const hosts = (json.hosts || []).map((h) => hostLabel(h)).join(', ');
+  const lines = [
+    'AI Fabrix Agent Kit',
+    `Installed  ${installed}`,
+    `Available  ${json.kitVersion} (Builder ${json.builderVersion})`,
+    `Skills     ${json.skills.installed}/${json.skills.expected}`,
+    `Hosts      ${hosts || '—'}`,
+    `State      ${json.state}`
+  ];
+  if (json.approvals && json.approvals.requested) {
+    const paths = (json.approvals.files || [])
+      .filter((row) => row.action !== 'skip')
+      .map((row) => `${row.path} (${row.action})`);
+    lines.push(`Approvals  ${paths.join(', ') || 'none'}`);
+  }
+  return lines.join('\n');
+}
+
+module.exports = { conflictPaths, kitStateName, buildJsonReport, formatHumanStatus };

package/lib/agent-kit/run.js

@@ -0,0 +1,82 @@
+/**
+ * Shared Agent Kit install/update runner.
+ * @fileoverview Classify, plan, optionally apply, write state
+ */
+
+'use strict';
+
+const { getCliVersion } = require('../utils/installation-log-core');
+const { resolveGitRoot } = require('./repo-guard');
+const { loadKitPackage } = require('./package-load');
+const { listManagedTargets } = require('./file-list');
+const { classifyItems } = require('./classify');
+const { detectV1, listObsoleteV1Items, markV1ShimReplacements } = require('./v1-detect');
+const { loadState, buildStateDocument, writeState } = require('./state-file');
+const { actionForInstall, actionForUpdate, assignActions } = require('./plan-ops');
+const { applyOps } = require('./apply-ops');
+const { resolveManagedHosts } = require('./hosts');
+const { kitStateName, buildJsonReport } = require('./report');
+const { writeApproveAllFiles } = require('./host-approve');
+
+/**
+ * @param {object} options
+ * @param {'install'|'update'} mode
+ * @returns {object}
+ */
+function runManagedCommand(options, mode) {
+  const repoRoot = resolveGitRoot(options.cwd || process.cwd());
+  const kit = loadKitPackage();
+  const state = loadState(repoRoot);
+  const hosts = resolveManagedHosts(options, state, mode);
+  const includeShims = detectV1(repoRoot) && hosts.includes('cursor');
+  const includeClaude = hosts.includes('claude');
+  const items = listManagedTargets(kit, repoRoot, { includeShims, includeClaude });
+  classifyItems(items, state, hosts);
+  markV1ShimReplacements(items, kit);
+  const managedRels = new Set(items.map((item) => item.targetRel));
+  items.push(...listObsoleteV1Items(kit, repoRoot, managedRels));
+  const picker = mode === 'update' ? actionForUpdate : actionForInstall;
+  const ops = assignActions(items, picker, Boolean(options.force));
+  if (!options.dryRun) {
+    applyOps(ops);
+    writeState(repoRoot, buildStateDocument(kit, hosts, ops, getCliVersion()));
+  }
+  const builderVersion = getCliVersion();
+  const kitState = kitStateName(options.dryRun ? state : loadState(repoRoot) || state, kit, ops);
+  const approvals = writeApproveAllFiles({
+    repoRoot,
+    hosts,
+    approveAll: options.approveAll,
+    dryRun: Boolean(options.dryRun),
+    force: Boolean(options.force)
+  });
+  return buildJsonReport({
+    command: mode,
+    kit,
+    state: options.dryRun ? state : loadState(repoRoot) || state,
+    hosts,
+    ops,
+    dryRun: Boolean(options.dryRun),
+    builderVersion,
+    kitState,
+    approvals
+  });
+}
+
+/**
+ * @param {object} options
+ * @returns {object}
+ */
+function runInstall(options) {
+  return runManagedCommand(options, 'install');
+}
+
+/**
+ * @param {object} options
+ * @returns {object}
+ */
+function runUpdate(options) {
+  return runManagedCommand(options, 'update');
+}
+
+module.exports = { runInstall, runUpdate, runManagedCommand };

package/lib/agent-kit/scm/git.js

@@ -0,0 +1,122 @@
+/**
+ * Local git SCM helpers for agent-kit init.
+ * @fileoverview git init / detect / initial commit
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('../../internal/fs-real-sync');
+const { execFileSync } = require('child_process');
+
+const INITIAL_COMMIT_MESSAGE = 'Initial customer workspace with Agent Kit.';
+
+/**
+ * @param {string} dir
+ * @returns {boolean}
+ */
+function isGitRepository(dir) {
+  return fs.existsSync(path.join(dir, '.git'));
+}
+
+/**
+ * @param {string} dir
+ * @param {{ dryRun?: boolean, execFileSync?: Function }} [options]
+ * @returns {{ initialized: boolean, skipped: boolean }}
+ */
+function ensureGitRepository(dir, options = {}) {
+  const exec = options.execFileSync || execFileSync;
+  if (isGitRepository(dir)) {
+    return { initialized: false, skipped: true };
+  }
+  if (options.dryRun) {
+    return { initialized: true, skipped: false };
+  }
+  exec('git', ['init', '-b', 'main'], { cwd: dir, stdio: 'ignore' });
+  return { initialized: true, skipped: false };
+}
+
+/**
+ * @param {string} dir
+ * @param {Function} exec
+ * @returns {boolean}
+ */
+function hasCommits(dir, exec) {
+  try {
+    exec('git', ['rev-parse', 'HEAD'], { cwd: dir, stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create the first commit when HEAD is missing (required before gh --push).
+ * Uses one-shot -c identity; does not rewrite git config.
+ * @param {string} dir
+ * @param {{ dryRun?: boolean, execFileSync?: Function }} [options]
+ * @returns {{ committed: boolean, skipped: boolean, planned?: boolean }}
+ */
+function ensureInitialCommit(dir, options = {}) {
+  const exec = options.execFileSync || execFileSync;
+  if (options.dryRun) {
+    return { committed: true, skipped: false, planned: true };
+  }
+  if (hasCommits(dir, exec)) {
+    return { committed: false, skipped: true };
+  }
+  exec('git', ['add', '-A'], { cwd: dir, stdio: 'ignore' });
+  const status = exec('git', ['status', '--porcelain'], {
+    cwd: dir,
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  if (!String(status || '').trim()) {
+    throw new Error('No files to commit before creating the remote.');
+  }
+  exec(
+    'git',
+    [
+      '-c',
+      'user.email=noreply@aifabrix.ai',
+      '-c',
+      'user.name=AI Fabrix Builder',
+      'commit',
+      '-m',
+      INITIAL_COMMIT_MESSAGE
+    ],
+    { cwd: dir, stdio: 'ignore' }
+  );
+  return { committed: true, skipped: false };
+}
+
+/**
+ * @param {string} dir
+ * @param {{ execFileSync?: Function }} [options]
+ * @returns {boolean}
+ */
+function hasOriginRemote(dir, options = {}) {
+  const exec = options.execFileSync || execFileSync;
+  try {
+    const out = exec('git', ['remote'], {
+      cwd: dir,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    });
+    return String(out)
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .includes('origin');
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  isGitRepository,
+  ensureGitRepository,
+  ensureInitialCommit,
+  hasOriginRemote,
+  hasCommits,
+  INITIAL_COMMIT_MESSAGE
+};