akm-cli 0.9.0-beta.54 → 0.9.0-beta.56

package/dist/setup/steps/output.js

@@ -0,0 +1,31 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Setup wizard step: choose the default output format + detail level.
+ */
+import * as p from "../../cli/clack.js";
+import { DEFAULT_CONFIG } from "../../core/config/config.js";
+import { prompt } from "../prompt.js";
+export async function stepOutputConfig(current) {
+    const defaultOutput = current.output ?? DEFAULT_CONFIG.output ?? { format: "json", detail: "brief" };
+    const format = await prompt(() => p.select({
+        message: "Default output format?",
+        options: [
+            { value: "json", label: "json", hint: "structured default" },
+            { value: "text", label: "text", hint: "human-readable CLI output" },
+            { value: "yaml", label: "yaml", hint: "structured text" },
+        ],
+        initialValue: defaultOutput.format ?? "json",
+    }));
+    const detail = await prompt(() => p.select({
+        message: "Default output detail level?",
+        options: [
+            { value: "brief", label: "brief", hint: "compact summaries" },
+            { value: "normal", label: "normal", hint: "balanced detail" },
+            { value: "full", label: "full", hint: "max available detail" },
+        ],
+        initialValue: defaultOutput.detail ?? "brief",
+    }));
+    return { format: format, detail: detail };
+}

package/dist/setup/steps/platforms.js

@@ -0,0 +1,124 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Setup wizard steps for agent platforms and agent-CLI selection: detect
+ * agent platform config dirs as stash sources, and pick a default agent CLI.
+ */
+import * as p from "../../cli/clack.js";
+import { detectAgentCliProfiles, pickDefaultAgentProfile } from "../../integrations/agent/index.js";
+import { detectAgentPlatforms } from "../detect.js";
+import { getCurrentAgentBlock } from "../legacy-config.js";
+import { prompt } from "../prompt.js";
+export async function stepAgentPlatforms(current) {
+    const platforms = detectAgentPlatforms();
+    if (platforms.length === 0) {
+        p.log.info("No agent platform configurations detected.");
+        return [];
+    }
+    const existingPaths = new Set((current.sources ?? []).map((s) => s.path));
+    // Filter out platforms already configured
+    const newPlatforms = platforms.filter((pl) => !existingPaths.has(pl.path));
+    if (newPlatforms.length === 0) {
+        p.log.info(`Detected ${platforms.length} agent platform(s), all already configured as stash sources.`);
+        return [];
+    }
+    const selected = await prompt(() => p.multiselect({
+        message: "Found agent platform configurations. Add as stash sources?",
+        options: newPlatforms.map((pl) => ({
+            value: pl.path,
+            label: pl.name,
+            hint: pl.path,
+        })),
+        required: false,
+    }));
+    const entries = [];
+    for (const selectedPath of selected) {
+        const platform = newPlatforms.find((pl) => pl.path === selectedPath);
+        if (platform) {
+            entries.push({
+                type: "filesystem",
+                path: platform.path,
+                name: platform.name.toLowerCase().replace(/\s+/g, "-"),
+            });
+        }
+    }
+    return entries;
+}
+/**
+ * Print a feature capability summary after both connection steps are complete.
+ */
+export function printCapabilitySummary(smallModelSkipped, agentConfigured) {
+    const lines = ["Setup complete. Here's what's enabled:", ""];
+    lines.push("  ✓ akm search, akm curate, akm show — always available");
+    if (!smallModelSkipped) {
+        lines.push("  ✓ akm index, akm distill, akm remember — small model configured");
+    }
+    else {
+        lines.push("  ✗ akm index, akm distill, akm remember — run `akm setup` to enable");
+    }
+    if (agentConfigured) {
+        lines.push("  ✓ akm propose, akm improve, akm tasks — agent configured");
+    }
+    else {
+        lines.push("  ✗ akm propose, akm improve, akm tasks — run `akm setup` to enable");
+    }
+    p.note(lines.join("\n"), "Feature Summary");
+}
+export async function stepAgentSelection(current, detections) {
+    const currentAgentBlock = getCurrentAgentBlock(current);
+    const available = detections.filter((d) => d.available);
+    if (available.length === 0) {
+        return currentAgentBlock;
+    }
+    const initialValue = pickDefaultAgentProfile(detections, currentAgentBlock?.default) ?? available[0]?.name;
+    const selectedDefault = await prompt(() => p.select({
+        message: "Which detected agent CLI should be the default?",
+        options: [
+            ...available.map((d) => ({
+                value: d.name,
+                label: d.name,
+                hint: d.resolvedPath ?? d.bin,
+            })),
+            { value: "disabled", label: "Disabled", hint: "do not configure a default agent CLI" },
+        ],
+        initialValue,
+    }));
+    if (selectedDefault === "disabled") {
+        if (!currentAgentBlock?.profiles && !currentAgentBlock?.timeoutMs) {
+            return undefined;
+        }
+        return {
+            ...(currentAgentBlock ?? {}),
+            default: undefined,
+        };
+    }
+    return {
+        ...(currentAgentBlock ?? {}),
+        default: selectedDefault,
+    };
+}
+/**
+ * Detect installed agent CLIs and produce an updated `agent` config block
+ * with a sensible `default` (the first detected profile that the user has
+ * not already overridden).
+ *
+ * Pure-ish: file system / PATH probes are routed through `detectFn` so
+ * tests can drive the branches without touching the real PATH.
+ *
+ * @internal Exported for testing only.
+ */
+export function stepAgentCliDetection(current, detectFn = detectAgentCliProfiles) {
+    const detections = detectFn(current);
+    const currentAgentBlock = getCurrentAgentBlock(current);
+    const defaultName = pickDefaultAgentProfile(detections, currentAgentBlock?.default);
+    // No installed agents found and no existing config → leave block absent.
+    if (!defaultName && !currentAgentBlock) {
+        return { detections };
+    }
+    const agent = {
+        ...(currentAgentBlock ?? {}),
+        ...(defaultName ? { default: defaultName } : {}),
+    };
+    return { agent, detections };
+}

package/dist/setup/steps/semantic.js

@@ -0,0 +1,27 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Setup wizard step: enable/disable semantic search and decide whether to
+ * prepare its assets now.
+ */
+import * as p from "../../cli/clack.js";
+import { prompt } from "../prompt.js";
+import { describeSemanticSearchAssets, isRemoteEmbeddingConfig } from "../semantic-assets.js";
+export async function stepSemanticSearch(current, embedding) {
+    const enabled = await prompt(() => p.confirm({
+        message: "Enable semantic search?",
+        initialValue: current.semanticSearchMode !== "off",
+    }));
+    if (!enabled) {
+        return { mode: "off", prepareAssets: false };
+    }
+    p.note(describeSemanticSearchAssets(embedding).join("\n"), "Semantic Search Assets");
+    const prepareAssets = await prompt(() => p.confirm({
+        message: isRemoteEmbeddingConfig(embedding)
+            ? "Check the embedding endpoint and verify semantic search now?"
+            : "Download and verify semantic-search assets now?",
+        initialValue: true,
+    }));
+    return { mode: "auto", prepareAssets };
+}

package/dist/setup/steps/sources.js

@@ -0,0 +1,222 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Setup wizard steps for stash sources and registries: toggle configured
+ * sources, pull registry-recommended stashes, add custom sources, and toggle
+ * built-in registries.
+ */
+import * as p from "../../cli/clack.js";
+import { DEFAULT_CONFIG, getEffectiveRegistries } from "../../core/config/config.js";
+import { prompt, promptOrBack } from "../prompt.js";
+import { loadSetupStashes } from "../registry-stash-loader.js";
+function configuredSourceKey(source) {
+    return `${source.type}:${source.path ?? source.url ?? source.name ?? "unknown"}`;
+}
+function describeConfiguredSource(source) {
+    const target = source.path ?? source.url ?? "(unknown target)";
+    const typeLabel = source.type === "git" ? "Git" : source.type === "filesystem" ? "Filesystem" : source.type;
+    return {
+        value: configuredSourceKey(source),
+        label: source.name ?? target,
+        hint: `${typeLabel}: ${target}`,
+    };
+}
+function renderConfiguredSourceList(sources) {
+    return sources
+        .map((source) => {
+        const described = describeConfiguredSource(source);
+        return `- ${described.label} (${described.hint})`;
+    })
+        .join("\n");
+}
+function renderInstalledSourceList(installed) {
+    return installed.map((entry) => `- ${entry.id} (${entry.source})`).join("\n");
+}
+export async function stepAdditionalSources(currentSources) {
+    const sources = [...currentSources];
+    let addMore = true;
+    while (addMore) {
+        const action = await prompt(() => p.select({
+            message: "Add another stash source?",
+            options: [
+                { value: "done", label: "Done — no more sources" },
+                { value: "github-repo", label: "GitHub repository", hint: "custom URL" },
+                { value: "filesystem", label: "Filesystem path", hint: "local directory" },
+            ],
+            initialValue: "done",
+        }));
+        if (action === "done") {
+            addMore = false;
+            break;
+        }
+        if (action === "github-repo") {
+            const url = await promptOrBack(() => p.text({
+                message: "Enter the GitHub repository URL:",
+                placeholder: "https://github.com/owner/repo",
+                validate: (v) => {
+                    if (!v?.trim())
+                        return "URL cannot be empty";
+                },
+            }));
+            if (url === null)
+                continue;
+            const name = await promptOrBack(() => p.text({
+                message: "Give this stash a name (optional):",
+                placeholder: "my-repo",
+            }));
+            if (name === null)
+                continue;
+            const entry = { type: "git", url: url.trim() };
+            if (name.trim())
+                entry.name = name.trim();
+            if (!sources.some((s) => s.url === entry.url)) {
+                sources.push(entry);
+            }
+            else {
+                p.log.warn("This URL is already configured.");
+            }
+        }
+        if (action === "filesystem") {
+            const fsPath = await promptOrBack(() => p.text({
+                message: "Enter the directory path:",
+                placeholder: "/path/to/stash",
+                validate: (v) => {
+                    if (!v?.trim())
+                        return "Path cannot be empty";
+                },
+            }));
+            if (fsPath === null)
+                continue;
+            const resolved = fsPath.trim();
+            const name = await promptOrBack(() => p.text({
+                message: "Give this stash a name (optional):",
+                placeholder: "my-stash",
+            }));
+            if (name === null)
+                continue;
+            const entry = { type: "filesystem", path: resolved };
+            if (name.trim())
+                entry.name = name.trim();
+            if (!sources.some((s) => s.path === entry.path)) {
+                sources.push(entry);
+            }
+            else {
+                p.log.warn("This path is already configured.");
+            }
+        }
+    }
+    return sources;
+}
+export async function stepRegistries(current) {
+    const defaults = DEFAULT_CONFIG.registries ?? [];
+    const currentRegistries = current.registries ?? defaults;
+    const defaultUrls = new Set(defaults.map((r) => r.url));
+    const enabledUrls = new Set(currentRegistries.filter((r) => r.enabled !== false).map((r) => r.url));
+    // Collect custom (non-default) registries to preserve them
+    const customRegistries = currentRegistries.filter((r) => !defaultUrls.has(r.url));
+    // Show default registries for toggling
+    const options = defaults.map((r) => ({
+        value: r.url,
+        label: r.name ?? r.url,
+        hint: r.provider ?? "static index",
+    }));
+    if (customRegistries.length > 0) {
+        p.log.info(`You have ${customRegistries.length} custom registr${customRegistries.length === 1 ? "y" : "ies"} that will be preserved.`);
+    }
+    const selected = await prompt(() => p.multiselect({
+        message: "Which built-in registries should be enabled?",
+        options,
+        initialValues: options.filter((o) => enabledUrls.has(o.value)).map((o) => o.value),
+    }));
+    // If all defaults are selected and there are no custom registries,
+    // return undefined to use the built-in defaults (avoids pinning)
+    const allDefaultsSelected = defaults.every((r) => selected.includes(r.url));
+    if (allDefaultsSelected && customRegistries.length === 0) {
+        return undefined;
+    }
+    // Build explicit list: toggled defaults + preserved custom registries
+    const result = defaults.map((r) => ({
+        ...r,
+        enabled: selected.includes(r.url),
+    }));
+    // Re-add custom registries unchanged
+    for (const custom of customRegistries) {
+        result.push(custom);
+    }
+    return result;
+}
+/**
+ * @internal Exported for testing only.
+ */
+export async function stepAddSources(current, options) {
+    const existingSources = [...(current.sources ?? [])];
+    const sources = [];
+    if (existingSources.length > 0) {
+        p.note(renderConfiguredSourceList(existingSources), "Configured stash sources");
+        const options = existingSources.map(describeConfiguredSource);
+        const selected = await prompt(() => p.multiselect({
+            message: "Configured stash sources — uncheck any you want to disable:",
+            options,
+            initialValues: options.map((option) => option.value),
+            required: false,
+        }));
+        for (const source of existingSources) {
+            if (selected.includes(configuredSourceKey(source))) {
+                sources.push(source);
+            }
+        }
+    }
+    if ((current.installed?.length ?? 0) > 0) {
+        p.note(renderInstalledSourceList(current.installed ?? []), "Installed managed stashes (preserved)");
+    }
+    // ── Registry-driven stash recommendations ─────────────────────────────
+    // Fetch available stashes from the official registry (cached, stale-ok).
+    // Falls back to the bundled list when the registry is unreachable.
+    const registryUrl = getEffectiveRegistries(current)[0]?.url ??
+        "https://raw.githubusercontent.com/itlackey/akm-registry/main/index.json";
+    const availableStashes = await loadSetupStashes(registryUrl);
+    if (availableStashes.length > 0) {
+        const existingUrls = new Set(sources.map((s) => s.url));
+        const stashOptions = availableStashes.map((s) => ({
+            value: s.url,
+            label: s.name,
+            hint: existingUrls.has(s.url) ? `${s.description} (already added)` : s.description || s.source,
+        }));
+        // Pre-check: already-installed stashes OR default-selected on fresh install
+        const initialValues = sources.length > 0
+            ? stashOptions.filter((o) => existingUrls.has(o.value)).map((o) => o.value)
+            : availableStashes.filter((s) => s.defaultSelected).map((s) => s.url);
+        const selectedUrls = await prompt(() => p.multiselect({
+            message: availableStashes[0]?.source === "registry"
+                ? "Available stashes from the AKM registry — toggle to add or remove:"
+                : "Recommended stash sources — toggle to add or remove:",
+            options: stashOptions,
+            initialValues,
+            required: false,
+        }));
+        // Add newly selected stashes
+        for (const url of selectedUrls) {
+            if (!existingUrls.has(url)) {
+                const entry = availableStashes.find((s) => s.url === url);
+                sources.push({ type: "git", url, name: entry?.name });
+                existingUrls.add(url);
+            }
+        }
+        // Remove deselected stashes that were previously configured
+        for (const entry of availableStashes) {
+            if (existingUrls.has(entry.url) && !selectedUrls.includes(entry.url)) {
+                const idx = sources.findIndex((s) => s.url === entry.url);
+                if (idx !== -1) {
+                    sources.splice(idx, 1);
+                    existingUrls.delete(entry.url);
+                    p.log.info(`Removed ${entry.name}.`);
+                }
+            }
+        }
+    }
+    if (options?.promptForAdditional === false) {
+        return sources;
+    }
+    return stepAdditionalSources(sources);
+}

package/dist/setup/steps/stashdir.js

@@ -0,0 +1,42 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Setup wizard step: choose where akm stores its stash (skills, commands,
+ * and other assets).
+ */
+import * as p from "../../cli/clack.js";
+import { assertSafeStashDir, getDefaultStashDir } from "../../core/paths.js";
+import { prompt } from "../prompt.js";
+export async function stepStashDir(current, options) {
+    const defaultDir = options?.preferredDir ?? current.stashDir ?? getDefaultStashDir();
+    if (options?.nonInteractive) {
+        return defaultDir;
+    }
+    const choice = await prompt(() => p.select({
+        message: "Where should akm store skills, commands, and other assets?",
+        options: [
+            { value: "default", label: defaultDir, hint: current.stashDir ? "current" : "default" },
+            { value: "custom", label: "Enter a custom path..." },
+        ],
+    }));
+    if (choice === "default")
+        return defaultDir;
+    const customPath = await prompt(() => p.text({
+        message: "Enter the stash directory path:",
+        placeholder: defaultDir,
+        validate: (v) => {
+            if (!v?.trim())
+                return "Path cannot be empty";
+            try {
+                assertSafeStashDir(v.trim());
+            }
+            catch (err) {
+                if (err instanceof Error)
+                    return err.message;
+                return "Refused: unsafe stash directory";
+            }
+        },
+    }));
+    return customPath.trim();
+}

package/dist/setup/steps/tasks.js

@@ -0,0 +1,152 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Setup wizard steps: register the default improve task set and enable/disable
+ * scheduled core tasks.
+ */
+import * as p from "../../cli/clack.js";
+import { detectServerDefault, isCiEnvironment, registerDefaultTasks } from "../../commands/tasks/default-tasks.js";
+import { akmTasksAdd, akmTasksList, akmTasksSetEnabled, akmTasksSync } from "../../commands/tasks/tasks.js";
+import { saveGitStash } from "../../sources/providers/git.js";
+import { backendNameForPlatform } from "../../tasks/backends/index.js";
+import { listEmbeddedTasks } from "../../tasks/embedded.js";
+import { parseSchedule } from "../../tasks/schedule.js";
+import { prompt } from "../prompt.js";
+/**
+ * Normalise a task id the same way `akm tasks` does (strip a trailing `.yml`
+ * / `.md` suffix, trim) so the wizard can match embedded template ids against
+ * the ids reported by `akmTasksList()`.
+ */
+function normaliseTaskIdForMatch(raw) {
+    return raw.trim().replace(/\.(yml|md)$/, "");
+}
+/**
+ * Setup sub-step (issue #552): idempotently register the default improve task
+ * set. Asks a single "Is this a server install?" question (defaulting per
+ * platform) to decide whether the nightly sweep is enabled, then delegates to
+ * {@link registerDefaultTasks}, which is CI-aware and never duplicates an
+ * existing task. Skipped entirely under CI (the registration helper short-
+ * circuits, and we never even prompt).
+ *
+ * Exported for testing.
+ */
+export async function stepDefaultImproveTasks(register = registerDefaultTasks) {
+    // CI: register nothing and don't prompt.
+    if (isCiEnvironment()) {
+        p.log.info("CI detected — skipping default improve task registration.");
+        return;
+    }
+    const platformDefault = detectServerDefault();
+    const serverInstall = await prompt(() => p.confirm({
+        message: "Is this a server install? (enables the nightly quality sweep at 2am)",
+        initialValue: platformDefault,
+    }));
+    const result = await register({ serverInstall: serverInstall === true });
+    if (result.skipped)
+        return;
+    const total = result.created.length + result.existing.length;
+    p.log.success(`Default improve tasks registered (${result.created.length} new, ${result.existing.length} already present, ${total} total).`);
+}
+const DEFAULT_SCHEDULED_TASKS_DEPS = {
+    list: akmTasksList,
+    add: akmTasksAdd,
+    setEnabled: akmTasksSetEnabled,
+    sync: akmTasksSync,
+    gitSync: saveGitStash,
+};
+export async function stepScheduledTasks(deps = DEFAULT_SCHEDULED_TASKS_DEPS) {
+    const embedded = listEmbeddedTasks();
+    if (embedded.length === 0)
+        return;
+    // Snapshot current state so we can diff against the user's selection.
+    let installed = [];
+    try {
+        installed = (await deps.list()).tasks;
+    }
+    catch {
+        // A missing/empty tasks dir is fine — treat as nothing installed.
+        installed = [];
+    }
+    const byId = new Map();
+    for (const t of installed)
+        byId.set(normaliseTaskIdForMatch(t.id), t);
+    // Pre-check tasks that are installed AND enabled.
+    const preChecked = embedded.filter((e) => byId.get(e.id)?.enabled === true).map((e) => e.id);
+    const stateLabel = (e) => {
+        const cur = byId.get(e.id);
+        if (!cur)
+            return "not installed";
+        return cur.enabled ? "enabled" : "disabled";
+    };
+    const selected = await prompt(() => p.multiselect({
+        message: "Enable scheduled core tasks? (space to toggle, enter to confirm)",
+        required: false,
+        initialValues: preChecked,
+        options: embedded.map((e) => ({
+            value: e.id,
+            label: e.label,
+            hint: `${e.description} — ${e.schedule} [${stateLabel(e)}]`,
+        })),
+    }));
+    const selectedSet = new Set(selected);
+    // Resolve per-task schedule edits for newly-checked, not-yet-installed tasks.
+    const scheduleFor = new Map();
+    for (const e of embedded) {
+        const cur = byId.get(e.id);
+        if (selectedSet.has(e.id) && !cur) {
+            const edited = await prompt(() => p.text({
+                message: `Schedule for ${e.label}?`,
+                initialValue: e.schedule,
+                validate(value) {
+                    const candidate = (value ?? "").trim() || e.schedule;
+                    try {
+                        parseSchedule(candidate, backendNameForPlatform());
+                    }
+                    catch (err) {
+                        return err instanceof Error ? err.message : "Invalid schedule.";
+                    }
+                    return undefined;
+                },
+            }));
+            const sched = (edited ?? "").trim() || e.schedule;
+            scheduleFor.set(e.id, sched);
+        }
+    }
+    let syncNeeded = false;
+    for (const e of embedded) {
+        const cur = byId.get(e.id);
+        const checked = selectedSet.has(e.id);
+        if (checked && !cur) {
+            // New task: copy template into the primary stash + install scheduler entry.
+            const schedule = scheduleFor.get(e.id) ?? e.schedule;
+            await deps.add({
+                id: e.id,
+                schedule,
+                command: e.command,
+                description: e.description,
+            });
+            syncNeeded = true;
+        }
+        else if (checked && cur && !cur.enabled) {
+            // Present but disabled → re-enable.
+            await deps.setEnabled(e.id, true);
+        }
+        else if (!checked && cur?.enabled) {
+            // Previously enabled, now unchecked → disable (keep the stash file).
+            await deps.setEnabled(e.id, false);
+        }
+        // No state change → no action.
+    }
+    if (syncNeeded) {
+        // Reconcile scheduler entries with on-disk YAML, then commit the new file
+        // to git (a no-op for non-git stashes).
+        await deps.sync();
+        try {
+            deps.gitSync(undefined, "akm setup: enable scheduled tasks");
+        }
+        catch {
+            // Non-fatal — the task is installed regardless of git sync outcome.
+        }
+    }
+}