swarmkit 0.0.6 → 0.0.8

package/dist/cli.js

@@ -6,6 +6,7 @@ import { join, dirname } from "node:path";
 import { registerInitCommand } from "./commands/init.js";
 import { registerAddCommand } from "./commands/add.js";
 import { registerRemoveCommand } from "./commands/remove.js";
+import { registerConfigureCommand } from "./commands/configure.js";
 import { registerStatusCommand } from "./commands/status.js";
 import { registerUpdateCommand } from "./commands/update.js";
 import { registerDoctorCommand } from "./commands/doctor.js";
@@ -23,6 +24,7 @@ program
 registerInitCommand(program);
 registerAddCommand(program);
 registerRemoveCommand(program);
+registerConfigureCommand(program);
 registerStatusCommand(program);
 registerUpdateCommand(program);
 registerDoctorCommand(program);

package/dist/commands/configure/configure.d.ts

@@ -0,0 +1,5 @@
+export interface ConfigureOptions {
+    packageName?: string;
+    quick?: boolean;
+}
+export declare function runConfigure(opts: ConfigureOptions): Promise<void>;

package/dist/commands/configure/configure.js

@@ -0,0 +1,354 @@
+import chalk from "chalk";
+import { confirm, input, select, password } from "@inquirer/prompts";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { readConfig, isFirstRun, getConfigPath } from "../../config/global.js";
+import { PACKAGES, getActiveIntegrations, isKnownPackage, } from "../../packages/registry.js";
+import { runPackageWizard, relocateAfterWizard, projectConfigDirs, PREFIX_ENV_VARS, PROJECT_ROOT, GLOBAL_CONFIG_DIRS, } from "../../packages/setup.js";
+import { readPackageConfig, getNestedValue } from "./read-config.js";
+import { createEmptyState } from "../init/state.js";
+import * as ui from "../../utils/ui.js";
+export async function runConfigure(opts) {
+    if (isFirstRun()) {
+        ui.fail("No swarmkit config found. Run `swarmkit init` first.");
+        process.exitCode = 1;
+        return;
+    }
+    const globalConfig = readConfig();
+    if (globalConfig.installedPackages.length === 0) {
+        // Config file exists but has no packages — likely corrupted or manually emptied
+        const configPath = getConfigPath();
+        ui.fail(`Config file exists at ${configPath} but no packages are registered.`);
+        ui.info("Run `swarmkit init --global` to re-run setup, or `swarmkit doctor` to diagnose.");
+        process.exitCode = 1;
+        return;
+    }
+    console.log();
+    console.log(`  ${chalk.bold("swarmkit configure")} ${chalk.dim("— reconfigure package settings")}`);
+    console.log();
+    // Build a WizardState from existing global config
+    const state = createEmptyState();
+    state.selectedPackages = [...globalConfig.installedPackages];
+    state.usePrefix = globalConfig.usePrefix ?? true;
+    state.embeddingProvider = globalConfig.embeddingProvider ?? null;
+    state.quick = opts.quick ?? false;
+    const cwd = process.cwd();
+    // Determine which packages to configure
+    let packagesToConfig;
+    if (opts.packageName) {
+        if (!isKnownPackage(opts.packageName)) {
+            ui.fail(`Unknown package: ${opts.packageName}`);
+            process.exitCode = 1;
+            return;
+        }
+        if (!globalConfig.installedPackages.includes(opts.packageName)) {
+            ui.fail(`${opts.packageName} is not installed. Run \`swarmkit add ${opts.packageName}\` first.`);
+            process.exitCode = 1;
+            return;
+        }
+        packagesToConfig = [opts.packageName];
+    }
+    else {
+        // All installed packages that have setup config
+        packagesToConfig = state.selectedPackages.filter((pkg) => PACKAGES[pkg]?.setup);
+    }
+    if (packagesToConfig.length === 0) {
+        ui.info("No configurable packages found.");
+        return;
+    }
+    // ─── Per-package configuration ────────────────────────────────────
+    let changedPackages = [];
+    for (const pkgName of packagesToConfig) {
+        const pkg = PACKAGES[pkgName];
+        if (!pkg?.setup) {
+            ui.info(`${pkgName} has no configurable settings.`);
+            continue;
+        }
+        const setupConfig = pkg.setup;
+        const existingConfig = readPackageConfig(pkgName, cwd);
+        const config = { values: {}, usedCliWizard: false };
+        console.log();
+        console.log(`  ${chalk.bold(pkgName)}  ${chalk.dim(pkg.description)}`);
+        if (existingConfig) {
+            ui.info("Current config loaded.");
+        }
+        else {
+            ui.info("No existing config found — using defaults.");
+        }
+        // Offer CLI wizard
+        if (setupConfig.cliWizard) {
+            const useWizard = await confirm({
+                message: `Run ${pkgName}'s interactive setup wizard?`,
+                default: false,
+            });
+            if (useWizard) {
+                // Build prefix-aware env vars for project-level packages
+                const wizardConfig = { ...setupConfig.cliWizard };
+                if (state.usePrefix && PREFIX_ENV_VARS[pkgName]) {
+                    const envVar = PREFIX_ENV_VARS[pkgName];
+                    const prefixDir = PROJECT_ROOT + "/" +
+                        (pkgName === "opentasks" ? "opentasks" :
+                            pkgName === "self-driving-repo" ? "self-driving" :
+                                pkgName === "openteams" ? "openteams" :
+                                    pkgName === "cognitive-core" ? "cognitive-core" : pkgName);
+                    wizardConfig.env = {
+                        ...wizardConfig.env,
+                        [envVar]: pkgName === "cognitive-core"
+                            ? join(cwd, prefixDir)
+                            : prefixDir,
+                    };
+                }
+                const result = await runPackageWizard(pkgName, wizardConfig, state, { cwd });
+                if (result.success) {
+                    relocateAfterWizard(cwd, pkgName, state.usePrefix);
+                    config.usedCliWizard = true;
+                    ui.success(`${pkgName} wizard completed.`);
+                    state.packageConfigs[pkgName] = config;
+                    changedPackages.push(pkgName);
+                    continue;
+                }
+                else {
+                    ui.warn(`${pkgName} wizard failed: ${result.message ?? "unknown error"}`);
+                    ui.info("Falling back to inline configuration.");
+                }
+            }
+        }
+        // Inline options — show current values as defaults
+        if (setupConfig.inlineOptions && setupConfig.inlineOptions.length > 0) {
+            const customize = await confirm({
+                message: `Update ${pkgName} settings?`,
+                default: true,
+            });
+            if (customize) {
+                let changed = false;
+                for (const option of setupConfig.inlineOptions) {
+                    if (option.when && !option.when(state.selectedPackages)) {
+                        continue;
+                    }
+                    // Resolve current value from existing config
+                    const currentValue = existingConfig
+                        ? getNestedValue(existingConfig, option.key)
+                        : undefined;
+                    const effectiveDefault = currentValue ?? option.default;
+                    const value = await promptOption(option, effectiveDefault);
+                    config.values[option.key] = value;
+                    // Track if anything changed
+                    if (value !== currentValue) {
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    changedPackages.push(pkgName);
+                }
+            }
+        }
+        state.packageConfigs[pkgName] = config;
+    }
+    // ─── Apply changes ────────────────────────────────────────────────
+    if (changedPackages.length === 0) {
+        ui.blank();
+        ui.info("No changes made.");
+        return;
+    }
+    // Apply inline config overrides to existing config files
+    for (const pkgName of changedPackages) {
+        const pkgConfig = state.packageConfigs[pkgName];
+        if (!pkgConfig || pkgConfig.usedCliWizard)
+            continue;
+        if (Object.keys(pkgConfig.values).length === 0)
+            continue;
+        const applied = applyConfigUpdates(pkgName, pkgConfig, cwd, state.usePrefix);
+        if (applied) {
+            ui.success(`${pkgName} config updated.`);
+        }
+    }
+    // ─── Integration wiring ───────────────────────────────────────────
+    const activeIntegrations = getActiveIntegrations(state.selectedPackages);
+    const wirable = activeIntegrations.filter((i) => i.requiresWiring && i.configOptions && i.configOptions.length > 0);
+    if (wirable.length > 0 && !state.quick) {
+        const configureIntegrations = await confirm({
+            message: "Reconfigure integration wiring?",
+            default: false,
+        });
+        if (configureIntegrations) {
+            ui.heading("  Integration wiring");
+            for (const integration of wirable) {
+                const [a, b] = integration.packages;
+                console.log();
+                console.log(`  ${chalk.bold(a)} ${chalk.dim("↔")} ${chalk.bold(b)}`);
+                ui.info(integration.description);
+                const enable = await confirm({
+                    message: "Configure this integration?",
+                    default: true,
+                });
+                if (enable && integration.configOptions) {
+                    for (const option of integration.configOptions) {
+                        // Read current value
+                        const targetConfig = readPackageConfig(option.targetPackage, cwd);
+                        const currentValue = targetConfig
+                            ? getNestedValue(targetConfig, option.configPath)
+                            : undefined;
+                        const effectiveDefault = currentValue ?? option.default;
+                        const value = await promptIntegrationOption(option, effectiveDefault);
+                        // Write directly to the target package's config
+                        applyConfigUpdate(option.targetPackage, option.configPath, value, cwd, state.usePrefix);
+                    }
+                    ui.success(`${a} ↔ ${b} integration updated.`);
+                }
+            }
+        }
+    }
+    // ─── Summary ──────────────────────────────────────────────────────
+    ui.blank();
+    ui.heading("  Updated");
+    for (const pkg of changedPackages) {
+        const config = state.packageConfigs[pkg];
+        const suffix = config?.usedCliWizard
+            ? chalk.dim(" (via wizard)")
+            : chalk.dim(" (inline)");
+        ui.success(`${pkg}${suffix}`);
+    }
+    ui.blank();
+}
+// ─── Config file patching ─────────────────────────────────────────────────────
+/**
+ * Apply all config overrides from a PackageConfig to the package's existing
+ * config file on disk.
+ */
+function applyConfigUpdates(pkg, pkgConfig, cwd, usePrefix) {
+    const configPath = resolveConfigPath(pkg, cwd, usePrefix);
+    if (!configPath)
+        return false;
+    try {
+        const config = existsSync(configPath)
+            ? JSON.parse(readFileSync(configPath, "utf-8"))
+            : {};
+        for (const [key, value] of Object.entries(pkgConfig.values)) {
+            setNestedValue(config, key, value);
+        }
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Apply a single config key update to a package's config file.
+ */
+function applyConfigUpdate(pkg, keyPath, value, cwd, usePrefix) {
+    const configPath = resolveConfigPath(pkg, cwd, usePrefix);
+    if (!configPath)
+        return false;
+    try {
+        const config = existsSync(configPath)
+            ? JSON.parse(readFileSync(configPath, "utf-8"))
+            : {};
+        setNestedValue(config, keyPath, value);
+        writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Find the config file path for a package (project or global).
+ */
+function resolveConfigPath(pkg, cwd, usePrefix) {
+    const configDirs = projectConfigDirs(usePrefix);
+    const configFile = pkg === "sessionlog" ? "settings.json" : "config.json";
+    // Check project config first
+    const projectDir = configDirs[pkg];
+    if (projectDir) {
+        const projectPath = join(cwd, projectDir, configFile);
+        if (existsSync(projectPath))
+            return projectPath;
+    }
+    // Check global config
+    const globalDir = GLOBAL_CONFIG_DIRS[pkg];
+    if (globalDir) {
+        const globalPath = join(homedir(), globalDir, "config.json");
+        if (existsSync(globalPath))
+            return globalPath;
+    }
+    // Return project path even if it doesn't exist yet (for creation)
+    if (projectDir) {
+        return join(cwd, projectDir, configFile);
+    }
+    return null;
+}
+/**
+ * Set a dotted key path in a nested object.
+ * Coerces numeric strings to numbers.
+ */
+function setNestedValue(obj, keyPath, value) {
+    const parts = keyPath.split(".");
+    let target = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (typeof target[parts[i]] !== "object" || target[parts[i]] === null) {
+            target[parts[i]] = {};
+        }
+        target = target[parts[i]];
+    }
+    const finalKey = parts[parts.length - 1];
+    if (typeof value === "string" && /^\d+(\.\d+)?$/.test(value)) {
+        target[finalKey] = parseFloat(value);
+    }
+    else {
+        target[finalKey] = value;
+    }
+}
+// ─── Prompt helpers ───────────────────────────────────────────────────────────
+async function promptOption(option, currentDefault) {
+    const defaultValue = currentDefault ?? option.default;
+    switch (option.type) {
+        case "confirm":
+            return confirm({
+                message: option.label,
+                default: defaultValue,
+            });
+        case "select":
+            return select({
+                message: option.label,
+                choices: option.choices ?? [],
+                default: defaultValue,
+            });
+        case "input":
+            return input({
+                message: option.label,
+                default: defaultValue != null ? String(defaultValue) : undefined,
+            });
+        case "password":
+            return password({
+                message: option.label,
+                mask: "*",
+            });
+        default:
+            return defaultValue;
+    }
+}
+async function promptIntegrationOption(option, currentDefault) {
+    const defaultValue = currentDefault ?? option.default;
+    switch (option.type) {
+        case "confirm":
+            return confirm({
+                message: option.label,
+                default: defaultValue,
+            });
+        case "select":
+            return select({
+                message: option.label,
+                choices: option.choices ?? [],
+                default: defaultValue,
+            });
+        case "input":
+            return input({
+                message: option.label,
+                default: defaultValue != null ? String(defaultValue) : undefined,
+            });
+        default:
+            return defaultValue;
+    }
+}

package/dist/commands/configure/configure.test.d.ts

@@ -0,0 +1 @@
+export {};