umbrella-context 0.1.39 → 0.1.41

package/dist/commands/source.js

@@ -0,0 +1,152 @@
+import chalk from "chalk";
+import { addKnowledgeSource, listKnowledgeSources, recordSessionEvent, removeKnowledgeSource, setSessionPanel, } from "../repo-state.js";
+import { ensureSwarmConfigForLinkedSources } from "../swarm/runtime.js";
+function asOutputFormat(value) {
+    return value === "json" ? "json" : "text";
+}
+function normalizeCliPathInput(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+export async function sourceAddCommandAction(targetPath, opts = {}) {
+    const format = asOutputFormat(opts.format);
+    const normalizedTargetPath = normalizeCliPathInput(targetPath ?? "");
+    if (!normalizedTargetPath) {
+        const message = 'Type a repo path after "umbrella-context source add".';
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "source.add", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(message));
+        return;
+    }
+    try {
+        await setSessionPanel("session", "source-add");
+        const result = await addKnowledgeSource(normalizedTargetPath, { alias: opts.alias });
+        const swarmBootstrap = await ensureSwarmConfigForLinkedSources();
+        await recordSessionEvent({
+            kind: "session",
+            title: "Added a knowledge source",
+            detail: swarmBootstrap.created
+                ? `${result.message} Swarm was also bootstrapped so cross-repo search is live right away.`
+                : result.message,
+            panel: "session",
+            focus: "source-add",
+            status: "success",
+        });
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "source.add", ...result, swarmBootstrap }, null, 2));
+            return;
+        }
+        console.log(chalk.green(`\n ${result.message}`));
+        if (swarmBootstrap.created) {
+            console.log(chalk.gray(" Swarm is now ready too, so this source can show up in cross-repo search immediately."));
+        }
+        else if (swarmBootstrap.ready) {
+            console.log(chalk.gray(" Swarm was already ready, so this source can be searched right away."));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "source.add", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export async function sourceListCommandAction(opts = {}) {
+    const format = asOutputFormat(opts.format);
+    try {
+        await setSessionPanel("session", "source-list");
+        const sources = await listKnowledgeSources();
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "source.list", sources }, null, 2));
+            return;
+        }
+        console.log(chalk.bold("\n Knowledge Sources\n"));
+        if (sources.length === 0) {
+            console.log(chalk.yellow("No read-only knowledge sources are linked yet."));
+            return;
+        }
+        sources.forEach((source) => {
+            console.log(`- ${source.alias} -> ${source.projectRoot} ${source.valid ? chalk.green("(valid)") : chalk.red("(broken)")}`);
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "source.list", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export async function sourceRemoveCommandAction(aliasOrPath, opts = {}) {
+    const format = asOutputFormat(opts.format);
+    const normalizedAliasOrPath = normalizeCliPathInput(aliasOrPath ?? "");
+    if (!normalizedAliasOrPath) {
+        const message = 'Type a source alias or path after "umbrella-context source remove".';
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "source.remove", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(message));
+        return;
+    }
+    try {
+        await setSessionPanel("session", "source-remove");
+        const result = await removeKnowledgeSource(normalizedAliasOrPath);
+        await recordSessionEvent({
+            kind: "session",
+            title: "Removed a knowledge source",
+            detail: result.message,
+            panel: "session",
+            focus: "source-remove",
+            status: "success",
+        });
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "source.remove", ...result }, null, 2));
+            return;
+        }
+        console.log(chalk.green(`\n ${result.message}`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "source.remove", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export function sourceCommand(cli) {
+    cli
+        .command("source <action> [...value]", "Manage read-only knowledge sources from other Umbrella repos")
+        .example('source add "C:\\Shared Repo" --alias shared')
+        .example("source list")
+        .example("source remove shared")
+        .option("--alias <alias>", "Friendly source alias")
+        .option("--format <format>", "Output format (text or json)")
+        .action(async (action, value = [], opts) => {
+        const normalized = action.trim().toLowerCase();
+        const joinedValue = value.join(" ").trim();
+        if (normalized === "add") {
+            await sourceAddCommandAction(joinedValue, opts);
+            return;
+        }
+        if (normalized === "list") {
+            await sourceListCommandAction(opts);
+            return;
+        }
+        if (normalized === "remove") {
+            await sourceRemoveCommandAction(joinedValue, opts);
+            return;
+        }
+        console.log(chalk.red("Use one of: source add <path>, source list, source remove <alias-or-path>"));
+    });
+}

package/dist/commands/status.d.ts

@@ -29,6 +29,11 @@ export type StatusSnapshot = {
     transportQueue: number;
     transportActiveTask: string;
     contextTreeSummary: string;
+    worktreeMode: "direct" | "linked";
+    worktreeCount: number;
+    sourceCount: number;
+    adaptiveEntryCount: number;
+    adaptiveTopTitle: string;
     warnings: string[];
     nextSteps: string[];
 };

package/dist/commands/status.js

@@ -1,10 +1,11 @@
 import chalk from "chalk";
 import { promises as fs } from "fs";
 import path from "path";
+import { getAdaptiveKnowledgeSummary } from "../adaptive/runtime.js";
 import { formatUmbrellaAuthStatus } from "../auth-state.js";
 import { getStoredUmbrellaAuthSnapshot } from "../adapters/umbrella-auth-runtime.js";
 import { configManager } from "../config.js";
-import { getConnectorRuns, getContextTreeState, getInstalledConnectors, getInstalledHubEntries, getPendingMemories, getPulledFixes, getPulledMemories, getRepoContext, ensureSessionState, getTransportState, } from "../repo-state.js";
+import { getConnectorRuns, getContextTreeState, getInstalledConnectors, getInstalledHubEntries, getRepoResolution, getPendingMemories, getPulledFixes, getPulledMemories, getRepoContext, listKnowledgeSources, listRegisteredWorktrees, ensureSessionState, getTransportState, } from "../repo-state.js";
 export function buildConnectionPresentation(config, authSnapshot = getStoredUmbrellaAuthSnapshot()) {
     const warnings = [];
     const connectionMode = authSnapshot.status === "authorized"
@@ -27,7 +28,7 @@ export function buildConnectionPresentation(config, authSnapshot = getStoredUmbr
             const backend = new URL(config.serverUrl);
             const umbrellaIsLoopback = ["127.0.0.1", "localhost"].includes(umbrella.hostname.toLowerCase());
             const backendIsLoopback = ["127.0.0.1", "localhost"].includes(backend.hostname.toLowerCase());
-            if (umbrella.hostname !== backend.hostname || umbrella.port !== backend.port) {
+            if (umbrella.hostname !== backend.hostname) {
                 warnings.push(`The saved Umbrella app URL (${config.umbrellaUrl}) and Context backend URL (${config.serverUrl}) point to different places.`);
             }
             if (umbrellaIsLoopback !== backendIsLoopback) {
@@ -53,7 +54,7 @@ export async function getStatusSnapshot() {
     const { repoRoot, state, umDir } = await getRepoContext();
     const session = await ensureSessionState();
     const latestEvent = session.events?.[0] ?? null;
-    const [pending, pulledMemories, pulledFixes, connectors, hubEntries, connectorRuns, transport, contextTree] = await Promise.all([
+    const [pending, pulledMemories, pulledFixes, connectors, hubEntries, connectorRuns, transport, contextTree, repoResolution, worktrees, sources, adaptive] = await Promise.all([
         getPendingMemories(),
         getPulledMemories(),
         getPulledFixes(),
@@ -62,6 +63,10 @@ export async function getStatusSnapshot() {
         getConnectorRuns(),
         getTransportState(),
         getContextTreeState(),
+        getRepoResolution(),
+        listRegisteredWorktrees(),
+        listKnowledgeSources(),
+        getAdaptiveKnowledgeSummary(),
     ]);
     const activeProvider = configManager.providers.find((entry) => entry.id === config.activeProvider) ?? null;
     const latestConnectorRun = connectorRuns[0] ?? null;
@@ -86,6 +91,8 @@ export async function getStatusSnapshot() {
         nextSteps.push('Add a first repo connector with "umbrella-context connectors install".');
     if (hubEntries.length === 0)
         nextSteps.push('Browse reusable bundles with "umbrella-context hub list".');
+    if (sources.length === 0)
+        nextSteps.push('Link another Umbrella repo with "umbrella-context source add <path>" if you want cross-project knowledge.');
     const connection = buildConnectionPresentation(config);
     if (connection.connectionMode === "saved_local_config") {
         nextSteps.unshift('Re-run "umbrella-context setup" to verify the live Umbrella connection before trusting the saved company and space.');
@@ -121,6 +128,11 @@ export async function getStatusSnapshot() {
         transportQueue: transport?.queue.length ?? 0,
         transportActiveTask: transport?.activeTaskId ?? "None",
         contextTreeSummary: contextTree?.summaryHandle ?? "No context tree summary yet",
+        worktreeMode: repoResolution.mode,
+        worktreeCount: worktrees.length,
+        sourceCount: sources.length,
+        adaptiveEntryCount: adaptive.entryCount,
+        adaptiveTopTitle: adaptive.hottestEntries[0]?.title ?? "None yet",
         warnings: connection.warnings,
         nextSteps,
     };
@@ -173,6 +185,9 @@ export async function statusCommandAction(opts = {}) {
         `${snapshot.pendingCount} pending draft${snapshot.pendingCount === 1 ? "" : "s"}`,
         `${snapshot.pulledContextCount} pulled note${snapshot.pulledContextCount === 1 ? "" : "s"}`,
         `${snapshot.pulledFixCount} pulled known fix${snapshot.pulledFixCount === 1 ? "" : "es"}`,
+        `${snapshot.worktreeCount} registered worktree${snapshot.worktreeCount === 1 ? "" : "s"} (${snapshot.worktreeMode})`,
+        `${snapshot.sourceCount} linked knowledge source${snapshot.sourceCount === 1 ? "" : "s"}`,
+        `${snapshot.adaptiveEntryCount} adaptive abstract${snapshot.adaptiveEntryCount === 1 ? "" : "s"} (top: ${snapshot.adaptiveTopTitle})`,
         `Last push: ${snapshot.lastPushAt}`,
         `Last pull: ${snapshot.lastPullAt}`,
     ]);

package/dist/commands/swarm.d.ts

@@ -0,0 +1,16 @@
+type OutputFormat = "json" | "text";
+export declare function swarmOnboardCommandAction(format?: OutputFormat): Promise<void>;
+export declare function swarmStatusCommandAction(format?: OutputFormat): Promise<void>;
+export declare function swarmQueryCommandAction(query: string, opts?: {
+    explain?: boolean;
+    format?: string;
+    maxResults?: number;
+    provider?: string;
+    timeout?: number;
+}): Promise<void>;
+export declare function swarmCurateCommandAction(content: string, opts?: {
+    format?: string;
+    provider?: string;
+}): Promise<void>;
+export declare function swarmCommand(cli: any): void;
+export {};

package/dist/commands/swarm.js

@@ -0,0 +1,211 @@
+import chalk from "chalk";
+import { executeSwarmCurate, executeSwarmQuery, formatSwarmQueryText, getSwarmStatus, runSwarmOnboardWizard, } from "../swarm/runtime.js";
+import { recordSessionEvent, setSessionPanel } from "../repo-state.js";
+function asOutputFormat(value) {
+    return value === "json" ? "json" : "text";
+}
+export async function swarmOnboardCommandAction(format = "text") {
+    try {
+        await setSessionPanel("session", "swarm-onboard");
+        const result = await runSwarmOnboardWizard();
+        await recordSessionEvent({
+            kind: "session",
+            title: "Configured swarm",
+            detail: `Swarm config was written to ${result.configPath}.`,
+            panel: "session",
+            focus: "swarm-onboard",
+            status: "success",
+        });
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "swarm.onboard", ...result }, null, 2));
+            return;
+        }
+        console.log(chalk.green("\n Swarm is configured for this repo."));
+        console.log(chalk.gray(` Config file: ${result.configPath}`));
+        console.log(chalk.gray(' Next step: run "umbrella-context swarm status" to verify provider health.'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "swarm.onboard", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export async function swarmStatusCommandAction(format = "text") {
+    try {
+        await setSessionPanel("session", "swarm-status");
+        const result = await getSwarmStatus();
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "swarm.status", ...result }, null, 2));
+            return;
+        }
+        console.log(chalk.bold("\n Swarm Status\n"));
+        console.log(` Configured: ${result.configured ? "Yes" : "No"}`);
+        console.log(` Config file: ${result.configPath}`);
+        console.log("");
+        if (!result.configured) {
+            result.suggestions.forEach((suggestion) => console.log(chalk.yellow(` - ${suggestion}`)));
+            return;
+        }
+        console.log(chalk.bold(" Providers"));
+        result.providers.forEach((provider) => {
+            const state = provider.available ? chalk.green("healthy") : chalk.red("missing");
+            const write = provider.writable ? "write" : "read-only";
+            console.log(` - ${provider.label} [${provider.type}] -> ${state} -> ${write}`);
+            console.log(chalk.gray(`   ${provider.detail}`));
+        });
+        if (result.enrichmentEdges.length > 0) {
+            console.log("");
+            console.log(chalk.bold(" Enrichment"));
+            result.enrichmentEdges.forEach((edge) => console.log(` - ${edge.from} -> ${edge.to}`));
+        }
+        if (result.suggestions.length > 0) {
+            console.log("");
+            console.log(chalk.bold(" Suggestions"));
+            result.suggestions.forEach((suggestion) => console.log(chalk.yellow(` - ${suggestion}`)));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "swarm.status", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export async function swarmQueryCommandAction(query, opts = {}) {
+    const format = asOutputFormat(opts.format);
+    if (!query.trim()) {
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "swarm.query", error: "Type a query after swarm query." }, null, 2));
+            return;
+        }
+        console.log(chalk.red('Type a question after "umbrella-context swarm query".'));
+        return;
+    }
+    try {
+        await setSessionPanel("session", `swarm-query:${query}`);
+        const queryPromise = executeSwarmQuery(query, {
+            explain: Boolean(opts.explain),
+            format,
+            maxResults: typeof opts.maxResults === "number" ? opts.maxResults : undefined,
+            provider: opts.provider,
+        });
+        const timeoutSeconds = Math.max(1, Math.min(3600, Number(opts.timeout ?? 300)));
+        const result = await Promise.race([
+            queryPromise,
+            new Promise((_, reject) => {
+                setTimeout(() => reject(new Error(`Swarm query timed out after ${timeoutSeconds} seconds.`)), timeoutSeconds * 1000);
+            }),
+        ]);
+        await recordSessionEvent({
+            kind: "query",
+            title: `Ran swarm query "${query}"`,
+            detail: `Swarm returned ${result.results.length} merged result${result.results.length === 1 ? "" : "s"}.`,
+            panel: "session",
+            focus: "swarm-query",
+            status: "success",
+        });
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "swarm.query", ...result }, null, 2));
+            return;
+        }
+        console.log(formatSwarmQueryText(result, { explain: Boolean(opts.explain) }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "swarm.query", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export async function swarmCurateCommandAction(content, opts = {}) {
+    const format = asOutputFormat(opts.format);
+    if (!content.trim()) {
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "swarm.curate", error: "Type content after swarm curate." }, null, 2));
+            return;
+        }
+        console.log(chalk.red('Type content after "umbrella-context swarm curate".'));
+        return;
+    }
+    try {
+        await setSessionPanel("session", "swarm-curate");
+        const result = await executeSwarmCurate(content, { provider: opts.provider });
+        await recordSessionEvent({
+            kind: "curate",
+            title: `Stored content through swarm`,
+            detail: `Swarm stored content in ${result.provider}${result.fallback ? " using fallback routing" : ""}.`,
+            panel: "session",
+            focus: "swarm-curate",
+            status: "success",
+        });
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "swarm.curate", ...result }, null, 2));
+            return;
+        }
+        console.log(chalk.green(`\n Stored through swarm in ${result.provider}.`));
+        console.log(chalk.gray(` Target type: ${result.targetType}`));
+        if (result.id) {
+            console.log(chalk.gray(` Saved as: ${result.id}`));
+        }
+        if (result.fallback) {
+            console.log(chalk.yellow(" Swarm fell back to Umbrella Context because no other writable provider was ready."));
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "swarm.curate", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export function swarmCommand(cli) {
+    cli
+        .command("swarm <action> [...rest]", "Swarm commands for searching and saving across multiple knowledge tools")
+        .example("swarm onboard")
+        .example("swarm status")
+        .example('swarm query "How do auth cookies refresh?" --explain')
+        .example('swarm curate "JWT refresh token notes"')
+        .option("--format <format>", "Output format (text or json)")
+        .option("--explain", "Show provider selection and enrichment details for swarm query")
+        .option("--max-results <n>", "Maximum number of merged hits to return for swarm query")
+        .option("--timeout <seconds>", "Maximum seconds to wait before a swarm query times out")
+        .option("--provider <provider>", "Force a specific swarm provider")
+        .action(async (action, rest = [], opts) => {
+        const normalized = action.trim().toLowerCase();
+        if (normalized === "onboard") {
+            await swarmOnboardCommandAction(asOutputFormat(opts.format));
+            return;
+        }
+        if (normalized === "status") {
+            await swarmStatusCommandAction(asOutputFormat(opts.format));
+            return;
+        }
+        if (normalized === "query") {
+            await swarmQueryCommandAction(rest.join(" "), {
+                explain: Boolean(opts.explain),
+                format: opts.format,
+                maxResults: opts.maxResults ? Number(opts.maxResults) : undefined,
+                provider: opts.provider,
+                timeout: opts.timeout ? Number(opts.timeout) : undefined,
+            });
+            return;
+        }
+        if (normalized === "curate") {
+            await swarmCurateCommandAction(rest.join(" "), {
+                format: opts.format,
+                provider: opts.provider,
+            });
+            return;
+        }
+        console.log(chalk.red('Use one of: swarm onboard, swarm status, swarm query "<question>", swarm curate "<content>"'));
+    });
+}