akm-cli 0.7.5 → 0.8.0-rc2

package/dist/setup/setup.js

@@ -11,8 +11,9 @@ import path from "node:path";
 import * as p from "@clack/prompts";
 import { akmInit } from "../commands/init";
 import { isHttpUrl } from "../core/common";
-import { DEFAULT_CONFIG, getConfigPath, loadUserConfig, saveConfig } from "../core/config";
-import { getDefaultStashDir } from "../core/paths";
+import { DEFAULT_CONFIG, loadUserConfig, saveConfig } from "../core/config";
+import { getConfigPath, getDefaultStashDir } from "../core/paths";
+import { warn } from "../core/warn";
 import { closeDatabase, isVecAvailable, openDatabase } from "../indexer/db";
 import { akmIndex } from "../indexer/indexer";
 import { clearSemanticStatus, deriveSemanticProviderFingerprint, writeSemanticStatus, } from "../indexer/semantic-status";
@@ -337,8 +338,11 @@ async function prepareSemanticSearchAssets(config) {
     return { ok: true };
 }
 // ── Steps ───────────────────────────────────────────────────────────────────
-async function stepStashDir(current) {
-    const defaultDir = current.stashDir ?? getDefaultStashDir();
+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: [
@@ -635,7 +639,7 @@ export async function stepRegistries(current) {
  * @internal Exported for testing only.
  */
 export async function stepAddSources(current, options) {
-    const existingSources = [...(current.sources ?? current.stashes ?? [])];
+    const existingSources = [...(current.sources ?? [])];
     const sources = [];
     if (existingSources.length > 0) {
         p.note(renderConfiguredSourceList(existingSources), "Configured stash sources");
@@ -705,7 +709,7 @@ async function stepAgentPlatforms(current) {
         p.log.info("No agent platform configurations detected.");
         return [];
     }
-    const existingPaths = new Set((current.sources ?? current.stashes ?? []).map((s) => s.path));
+    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) {
@@ -734,6 +738,365 @@ async function stepAgentPlatforms(current) {
     }
     return entries;
 }
+/**
+ * Step 1/2: Configure the small model connection used for metadata and bounded LLM features.
+ *
+ * Detects Ollama automatically and pre-selects it. The user may also choose
+ * OpenAI, LM Studio, a custom endpoint, or skip the step entirely.
+ */
+export async function stepSmallModelConnection(current) {
+    p.log.step("Step 1/2: Configure your small model connection");
+    p.note([
+        "This connection is used for background processing:",
+        "  • akm index           (metadata enhancement)",
+        "  • akm distill         (lesson distillation)",
+        "  • akm remember --enrich (memory compression)",
+        "  • akm curate --rerank   (search reranking)",
+    ].join("\n"));
+    // Probe for Ollama in the background while showing the note.
+    const spin = p.spinner();
+    spin.start("Detecting local services...");
+    const ollama = await detectOllama();
+    spin.stop(ollama.available ? `Ollama detected at ${ollama.endpoint}` : "No local services detected");
+    const ollamaEndpoint = ollama.available ? ollama.endpoint : undefined;
+    const providerOptions = [];
+    if (ollama.available) {
+        providerOptions.push({
+            value: "ollama",
+            label: "Ollama (local)",
+            hint: `detected at ${ollama.endpoint}`,
+        });
+    }
+    providerOptions.push({ value: "openai", label: "OpenAI", hint: "requires AKM_LLM_API_KEY" }, { value: "lmstudio", label: "LM Studio / local server", hint: "http://localhost:1234" }, { value: "custom", label: "Custom OpenAI-compatible endpoint" }, { value: "skip", label: "Skip — disable enrichment features" });
+    if (current.llm) {
+        providerOptions.push({
+            value: "keep",
+            label: `Keep current: ${current.llm.provider ?? current.llm.endpoint}`,
+            hint: current.llm.model,
+        });
+    }
+    const initialValue = current.llm ? "keep" : ollama.available ? "ollama" : "openai";
+    const providerChoice = await prompt(() => p.select({
+        message: "Provider:",
+        options: providerOptions,
+        initialValue,
+    }));
+    if (providerChoice === "keep") {
+        return { llm: cloneLlmConfig(current.llm), skipped: false, ollamaEndpoint };
+    }
+    if (providerChoice === "skip") {
+        p.note([
+            "Enrichment features disabled:",
+            "  • akm index           — metadata enhancement disabled",
+            "  • akm distill         — lesson generation",
+            "  • akm remember --enrich",
+            "  • akm curate --rerank",
+            "",
+            "You can configure this later with `akm setup`.",
+        ].join("\n"), "Warning");
+        return { llm: undefined, skipped: true, ollamaEndpoint };
+    }
+    let llm;
+    if (providerChoice === "ollama") {
+        const ollamaChatModels = ollama.models.filter((m) => !m.includes("embed") && !m.includes("nomic") && !m.includes("minilm") && !m.includes("bge"));
+        let model;
+        if (ollamaChatModels.length > 0) {
+            model = await prompt(() => p.select({
+                message: "Model name:",
+                options: [
+                    ...ollamaChatModels.map((m) => ({ value: m, label: m })),
+                    { value: "__custom__", label: "Enter a model name manually..." },
+                ],
+                initialValue: ollamaChatModels[0],
+            }));
+            if (model === "__custom__") {
+                model = await prompt(() => p.text({
+                    message: "Model name:",
+                    placeholder: "llama3.2",
+                    validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+                }));
+            }
+        }
+        else {
+            model = await prompt(() => p.text({
+                message: "Model name (e.g. llama3.2):",
+                placeholder: "llama3.2",
+                defaultValue: "llama3.2",
+                validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+            }));
+        }
+        llm = {
+            provider: "ollama",
+            endpoint: `${ollama.endpoint}/v1/chat/completions`,
+            model: model.trim(),
+            temperature: 0.3,
+            maxTokens: 1024,
+        };
+    }
+    else if (providerChoice === "openai") {
+        const model = await prompt(() => p.text({
+            message: "Model name:",
+            placeholder: "gpt-4o-mini",
+            defaultValue: "gpt-4o-mini",
+            validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+        }));
+        if (!process.env.AKM_LLM_API_KEY) {
+            p.log.info("Set AKM_LLM_API_KEY in your shell before running `akm index`.");
+        }
+        llm = {
+            provider: "openai",
+            endpoint: "https://api.openai.com/v1/chat/completions",
+            model: model.trim() || "gpt-4o-mini",
+            temperature: 0.3,
+            maxTokens: 1024,
+        };
+    }
+    else if (providerChoice === "lmstudio") {
+        const endpoint = await prompt(() => p.text({
+            message: "Endpoint URL:",
+            placeholder: "http://localhost:1234/v1/chat/completions",
+            defaultValue: "http://localhost:1234/v1/chat/completions",
+            validate: (v) => {
+                if (!v?.trim())
+                    return "Endpoint cannot be empty";
+                if (!v.startsWith("http://") && !v.startsWith("https://"))
+                    return "Must start with http:// or https://";
+            },
+        }));
+        const model = await prompt(() => p.text({
+            message: "Model name:",
+            placeholder: "local-model",
+            validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+        }));
+        llm = {
+            provider: "lmstudio",
+            endpoint: endpoint.trim(),
+            model: model.trim(),
+            temperature: 0.3,
+            maxTokens: 1024,
+        };
+    }
+    else {
+        // custom
+        const endpoint = await prompt(() => p.text({
+            message: "OpenAI-compatible chat completions endpoint:",
+            placeholder: "https://your-host/v1/chat/completions",
+            validate: (v) => {
+                if (!v?.trim())
+                    return "Endpoint cannot be empty";
+                if (!v.startsWith("http://") && !v.startsWith("https://"))
+                    return "Must start with http:// or https://";
+            },
+        }));
+        const model = await prompt(() => p.text({
+            message: "Model name:",
+            placeholder: "gpt-4o-mini",
+            validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+        }));
+        const apiKeyInput = await promptOrBack(() => p.text({
+            message: "API key (optional — press Enter to skip):",
+            placeholder: "",
+        }));
+        llm = {
+            provider: "custom",
+            endpoint: endpoint.trim(),
+            model: model.trim(),
+            temperature: 0.3,
+            maxTokens: 1024,
+            ...(apiKeyInput?.trim() ? { apiKey: apiKeyInput.trim() } : {}),
+        };
+    }
+    // Best-effort probe — never blocks setup.
+    const probeSpin = p.spinner();
+    probeSpin.start("Probing LLM (structured-output round-trip)...");
+    const probe = await probeLlmCapabilities(llm);
+    if (probe.reachable && probe.structuredOutput) {
+        probeSpin.stop("LLM reachable; structured output verified.");
+        llm.capabilities = { ...(llm.capabilities ?? {}), structuredOutput: true };
+    }
+    else if (probe.reachable) {
+        probeSpin.stop("LLM reachable but structured-output probe failed.");
+        llm.capabilities = { ...(llm.capabilities ?? {}), structuredOutput: false };
+    }
+    else {
+        probeSpin.stop("LLM not reachable.");
+        p.log.warn(`Could not reach the LLM endpoint${probe.error ? ` (${probe.error})` : ""}. Configuration was saved; verify your endpoint and API key, then retry.`);
+    }
+    return { llm, skipped: false, ollamaEndpoint };
+}
+/**
+ * Step 2/2: Configure the agent connection used for agentic features.
+ *
+ * Options depend on whether Step 1 was completed or skipped.
+ */
+export async function stepAgentConnection(current, smallModel) {
+    p.log.step("Step 2/2: Configure your agent connection");
+    p.note([
+        "This connection is used for agentic commands:",
+        "  • akm propose   (generate improvement proposals)",
+        "  • akm reflect   (reflect on assets and generate proposals)",
+        "  • akm tasks run (run automated task prompts)",
+    ].join("\n"));
+    // Detect available CLI agents.
+    const detections = detectAgentCliProfiles(current.agent);
+    const availableClis = detections.filter((d) => d.available);
+    const agentOptions = [];
+    if (!smallModel.skipped && smallModel.llm) {
+        agentOptions.push({
+            value: "same-connection",
+            label: "Same connection, select model",
+            hint: `uses ${smallModel.llm.endpoint.replace("/v1/chat/completions", "")}`,
+        });
+    }
+    agentOptions.push({ value: "new-connection", label: "New connection (different endpoint)" });
+    if (availableClis.length > 0) {
+        agentOptions.push({
+            value: "cli-agent",
+            label: "Installed CLI agent",
+            hint: `${availableClis.map((d) => d.name).join(", ")} detected`,
+        });
+    }
+    agentOptions.push({ value: "none", label: "None — disable agentic features" });
+    if (current.agent) {
+        const currentDesc = current.agent.default
+            ? `CLI: ${current.agent.default}`
+            : current.agent.profiles?.default?.model
+                ? `SDK: ${current.agent.profiles.default.model}`
+                : "configured";
+        agentOptions.push({ value: "keep", label: `Keep current: ${currentDesc}` });
+    }
+    const initialAgentValue = current.agent
+        ? "keep"
+        : availableClis.length > 0 && smallModel.skipped
+            ? "cli-agent"
+            : !smallModel.skipped && smallModel.llm
+                ? "same-connection"
+                : availableClis.length > 0
+                    ? "cli-agent"
+                    : "none";
+    const agentChoice = await prompt(() => p.select({
+        message: "How do you want to run agent commands?",
+        options: agentOptions,
+        initialValue: initialAgentValue,
+    }));
+    if (agentChoice === "keep") {
+        return current.agent;
+    }
+    if (agentChoice === "none") {
+        p.note([
+            "Agentic features disabled:",
+            '  • akm propose — will show "no agent configured" error',
+            '  • akm reflect — will show "no agent configured" error',
+            '  • akm tasks run — will show "no agent configured" error',
+            "",
+            "You can configure this later with `akm setup`.",
+        ].join("\n"), "Warning");
+        return undefined;
+    }
+    if (agentChoice === "same-connection") {
+        if (smallModel.skipped || !smallModel.llm) {
+            p.log.warn("You skipped the small model connection. Configure one to use the same connection. Falling back to 'new connection'.");
+            // Fall through to new-connection flow
+        }
+        else {
+            const baseEndpoint = smallModel.llm.endpoint.replace("/v1/chat/completions", "");
+            p.log.info(`Endpoint: ${baseEndpoint} (from Step 1)`);
+            const agentModel = await prompt(() => p.text({
+                message: "Model to use for agent tasks (same model is fine, larger models work better):",
+                placeholder: "qwen2.5-coder:32b",
+                validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+            }));
+            const profileName = smallModel.llm.provider ?? "default";
+            return {
+                ...(current.agent ?? {}),
+                profiles: {
+                    ...(current.agent?.profiles ?? {}),
+                    [profileName]: {
+                        ...(current.agent?.profiles?.[profileName] ?? {}),
+                        sdkMode: true,
+                        model: agentModel.trim(),
+                        endpoint: smallModel.llm.endpoint,
+                    },
+                },
+                default: profileName,
+            };
+        }
+    }
+    if (agentChoice === "cli-agent") {
+        if (availableClis.length === 0) {
+            p.log.warn("No agent CLIs detected on PATH.");
+            return current.agent;
+        }
+        const initialCli = pickDefaultAgentProfile(detections, current.agent?.default) ?? availableClis[0]?.name;
+        const selectedCli = await prompt(() => p.select({
+            message: "Which CLI agent?",
+            options: availableClis.map((d) => ({
+                value: d.name,
+                label: d.name,
+                hint: d.resolvedPath ?? d.bin,
+            })),
+            initialValue: initialCli,
+        }));
+        return {
+            ...(current.agent ?? {}),
+            default: selectedCli,
+        };
+    }
+    // "new-connection" (also fall-through from "same-provider" when Step 1 was skipped)
+    const newEndpoint = await prompt(() => p.text({
+        message: "OpenAI-compatible chat completions endpoint:",
+        placeholder: "https://your-host/v1/chat/completions",
+        validate: (v) => {
+            if (!v?.trim())
+                return "Endpoint cannot be empty";
+            if (!v.startsWith("http://") && !v.startsWith("https://"))
+                return "Must start with http:// or https://";
+        },
+    }));
+    const newApiKeyInput = await promptOrBack(() => p.text({
+        message: "API key (optional — press Enter to skip):",
+        placeholder: "",
+    }));
+    const newModel = await prompt(() => p.text({
+        message: "Model name (larger is better, e.g. gpt-4o):",
+        placeholder: "gpt-4o",
+        validate: (v) => (!v?.trim() ? "Model name cannot be empty" : undefined),
+    }));
+    const customProfile = {
+        sdkMode: true,
+        endpoint: newEndpoint.trim(),
+        model: newModel.trim(),
+        ...(newApiKeyInput?.trim() ? { apiKey: newApiKeyInput.trim() } : {}),
+    };
+    return {
+        ...(current.agent ?? {}),
+        profiles: {
+            ...(current.agent?.profiles ?? {}),
+            custom: customProfile,
+        },
+        default: "custom",
+    };
+}
+/**
+ * Print a feature capability summary after both connection steps are complete.
+ */
+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 reflect, akm tasks — agent configured");
+    }
+    else {
+        lines.push("  ✗ akm propose, akm reflect, akm tasks — run `akm setup` to enable");
+    }
+    p.note(lines.join("\n"), "Feature Summary");
+}
 export async function stepAgentSelection(current, detections) {
     const available = detections.filter((d) => d.available);
     if (available.length === 0) {
@@ -832,7 +1195,10 @@ export function buildSetupSteps(options) {
             label: "Stash Directory",
             nonInteractive: true,
             async run(ctx) {
-                const stashDir = await stepStashDir(ctx.config);
+                const stashDir = await stepStashDir(ctx.config, {
+                    nonInteractive: ctx.nonInteractive,
+                    preferredDir: options.preferredStashDir,
+                });
                 ctx.apply({ stashDir });
             },
         },
@@ -922,10 +1288,17 @@ export function buildSetupSteps(options) {
     ];
     return { steps, outcome };
 }
-export async function runSetupWizard() {
+export async function runSetupWizard(opts) {
     p.intro("akm setup");
     const current = loadUserConfig();
     const configPath = getConfigPath();
+    // Resolve stash directory early so akmInit can run before any prompts
+    const resolvedStashDir = opts?.dir ? path.resolve(opts.dir) : (current.stashDir ?? getDefaultStashDir());
+    // Bootstrap directory structure before any prompts so the stash exists
+    // even if the wizard is interrupted after this point.
+    if (!opts?.noInit) {
+        await akmInit({ dir: resolvedStashDir });
+    }
     // Quick connectivity check — skip network-dependent steps when offline
     const online = await isOnline();
     if (!online) {
@@ -936,6 +1309,7 @@ export async function runSetupWizard() {
     const { steps, outcome } = buildSetupSteps({
         online,
         semanticSearchOutcome: { mode: current.semanticSearchMode, prepareAssets: false },
+        preferredStashDir: resolvedStashDir,
     });
     // Wrap each step with a `p.log.step()` header so the wizard UI is
     // unchanged. The canonical `runSetupSteps()` runner is used directly by
@@ -948,6 +1322,15 @@ export async function runSetupWizard() {
         },
     }));
     await runSetupSteps(labeledSteps, ctx);
+    // ── Two-step connection configuration ──────────────────────────────────────
+    // Step 1/2: Small model connection (for enrichment features)
+    const smallModelResult = await stepSmallModelConnection(ctx.config);
+    if (!smallModelResult.skipped) {
+        ctx.apply({ llm: smallModelResult.llm });
+    }
+    // Step 2/2: Agent connection (for agentic features)
+    const agentConfig = await stepAgentConnection(ctx.config, smallModelResult);
+    ctx.apply({ agent: agentConfig });
     const newConfig = {
         ...ctx.config,
         // Preserve fields the steps don't manage explicitly.
@@ -958,7 +1341,10 @@ export async function runSetupWizard() {
     const embedding = newConfig.embedding;
     const llm = newConfig.llm;
     const registries = newConfig.registries;
-    const allStashes = newConfig.sources ?? newConfig.stashes ?? [];
+    const allStashes = newConfig.sources ?? [];
+    // Feature capability summary
+    const agentConfigured = Boolean(agentConfig);
+    printCapabilitySummary(smallModelResult.skipped, agentConfigured);
     // Confirm before saving
     const effectiveRegistries = registries ?? DEFAULT_CONFIG.registries ?? [];
     p.note([
@@ -979,8 +1365,6 @@ export async function runSetupWizard() {
         bail();
     // Save config
     saveConfig(newConfig);
-    // Initialize stash directory
-    await akmInit({ dir: stashDir });
     if (semanticSearchMode.mode === "off") {
         clearSemanticStatus();
     }
@@ -1062,3 +1446,118 @@ export async function runSetupWizard() {
     }
     p.outro(`Configuration saved to ${configPath}`);
 }
+// ── Non-interactive / scripting entry points ─────────────────────────────────
+/**
+ * Run setup in non-interactive mode, applying all defaults.
+ * Safe to call from CI or scripts. Idempotent — re-running produces the same result.
+ */
+export async function runSetupWithDefaults(opts) {
+    const current = loadUserConfig();
+    const stashDir = opts.dir ? path.resolve(opts.dir) : (current.stashDir ?? getDefaultStashDir());
+    // Bootstrap directory structure first
+    let initResult;
+    if (!opts.noInit) {
+        initResult = await akmInit({ dir: stashDir });
+    }
+    // Run steps in non-interactive mode (applies defaults, skips prompts)
+    const ctx = createSetupContext(current, { nonInteractive: true });
+    const { steps } = buildSetupSteps({
+        online: false,
+        semanticSearchOutcome: { mode: current.semanticSearchMode, prepareAssets: false },
+        preferredStashDir: stashDir,
+    });
+    await runSetupSteps(steps, ctx);
+    // Ensure stashDir is set
+    if (!ctx.config.stashDir)
+        ctx.apply({ stashDir });
+    // Auto-detect agent CLI if not already configured
+    if (!ctx.config.agent) {
+        const detected = detectAgentCliProfiles(undefined);
+        const defaultProfile = pickDefaultAgentProfile(detected, undefined);
+        if (defaultProfile) {
+            ctx.apply({ agent: { default: defaultProfile } });
+        }
+    }
+    saveConfig(ctx.config);
+    return {
+        configPath: getConfigPath(),
+        stashDir,
+        stashCreated: initResult?.created ?? false,
+        written: true,
+        fields: Object.keys(ctx.config).filter((k) => ctx.config[k] !== undefined),
+        ripgrep: initResult?.ripgrep,
+    };
+}
+/**
+ * Apply a JSON config blob non-interactively, merging it with the current config.
+ * Validates required sub-fields and strips unknown/restricted keys.
+ */
+export async function runSetupFromConfig(opts) {
+    // Phase 1: Parse JSON
+    let incoming;
+    try {
+        incoming = JSON.parse(opts.configJson);
+    }
+    catch (e) {
+        throw new Error(`Invalid JSON in --config: ${e.message}`);
+    }
+    // Phase 2: Validate — only allow safe top-level keys
+    const ALLOWED_KEYS = new Set(["stashDir", "llm", "embedding", "agent", "semanticSearchMode", "output"]);
+    for (const key of Object.keys(incoming)) {
+        if (!ALLOWED_KEYS.has(key)) {
+            warn(`[akm setup] Ignoring unknown or restricted config key: "${key}"`);
+            delete incoming[key];
+        }
+    }
+    // Validate required sub-fields
+    if (incoming.llm) {
+        if (!incoming.llm.endpoint?.trim())
+            throw new Error("llm.endpoint is required when llm is provided");
+        if (!incoming.llm.model?.trim())
+            throw new Error("llm.model is required when llm is provided");
+    }
+    if (incoming.embedding) {
+        if (!incoming.embedding.endpoint?.trim())
+            throw new Error("embedding.endpoint is required when embedding is provided");
+        if (!incoming.embedding.model?.trim())
+            throw new Error("embedding.model is required when embedding is provided");
+    }
+    // Phase 3: Merge with existing config
+    const current = loadUserConfig();
+    const stashDir = opts.dir
+        ? path.resolve(opts.dir)
+        : incoming.stashDir
+            ? path.resolve(incoming.stashDir)
+            : (current.stashDir ?? getDefaultStashDir());
+    const merged = {
+        ...current,
+        ...incoming,
+        stashDir,
+    };
+    // Bootstrap directory structure
+    let initResult;
+    if (!opts.noInit) {
+        initResult = await akmInit({ dir: stashDir });
+    }
+    // Optional probe
+    if (opts.probe && merged.llm) {
+        try {
+            const caps = await probeLlmCapabilities(merged.llm);
+            if (caps.reachable) {
+                merged.llm = { ...merged.llm, capabilities: { structuredOutput: caps.structuredOutput ?? false } };
+            }
+        }
+        catch {
+            // Non-fatal: probe failure is informational only
+        }
+    }
+    saveConfig(merged);
+    return {
+        configPath: getConfigPath(),
+        stashDir,
+        stashCreated: initResult?.created ?? false,
+        written: true,
+        fields: Object.keys(incoming).filter((k) => incoming[k] !== undefined),
+        ripgrep: initResult?.ripgrep,
+    };
+}

package/dist/sources/provider-factory.js

@@ -9,6 +9,7 @@
  * Both share `create-provider-registry.ts` for the underlying string→factory
  * map.
  */
+import { getSources } from "../core/config";
 import { createProviderRegistry } from "../registry/create-provider-registry";
 // ── Factory map ─────────────────────────────────────────────────────────────
 const registry = createProviderRegistry();
@@ -24,7 +25,7 @@ export function resolveSourceProviderFactory(type) {
  */
 export function resolveSourceProviders(config) {
     const providers = [];
-    for (const entry of config.sources ?? config.stashes ?? []) {
+    for (const entry of getSources(config)) {
         if (entry.enabled === false)
             continue;
         const factory = registry.resolve(entry.type);

package/dist/sources/providers/git.js

@@ -4,7 +4,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { TYPE_DIRS } from "../../core/asset-spec";
 import { resolveStashDir } from "../../core/common";
-import { loadConfig } from "../../core/config";
+import { getSources, loadConfig } from "../../core/config";
 import { ConfigError, UsageError } from "../../core/errors";
 import { getRegistryCacheDir, getRegistryIndexCacheDir } from "../../core/paths";
 import { sanitizeCommitMessage } from "../../core/write-source";
@@ -407,7 +407,7 @@ export function saveGitStash(name, message, writableOverride) {
     let writable = false;
     if (name) {
         const config = loadConfig();
-        const stash = findGitStashByTarget(config.sources ?? config.stashes ?? [], name);
+        const stash = findGitStashByTarget(getSources(config), name);
         if (!stash)
             throw new UsageError(`No git stash found with name "${name}"`);
         if (!GIT_STASH_TYPES.has(stash.type)) {

package/dist/sources/website-ingest.js

@@ -167,6 +167,10 @@ async function crawlWebsite(startUrl, options) {
     return pages;
 }
 async function fetchWebsitePage(pageUrl) {
+    const parsedUrl = new URL(pageUrl);
+    if (parsedUrl.hostname.endsWith(".invalid")) {
+        throw new Error(`Refusing to fetch reserved invalid hostname: ${parsedUrl.hostname}`);
+    }
     const response = await fetchWithRetry(pageUrl, {
         headers: {
             Accept: "text/html, text/markdown, text/plain;q=0.9, application/xhtml+xml;q=0.8",