swarmkit 0.0.6 → 0.0.7

package/dist/commands/init/phases/wizard-modes.test.js

@@ -0,0 +1,270 @@
+/**
+ * Tests for interactive vs non-interactive wizard modes.
+ *
+ * These tests verify that runPackageWizard correctly handles both modes:
+ * - Interactive: stdio: "inherit", uses `args` (wizard takes over terminal)
+ * - Non-interactive: stdio: "pipe", uses `nonInteractiveArgs` (silent, for CI/testing)
+ *
+ * All tests use real CLIs against real filesystems in temp directories.
+ */
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync, readFileSync, writeFileSync, realpathSync, } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { execFile, execSync } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+// ─── Mock homedir only ──────────────────────────────────────────────────────
+let testHome;
+vi.mock("node:os", async () => {
+    const actual = await import("node:os");
+    return { ...actual, homedir: () => testHome };
+});
+const { runPackageWizard, relocateAfterWizard, isProjectInit, initProjectPackage, PROJECT_INIT_ORDER, } = await import("../../../packages/setup.js");
+import { PACKAGES } from "../../../packages/registry.js";
+import { createEmptyState } from "../state.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+let testDir;
+beforeEach(() => {
+    const realTmp = realpathSync(tmpdir());
+    testDir = join(realTmp, `swarmkit-wizard-modes-${randomUUID()}`);
+    testHome = join(realTmp, `swarmkit-wizard-modes-home-${randomUUID()}`);
+    mkdirSync(testDir, { recursive: true });
+    mkdirSync(testHome, { recursive: true });
+});
+afterEach(() => {
+    rmSync(testDir, { recursive: true, force: true });
+    rmSync(testHome, { recursive: true, force: true });
+});
+async function hasCliInstalled(command) {
+    try {
+        await execFileAsync("which", [command]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function createProject(name, dir = testDir) {
+    execSync("git init -q", { cwd: dir });
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name, version: "1.0.0" }));
+    return dir;
+}
+// ─── runPackageWizard: interactive vs non-interactive ────────────────────────
+describe("runPackageWizard — interactive mode (stdio: inherit)", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    const skOk = await hasCliInstalled("skill-tree");
+    it.skipIf(!opentasksOk)("opentasks: interactive mode uses args, creates config", async () => {
+        createProject("interactive-ot");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        const wizardConfig = PACKAGES.opentasks.setup.cliWizard;
+        const result = await runPackageWizard("opentasks", { ...wizardConfig, args: ["init", "--name", "interactive-ot"] }, state, { cwd: testDir, interactive: true });
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        const config = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        expect(config.location.name).toBe("interactive-ot");
+    });
+    it.skipIf(!skOk)("skill-tree: interactive mode runs config init", async () => {
+        const state = createEmptyState();
+        state.selectedPackages = ["skill-tree"];
+        const result = await runPackageWizard("skill-tree", PACKAGES["skill-tree"].setup.cliWizard, state, { cwd: testDir, interactive: true });
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+    });
+});
+describe("runPackageWizard — non-interactive mode (stdio: pipe)", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    const skOk = await hasCliInstalled("skill-tree");
+    it.skipIf(!opentasksOk)("opentasks: non-interactive mode completes silently", async () => {
+        createProject("noninteractive-ot");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        const result = await runPackageWizard("opentasks", { ...PACKAGES.opentasks.setup.cliWizard, args: ["init", "--name", "noninteractive-ot"] }, state, { cwd: testDir, interactive: false });
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".opentasks", "config.json"))).toBe(true);
+        const config = JSON.parse(readFileSync(join(testDir, ".opentasks", "config.json"), "utf-8"));
+        expect(config.location.name).toBe("noninteractive-ot");
+    });
+    it.skipIf(!skOk)("skill-tree: non-interactive mode runs silently", async () => {
+        const state = createEmptyState();
+        state.selectedPackages = ["skill-tree"];
+        const result = await runPackageWizard("skill-tree", PACKAGES["skill-tree"].setup.cliWizard, state, { cwd: testDir, interactive: false });
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testHome, ".skill-tree", "config.yaml"))).toBe(true);
+    });
+    it("non-interactive uses nonInteractiveArgs when available", async () => {
+        const state = createEmptyState();
+        // Use a node script to verify which args were received
+        const result = await runPackageWizard("test-pkg", {
+            command: "node",
+            args: ["-e", "process.exit(1)"], // interactive would fail
+            nonInteractiveArgs: ["-e", "process.exit(0)"], // non-interactive succeeds
+        }, state, { interactive: false });
+        // Should have used nonInteractiveArgs (exit 0), not args (exit 1)
+        expect(result.success).toBe(true);
+    });
+    it("non-interactive falls back to args when nonInteractiveArgs not set", async () => {
+        const state = createEmptyState();
+        const result = await runPackageWizard("test-pkg", {
+            command: "node",
+            args: ["-e", "process.exit(0)"],
+            // no nonInteractiveArgs
+        }, state, { interactive: false });
+        expect(result.success).toBe(true);
+    });
+    it("interactive mode ignores nonInteractiveArgs", async () => {
+        const state = createEmptyState();
+        const result = await runPackageWizard("test-pkg", {
+            command: "node",
+            args: ["-e", "process.exit(0)"], // interactive uses these
+            nonInteractiveArgs: ["-e", "process.exit(1)"], // would fail
+        }, state, { interactive: true });
+        // Should have used args (exit 0), not nonInteractiveArgs (exit 1)
+        expect(result.success).toBe(true);
+    });
+});
+// ─── Non-interactive mode with sdr ───────────────────────────────────────────
+describe("runPackageWizard — sdr non-interactive (template flag)", async () => {
+    const sdrOk = await hasCliInstalled("sdr");
+    it.skipIf(!sdrOk)("sdr: non-interactive uses -t template instead of interactive wizard", async () => {
+        createProject("sdr-noninteractive");
+        const state = createEmptyState();
+        state.selectedPackages = ["self-driving-repo"];
+        const wizardConfig = PACKAGES["self-driving-repo"].setup.cliWizard;
+        // Verify nonInteractiveArgs is defined
+        expect(wizardConfig.nonInteractiveArgs).toBeDefined();
+        expect(wizardConfig.nonInteractiveArgs).toContain("-t");
+        const result = await runPackageWizard("self-driving-repo", wizardConfig, state, { cwd: testDir, interactive: false });
+        expect(result.success).toBe(true);
+        expect(existsSync(join(testDir, ".self-driving"))).toBe(true);
+    });
+});
+// ─── E2E: non-interactive full init flow ─────────────────────────────────────
+describe("e2e: non-interactive wizard → init → verify", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("non-interactive opentasks wizard + prefix relocation", async () => {
+        createProject("e2e-noninteractive");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks"];
+        state.usePrefix = true;
+        // Run wizard non-interactively
+        const wizardConfig = {
+            ...PACKAGES.opentasks.setup.cliWizard,
+            args: ["init", "--name", "e2e-noninteractive"],
+        };
+        const result = await runPackageWizard("opentasks", wizardConfig, state, { cwd: testDir, interactive: false });
+        expect(result.success).toBe(true);
+        // Relocate to prefixed layout
+        relocateAfterWizard(testDir, "opentasks", true);
+        // Should be at .swarm/opentasks/
+        expect(existsSync(join(testDir, ".swarm", "opentasks", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".opentasks"))).toBe(false);
+        // isProjectInit should detect it
+        expect(isProjectInit(testDir, "opentasks")).toBe(true);
+    });
+    it.skipIf(!opentasksOk)("non-interactive wizard then normal init skips wizard-configured package", async () => {
+        createProject("e2e-skip");
+        const state = createEmptyState();
+        state.selectedPackages = ["opentasks", "minimem", "sessionlog"];
+        state.usePrefix = true;
+        // Run opentasks wizard non-interactively
+        const result = await runPackageWizard("opentasks", {
+            ...PACKAGES.opentasks.setup.cliWizard,
+            args: ["init", "--name", "e2e-skip"],
+        }, state, { cwd: testDir, interactive: false });
+        expect(result.success).toBe(true);
+        relocateAfterWizard(testDir, "opentasks", true);
+        // Now run normal project init for remaining packages
+        const initResults = [];
+        for (const pkg of PROJECT_INIT_ORDER) {
+            if (!state.selectedPackages.includes(pkg))
+                continue;
+            if (isProjectInit(testDir, pkg)) {
+                initResults.push(`${pkg}:skipped`);
+                continue;
+            }
+            const ctx = {
+                cwd: testDir,
+                packages: state.selectedPackages,
+                embeddingProvider: state.embeddingProvider,
+                apiKeys: state.apiKeys,
+                usePrefix: state.usePrefix,
+            };
+            await initProjectPackage(pkg, ctx);
+            initResults.push(`${pkg}:init`);
+        }
+        // opentasks skipped (already done by wizard), others initialized
+        expect(initResults).toContain("opentasks:skipped");
+        expect(initResults).toContain("minimem:init");
+        expect(initResults).toContain("sessionlog:init");
+        // All three have configs on disk
+        expect(existsSync(join(testDir, ".swarm", "opentasks", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "minimem", "config.json"))).toBe(true);
+        expect(existsSync(join(testDir, ".swarm", "sessionlog", "settings.json"))).toBe(true);
+    });
+});
+// ─── Interactive vs non-interactive produce same filesystem result ───────────
+describe("interactive vs non-interactive produce same result", async () => {
+    const opentasksOk = await hasCliInstalled("opentasks");
+    it.skipIf(!opentasksOk)("opentasks: both modes create identical config structure", async () => {
+        // Run interactive in one dir
+        const interactiveDir = join(testDir, "interactive");
+        mkdirSync(interactiveDir, { recursive: true });
+        createProject("mode-compare", interactiveDir);
+        const state1 = createEmptyState();
+        const r1 = await runPackageWizard("opentasks", { ...PACKAGES.opentasks.setup.cliWizard, args: ["init", "--name", "mode-compare"] }, state1, { cwd: interactiveDir, interactive: true });
+        expect(r1.success).toBe(true);
+        // Run non-interactive in another dir
+        const noninteractiveDir = join(testDir, "noninteractive");
+        mkdirSync(noninteractiveDir, { recursive: true });
+        createProject("mode-compare", noninteractiveDir);
+        const state2 = createEmptyState();
+        const r2 = await runPackageWizard("opentasks", { ...PACKAGES.opentasks.setup.cliWizard, args: ["init", "--name", "mode-compare"] }, state2, { cwd: noninteractiveDir, interactive: false });
+        expect(r2.success).toBe(true);
+        // Both should have the same files
+        const iConfig = JSON.parse(readFileSync(join(interactiveDir, ".opentasks", "config.json"), "utf-8"));
+        const nConfig = JSON.parse(readFileSync(join(noninteractiveDir, ".opentasks", "config.json"), "utf-8"));
+        // Same structure (different UUIDs/hashes, but same keys)
+        expect(Object.keys(iConfig).sort()).toEqual(Object.keys(nConfig).sort());
+        expect(iConfig.version).toBe(nConfig.version);
+        expect(iConfig.location.name).toBe(nConfig.location.name);
+        expect(typeof iConfig.location.hash).toBe("string");
+        expect(typeof nConfig.location.hash).toBe("string");
+        // Same files created
+        const iFiles = ["config.json", "graph.jsonl", ".gitignore"];
+        const nFiles = ["config.json", "graph.jsonl", ".gitignore"];
+        for (const f of iFiles) {
+            expect(existsSync(join(interactiveDir, ".opentasks", f))).toBe(true);
+        }
+        for (const f of nFiles) {
+            expect(existsSync(join(noninteractiveDir, ".opentasks", f))).toBe(true);
+        }
+    });
+});
+// ─── Registry: nonInteractiveArgs declarations ──────────────────────────────
+describe("registry: nonInteractiveArgs declarations", () => {
+    it("sdr has nonInteractiveArgs with template flag", () => {
+        const config = PACKAGES["self-driving-repo"].setup.cliWizard;
+        expect(config.nonInteractiveArgs).toBeDefined();
+        expect(config.nonInteractiveArgs).toContain("-t");
+        expect(config.nonInteractiveArgs).toContain("triage-only");
+    });
+    it("openhive has nonInteractiveArgs with all flags", () => {
+        const config = PACKAGES.openhive.setup.cliWizard;
+        expect(config.nonInteractiveArgs).toBeDefined();
+        expect(config.nonInteractiveArgs).toContain("--name");
+        expect(config.nonInteractiveArgs).toContain("--port");
+        expect(config.nonInteractiveArgs).toContain("--auth-mode");
+        expect(config.nonInteractiveArgs).toContain("--verification");
+    });
+    it("opentasks has no nonInteractiveArgs (already non-interactive)", () => {
+        const config = PACKAGES.opentasks.setup.cliWizard;
+        expect(config.nonInteractiveArgs).toBeUndefined();
+    });
+    it("skill-tree has no nonInteractiveArgs (already non-interactive)", () => {
+        const config = PACKAGES["skill-tree"].setup.cliWizard;
+        expect(config.nonInteractiveArgs).toBeUndefined();
+    });
+});

package/dist/commands/init/state.d.ts

@@ -1,5 +1,27 @@
+export interface PackageConfig {
+    /** Config values collected (key-value pairs matching InlineOption keys) */
+    values: Record<string, unknown>;
+    /** Whether a CLI wizard was used (vs inline prompts or defaults) */
+    usedCliWizard: boolean;
+}
+export interface IntegrationWiring {
+    /** Integration key, e.g. "claude-code-swarm:sessionlog" */
+    key: string;
+    /** Whether user enabled this integration */
+    enabled: boolean;
+    /** Config values chosen */
+    values: Record<string, unknown>;
+}
+export interface ConfigWritten {
+    /** Package name */
+    package: string;
+    /** Relative path to the config file/directory */
+    path: string;
+    /** Brief description of what was written */
+    description: string;
+}
 export interface WizardState {
-    /** Selected bundle name, or "custom" */
+    /** Selected bundle name: "all", "manual", or legacy bundle name */
     bundle: string;
     /** Packages to install */
     selectedPackages: string[];
@@ -9,5 +31,13 @@ export interface WizardState {
     apiKeys: Record<string, string>;
     /** Whether to nest project configs under .swarm/ (default true) */
     usePrefix: boolean;
+    /** Skip interactive per-package config and use defaults */
+    quick: boolean;
+    /** Per-package config choices from the interactive config phase */
+    packageConfigs: Record<string, PackageConfig>;
+    /** Integration wiring decisions */
+    integrationWiring: IntegrationWiring[];
+    /** Tracks which config files/dirs were written (for review phase) */
+    configsWritten: ConfigWritten[];
 }
 export declare function createEmptyState(): WizardState;

package/dist/commands/init/state.js

@@ -5,5 +5,9 @@ export function createEmptyState() {
         embeddingProvider: null,
         apiKeys: {},
         usePrefix: true,
+        quick: false,
+        packageConfigs: {},
+        integrationWiring: [],
+        configsWritten: [],
     };
 }

package/dist/commands/init/state.test.js

@@ -9,6 +9,10 @@ describe("WizardState", () => {
             expect(state.embeddingProvider).toBeNull();
             expect(state.apiKeys).toEqual({});
             expect(state.usePrefix).toBe(true);
+            expect(state.quick).toBe(false);
+            expect(state.packageConfigs).toEqual({});
+            expect(state.integrationWiring).toEqual([]);
+            expect(state.configsWritten).toEqual([]);
         });
         it("returns a new object each time", () => {
             const a = createEmptyState();
@@ -16,6 +20,9 @@ describe("WizardState", () => {
             expect(a).not.toBe(b);
             expect(a.selectedPackages).not.toBe(b.selectedPackages);
             expect(a.apiKeys).not.toBe(b.apiKeys);
+            expect(a.packageConfigs).not.toBe(b.packageConfigs);
+            expect(a.integrationWiring).not.toBe(b.integrationWiring);
+            expect(a.configsWritten).not.toBe(b.configsWritten);
         });
     });
 });

package/dist/commands/init/wizard.d.ts

@@ -1,5 +1,6 @@
 export interface WizardOptions {
     noPrefix?: boolean;
     forceGlobal?: boolean;
+    quick?: boolean;
 }
 export declare function runWizard(opts?: WizardOptions): Promise<void>;

package/dist/commands/init/wizard.js

@@ -2,15 +2,17 @@ import chalk from "chalk";
 import { select, confirm } from "@inquirer/prompts";
 import { isFirstRun, readConfig, writeConfig, ensureConfigDir, isConfigOutdated, getSwarmkitVersion } from "../../config/global.js";
 import * as ui from "../../utils/ui.js";
-import { getActiveIntegrations } from "../../packages/registry.js";
 import { isClaudeCliAvailable } from "../../packages/installer.js";
 import { isInstalledPlugin, registerPlugin } from "../../packages/plugin.js";
 import { createEmptyState } from "./state.js";
 import { selectUseCase } from "./phases/use-case.js";
 import { installSelectedPackages } from "./phases/packages.js";
 import { configureKeys } from "./phases/configure.js";
+import { configurePackages } from "./phases/package-config.js";
 import { initProject } from "./phases/project.js";
 import { initGlobal } from "./phases/global-setup.js";
+import { configureIntegrations, applyIntegrationWiring } from "./phases/integrations.js";
+import { showReview } from "./phases/review.js";
 export async function runWizard(opts) {
     console.log();
     console.log(`  ${chalk.bold("swarmkit")} ${chalk.dim("— multi-agent infrastructure toolkit")}`);
@@ -41,28 +43,37 @@ export async function runWizard(opts) {
 }
 async function runFirstTimeSetup(opts) {
     ensureConfigDir();
-    // Step 1: Use case / bundle selection
+    // Phase 1: Package selection (all vs manual)
     let state = await selectUseCase(createEmptyState());
     if (opts?.noPrefix) {
         state.usePrefix = false;
     }
-    // Step 2: Install packages
+    if (opts?.quick) {
+        state.quick = true;
+    }
+    // Phase 2: Install packages
     await installSelectedPackages(state);
-    // Step 2.5: Plugin activation (for any Claude Code plugins)
+    // Phase 2.5: Plugin activation (for any Claude Code plugins)
     await activatePlugins(state);
-    // Step 3: Configure (embedding provider, API keys)
+    // Phase 3: Configure (embedding provider, API keys)
     state = await configureKeys(state);
-    // Step 4: Global package setup (skill-tree, openhive)
-    await initGlobal(state);
-    // Step 5: Project init (if in a project directory)
+    // Phase 4: Per-package interactive configuration
+    state = await configurePackages(state);
+    // Phase 5: Global package setup (reads from state.packageConfigs)
+    await initGlobal(state, opts?.forceGlobal);
+    // Phase 6: Project init (reads from state.packageConfigs)
     await initProject(state);
+    // Phase 7: Integration wiring (collect user choices)
+    state = await configureIntegrations(state);
+    // Phase 7.5: Apply wiring values to config files on disk
+    applyIntegrationWiring(state);
     // Persist prefix preference and config version
     const config = readConfig();
     config.usePrefix = state.usePrefix;
     config.configVersion = getSwarmkitVersion();
     writeConfig(config);
-    // Summary
-    printSummary(state);
+    // Phase 8: Review & next steps
+    await showReview(state);
 }
 async function runProjectSetup(opts) {
     const config = readConfig();
@@ -70,7 +81,17 @@ async function runProjectSetup(opts) {
     const state = createEmptyState();
     state.selectedPackages = [...config.installedPackages];
     state.usePrefix = opts?.noPrefix === true ? false : (config.usePrefix ?? true);
+    state.quick = opts?.quick === true;
+    // Per-package config for project setup (if not quick mode)
+    if (!state.quick) {
+        const updated = await configurePackages(state);
+        Object.assign(state, updated);
+    }
     await initProject(state);
+    // Show a brief summary for project-only setup
+    if (state.configsWritten.length > 0) {
+        await showReview(state);
+    }
 }
 async function activatePlugins(state) {
     if (!(await isClaudeCliAvailable()))
@@ -111,16 +132,3 @@ async function activatePlugins(state) {
         }
     }
 }
-function printSummary(state) {
-    const integrations = getActiveIntegrations(state.selectedPackages);
-    if (integrations.length > 0) {
-        ui.heading("  Active integrations:");
-        for (const integration of integrations) {
-            const [a, b] = integration.packages;
-            ui.bullet(`  ${a} ${chalk.dim("↔")} ${b}  ${chalk.dim(integration.description)}`);
-        }
-    }
-    ui.blank();
-    console.log(`  ${chalk.green("Done.")} Run ${chalk.bold("`swarmkit status`")} to see your setup.`);
-    ui.blank();
-}

package/dist/commands/init.js

@@ -4,12 +4,14 @@ export function registerInitCommand(program) {
         .description("Interactive setup wizard")
         .option("--no-prefix", "Use flat layout (e.g. .opentasks/) instead of nesting under .swarm/")
         .option("-g, --global", "Re-run full global setup (even if already configured)")
+        .option("-q, --quick", "Skip interactive per-package config and use defaults")
         .action(async (opts) => {
         // Dynamic import to avoid loading @inquirer/prompts for other commands
         const { runWizard } = await import("./init/wizard.js");
         await runWizard({
             noPrefix: opts.prefix === false,
             forceGlobal: opts.global === true,
+            quick: opts.quick === true,
         });
     });
 }

package/dist/packages/registry.d.ts

@@ -9,6 +9,45 @@ export interface PackageDefinition {
     category: "orchestration" | "protocol" | "tasks" | "interface" | "learning" | "observability";
     /** No per-project config — global only */
     globalOnly?: boolean;
+    /** Interactive setup configuration */
+    setup?: PackageSetupConfig;
+}
+export interface PackageSetupConfig {
+    /** CLI command for the package's own interactive setup wizard */
+    cliWizard?: {
+        command: string;
+        /** Args for interactive mode (wizard takes over terminal) */
+        args: string[];
+        /**
+         * Args for non-interactive mode (no terminal prompts).
+         * Used by `--quick` flag and in test environments.
+         * Falls back to `args` if not provided.
+         */
+        nonInteractiveArgs?: string[];
+        /** Extra env vars swarmkit passes to the wizard */
+        env?: Record<string, string>;
+        /** Timeout in ms (default 120_000) */
+        timeout?: number;
+    };
+    /** Inline config options swarmkit prompts when no CLI wizard exists */
+    inlineOptions?: InlineOption[];
+}
+export interface InlineOption {
+    /** Config key path, e.g. "enabled" */
+    key: string;
+    /** Prompt message */
+    label: string;
+    /** Prompt type */
+    type: "input" | "select" | "confirm" | "password";
+    /** Default value */
+    default?: string | boolean | number;
+    /** Choices for select type */
+    choices?: Array<{
+        name: string;
+        value: string;
+    }>;
+    /** Only show if condition is met (receives selected package list) */
+    when?: (packages: string[]) => boolean;
 }
 export interface BundleDefinition {
     name: string;
@@ -16,9 +55,32 @@ export interface BundleDefinition {
     description: string;
     packages: string[];
 }
+export interface IntegrationConfigOption {
+    /** Config key */
+    key: string;
+    /** Prompt message */
+    label: string;
+    /** Prompt type */
+    type: "confirm" | "input" | "select";
+    /** Default value */
+    default?: string | boolean;
+    /** Choices for select type */
+    choices?: Array<{
+        name: string;
+        value: string;
+    }>;
+    /** Which package's config file to write into */
+    targetPackage: string;
+    /** JSON path in that package's config */
+    configPath: string;
+}
 export interface Integration {
     packages: [string, string];
     description: string;
+    /** Whether this integration requires explicit user opt-in (vs auto-detect) */
+    requiresWiring?: boolean;
+    /** Config options for wiring this integration */
+    configOptions?: IntegrationConfigOption[];
 }
 export declare const PACKAGES: Record<string, PackageDefinition>;
 export declare const BUNDLES: Record<string, BundleDefinition>;
@@ -35,3 +97,7 @@ export declare function getLostIntegrations(currentPackages: string[], removedPa
 export declare function getNpmName(registryKey: string): string;
 export declare function isKnownPackage(name: string): boolean;
 export declare function getAllPackageNames(): string[];
+/** Category display order for manual package selection */
+export declare const CATEGORY_ORDER: PackageDefinition["category"][];
+/** Human-readable category labels */
+export declare const CATEGORY_LABELS: Record<PackageDefinition["category"], string>;