@izkac/forgekit 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@izkac/forgekit",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Forgekit CLIs — forgekit (install), forge (workflow), review (code review)",
   "type": "module",
   "bin": {

package/src/init.mjs

@@ -30,6 +30,11 @@ import {
   writeProjectPlanConfig,
 } from './plan-engine.mjs';
 import { resolveAsset } from './paths.mjs';
+import { AGENT_IDS, AGENTS, installedManagedPairs } from './install.mjs';
+
+// Environments with project-local command/rule/hook templates. Others are
+// driven by the globally-installed skill alone (no per-project wiring).
+const WIRED_AGENTS = Object.freeze(['cursor', 'claude', 'codex']);
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
@@ -61,6 +66,10 @@ export function parseArgs(argv) {
     else if (arg === '--cursor') opts.agents.push('cursor');
     else if (arg === '--claude' || arg === '--claude-code') opts.agents.push('claude');
     else if (arg === '--codex') opts.agents.push('codex');
+    else if (arg === '--copilot') opts.agents.push('copilot');
+    else if (arg === '--gemini') opts.agents.push('gemini');
+    else if (arg === '--windsurf') opts.agents.push('windsurf');
+    else if (arg === '--opencode') opts.agents.push('opencode');
     else if (arg === '--adr') opts.adr = true;
     else if (arg === '--no-adr') opts.adr = false;
     else if (arg === '--adr-dir') opts.adrDir = argv[++i];
@@ -81,7 +90,10 @@ Options:
   --cursor          Cursor (.cursor/commands, rules, hooks)
   --claude          Claude Code (.claude/commands, rules, hooks)
   --codex           Codex CLI (.codex/rules)
-  --all             All of the above
+  --copilot/--gemini/--windsurf/--opencode
+                    Offered in the picker for parity with \`forgekit install\`;
+                    driven by the global skill (no per-project wiring yet)
+  --all             Every offered environment
   --openspec        Plan with OpenSpec (offer install + \`openspec init\` if missing)
   --no-openspec     Plan with the built-in specs engine (${DEFAULT_SPECS_DIR}/changes/)
   --adr             Enable ADRs (scaffold decisions.md + ADR dir + hooks)
@@ -95,10 +107,12 @@ Options:
 Requires the Forge skill already installed (\`forge install\`) for agents
 to load skill content. Init only adds project-local wiring.
 
-Interactive (TTY): when --openspec/--no-openspec omitted and OpenSpec is not
-already set up, offers to install + set it up (decline = built-in specs
-engine). When --adr/--no-adr omitted, asks whether to use ADRs and for the
-directory inside the repo.
+Interactive (TTY): the environment picker matches \`forgekit install\` and is
+pre-checked with what you installed there (saved in ~/.forgekit/config.json),
+so you don't pick twice. When --openspec/--no-openspec omitted and OpenSpec is
+not already set up, offers to install + set it up (decline = built-in specs
+engine). When --adr/--no-adr omitted, asks whether to use ADRs (default Yes)
+and for the directory inside the repo.
 `);
 }
 
@@ -343,6 +357,10 @@ export function initProject(selected, opts) {
     );
   }
 
+  // Selected environments without project-wiring templates: the globally
+  // installed skill is their interface — nothing to scaffold per project.
+  report.skillOnly = selected.filter((id) => !WIRED_AGENTS.includes(id));
+
   if (opts.planEngine === 'specs') {
     const scaffold = scaffoldSpecs(cwd, { force: opts.force });
     const config = writeProjectPlanConfig(cwd, {
@@ -407,16 +425,32 @@ function wiredAgents(cwd) {
   );
 }
 
+/**
+ * Environments to pre-check: those chosen during `forgekit install`
+ * (saved in ~/.forgekit/config.json), plus what is already installed or wired.
+ * @param {string} cwd
+ * @param {string} [home]
+ * @returns {Set<string>}
+ */
+export function rememberedAgents(cwd, home) {
+  const user = loadUserConfig(home);
+  return new Set([
+    ...(Array.isArray(user.agents) ? user.agents : []),
+    ...installedManagedPairs(home).map((p) => p.agent),
+    ...wiredAgents(cwd),
+  ]);
+}
+
 /** @param {string} cwd */
 async function promptAgents(cwd) {
-  const wired = wiredAgents(cwd);
+  const remembered = rememberedAgents(cwd);
   return checkbox({
     message: 'Init Forge project wiring for which environments?',
-    choices: [
-      { value: 'cursor', name: 'Cursor', checked: wired.has('cursor') },
-      { value: 'claude', name: 'Claude Code', checked: wired.has('claude') },
-      { value: 'codex', name: 'Codex CLI', checked: wired.has('codex') },
-    ],
+    choices: AGENT_IDS.map((id) => ({
+      value: id,
+      name: AGENTS[id].label,
+      checked: remembered.has(id),
+    })),
     required: true,
   });
 }
@@ -435,17 +469,18 @@ async function promptOpenSpecSetup() {
 
 /**
  * Resolve the planning engine for `forge init`, offering OpenSpec setup when needed.
- * @param {{ cwd: string, openspec: boolean | null }} opts
+ * @param {{ cwd: string, openspec: boolean | null, agents?: string[] }} opts
  * @returns {Promise<string>} 'openspec' | 'specs'
  */
 async function resolveInitPlanEngine(opts) {
   const configured = hasOpenSpecConfig(opts.cwd);
+  const tools = opts.agents;
 
   if (opts.openspec === false) return 'specs';
 
   if (opts.openspec === true) {
     if (!configured && process.stdin.isTTY) {
-      const setup = setupOpenSpec(opts.cwd);
+      const setup = setupOpenSpec(opts.cwd, { tools });
       for (const s of setup.steps) {
         process.stdout.write(`  [${s.ok ? 'ok' : 'FAIL'}] ${s.step}${s.detail ? ` — ${s.detail}` : ''}\n`);
       }
@@ -471,7 +506,7 @@ async function resolveInitPlanEngine(opts) {
   const accepted = await promptOpenSpecSetup();
   if (!accepted) return 'specs';
 
-  const setup = setupOpenSpec(opts.cwd);
+  const setup = setupOpenSpec(opts.cwd, { tools });
   for (const s of setup.steps) {
     process.stdout.write(`  [${s.ok ? 'ok' : 'FAIL'}] ${s.step}${s.detail ? ` — ${s.detail}` : ''}\n`);
   }
@@ -486,12 +521,13 @@ async function resolveInitPlanEngine(opts) {
 
 /**
  * @param {string} [defaultDir]
+ * @param {boolean} [defaultEnabled]
  * @returns {Promise<{ enabled: boolean, dir: string }>}
  */
-async function promptAdrForInit(defaultDir = DEFAULT_ADR_DIR) {
+async function promptAdrForInit(defaultDir = DEFAULT_ADR_DIR, defaultEnabled = true) {
   const enabled = await confirm({
     message: 'Use Architecture Decision Records (ADRs) in this project?',
-    default: false,
+    default: defaultEnabled,
   });
   if (!enabled) return { enabled: false, dir: defaultDir };
   const dir = await input({
@@ -508,20 +544,28 @@ async function main(argv = process.argv.slice(2)) {
     return 0;
   }
 
-  let selected = opts.all ? ['cursor', 'claude', 'codex'] : [...new Set(opts.agents)];
+  let selected = opts.all ? [...AGENT_IDS] : [...new Set(opts.agents)];
   if (selected.length === 0) {
     if (!process.stdin.isTTY) {
       process.stderr.write(
-        'No agents specified. Pass --cursor/--claude/--codex/--all, or run in a TTY.\n',
+        'No agents specified. Pass --cursor/--claude/--codex/--copilot/--gemini/--windsurf/--opencode/--all, or run in a TTY.\n',
       );
       return 1;
     }
     selected = await promptAgents(opts.cwd);
   }
 
+  for (const id of selected) {
+    if (!AGENTS[id]) {
+      process.stderr.write(`Unknown environment: ${id}. Known: ${AGENT_IDS.join(', ')}\n`);
+      return 1;
+    }
+  }
+
   const planEngine = await resolveInitPlanEngine({
     cwd: opts.cwd,
     openspec: opts.openspec,
+    agents: selected,
   });
 
   let adr = opts.adr;
@@ -530,7 +574,8 @@ async function main(argv = process.argv.slice(2)) {
     const user = loadUserConfig();
     const defaultDir = user.adr?.dir ?? DEFAULT_ADR_DIR;
     if (process.stdin.isTTY) {
-      const picked = await promptAdrForInit(defaultDir);
+      // Default Yes, unless the user globally opted out of ADRs.
+      const picked = await promptAdrForInit(defaultDir, user.adr?.enabled !== false);
       adr = picked.enabled;
       adrDir = picked.dir;
     } else if (user.adr?.enabled === true) {
@@ -543,6 +588,12 @@ async function main(argv = process.argv.slice(2)) {
 
   const report = initProject(selected, { ...opts, adr, adrDir, planEngine });
   process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+  if (Array.isArray(report.skillOnly) && report.skillOnly.length) {
+    const labels = report.skillOnly.map((id) => AGENTS[id].label).join(', ');
+    process.stdout.write(
+      `\nNo project wiring for: ${labels} — they use the globally installed Forge skill directly (run \`forgekit install\` if not yet installed).\n`,
+    );
+  }
   process.stdout.write(
     `\nMerge hook snippets into settings if needed, ensure \`forge\` is on PATH, then open the project in your agent.\n`,
   );

package/src/init.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { parseArgs, initProject, rememberedAgents } from './init.mjs';
+import { installSkillsToAgents } from './install.mjs';
+import { saveUserConfig } from './config.mjs';
+
+test('init parseArgs accepts the expanded environment shorthands', () => {
+  const opts = parseArgs(['--cursor', '--copilot', '--gemini', '--windsurf', '--opencode']);
+  assert.deepEqual(opts.agents, ['cursor', 'copilot', 'gemini', 'windsurf', 'opencode']);
+});
+
+test('rememberedAgents unions install config, installed skills, and project wiring', () => {
+  const home = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-home-'));
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-proj-'));
+  try {
+    // Chosen during `forgekit install` (saved to user config).
+    saveUserConfig({ agents: ['claude', 'gemini'] }, home);
+    // Actually installed skill for another env.
+    installSkillsToAgents(['forge'], ['copilot'], { home, force: true });
+    // Project already wired for cursor.
+    fs.mkdirSync(path.join(cwd, '.cursor', 'commands'), { recursive: true });
+
+    const remembered = rememberedAgents(cwd, home);
+    assert.ok(remembered.has('claude'), 'from install config');
+    assert.ok(remembered.has('gemini'), 'from install config');
+    assert.ok(remembered.has('copilot'), 'from installed skill dir');
+    assert.ok(remembered.has('cursor'), 'from project wiring marker');
+    assert.ok(!remembered.has('codex'));
+  } finally {
+    fs.rmSync(home, { recursive: true, force: true });
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
+test('initProject wires templated envs and marks the rest skill-only', () => {
+  const cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'forgekit-init-'));
+  try {
+    const report = initProject(['cursor', 'copilot', 'gemini'], {
+      cwd,
+      force: true,
+      adr: false,
+      planEngine: null,
+    });
+    assert.ok(report.files.some((f) => f.file.includes('.cursor')));
+    assert.deepEqual(report.skillOnly, ['copilot', 'gemini']);
+    assert.ok(!fs.existsSync(path.join(cwd, '.copilot')));
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});

package/src/install.mjs

@@ -730,6 +730,9 @@ export async function runInstall(argv = process.argv.slice(2)) {
 
   saveUserConfig({
     adr: { enabled: adrOpts.enabled, dir: adrOpts.dir },
+    // Remember the environment set so `forge init` can pre-check it. Only when
+    // deliberately chosen (picker or --all-agents) — narrow flag runs don't clobber it.
+    ...(resolved.agentsPrompted || opts.allAgents || opts.all ? { agents } : {}),
   });
 
   const { results, removed } = prune

package/src/plan-engine.mjs

@@ -204,12 +204,28 @@ export function checkOpenSpecCliQuick(runCommand) {
   return { ok: false, version: null };
 }
 
+/**
+ * Map forgekit environment ids → OpenSpec tool ids (mostly identity).
+ * @type {Record<string, string>}
+ */
+const OPENSPEC_TOOL_ID = { copilot: 'github-copilot' };
+
+/**
+ * @param {string[]} agentIds forgekit environment ids
+ * @returns {string[]} OpenSpec tool ids
+ */
+export function toOpenSpecToolIds(agentIds) {
+  return agentIds.map((id) => OPENSPEC_TOOL_ID[id] ?? id);
+}
+
 /**
  * Install the OpenSpec CLI (if missing) and run `openspec init` in the project.
- * Interactive: inherits stdio so `openspec init` can prompt.
+ * Interactive: inherits stdio so `openspec init` can prompt — unless `tools`
+ * is given, in which case those tools are configured non-interactively
+ * (`openspec init --tools <ids>`), skipping OpenSpec's own tool picker.
  *
  * @param {string} cwd
- * @param {{ runCommand?: Function, interactive?: boolean }} [opts]
+ * @param {{ runCommand?: Function, interactive?: boolean, tools?: string[] }} [opts]
  * @returns {{ ok: boolean, steps: { step: string, ok: boolean, detail?: string }[] }}
  */
 export function setupOpenSpec(cwd, opts = {}) {
@@ -249,10 +265,12 @@ export function setupOpenSpec(cwd, opts = {}) {
     return { ok: true, steps };
   }
 
-  const init = runInherit('openspec', ['init']);
+  const tools = opts.tools?.length ? toOpenSpecToolIds(opts.tools) : null;
+  const initArgs = tools ? ['init', '--tools', tools.join(',')] : ['init'];
+  const init = runInherit('openspec', initArgs);
   const initOk = init.status === 0;
   steps.push({
-    step: 'openspec init',
+    step: `openspec ${initArgs.join(' ')}`,
     ok: initOk,
     detail: initOk ? undefined : String(init.error ?? `exit ${init.status}`),
   });

package/src/plan-engine.test.mjs

@@ -12,6 +12,7 @@ import {
   saveUserPlanEngine,
   scaffoldSpecs,
   setupOpenSpec,
+  toOpenSpecToolIds,
   writeProjectPlanConfig,
 } from './plan-engine.mjs';
 import { loadProjectConfig, loadUserConfig, saveUserConfig } from './adr.mjs';
@@ -148,6 +149,43 @@ test('setupOpenSpec runs install + init via injected runner', () => {
   }
 });
 
+test('toOpenSpecToolIds maps copilot → github-copilot, else identity', () => {
+  assert.deepEqual(
+    toOpenSpecToolIds(['claude', 'cursor', 'codex', 'opencode', 'copilot', 'gemini', 'windsurf']),
+    ['claude', 'cursor', 'codex', 'opencode', 'github-copilot', 'gemini', 'windsurf'],
+  );
+});
+
+test('setupOpenSpec passes selected tools to `openspec init --tools`', () => {
+  const cwd = tmpdir('forgekit-openspec-tools-');
+  try {
+    /** @type {string[]} */
+    const calls = [];
+    const runCommand = (cmd, args) => {
+      const line = [cmd, ...args].join(' ');
+      calls.push(line);
+      if (line === 'openspec --version') return { status: 0, stdout: '1.0.0' };
+      if (line.startsWith('openspec init')) {
+        fs.mkdirSync(path.join(cwd, 'openspec'), { recursive: true });
+        fs.writeFileSync(path.join(cwd, 'openspec', 'config.yaml'), 'x: 1\n', 'utf8');
+        return { status: 0, stdout: '' };
+      }
+      return { status: 1, stdout: '' };
+    };
+    const result = setupOpenSpec(cwd, {
+      runCommand,
+      tools: ['claude', 'cursor', 'codex', 'copilot'],
+    });
+    assert.equal(result.ok, true);
+    assert.ok(
+      calls.includes('openspec init --tools claude,cursor,codex,github-copilot'),
+      `expected --tools call, got: ${calls.join(' | ')}`,
+    );
+  } finally {
+    fs.rmSync(cwd, { recursive: true, force: true });
+  }
+});
+
 test('setupOpenSpec reports failure when install fails', () => {
   const cwd = tmpdir('forgekit-openspec-fail-');
   try {