umbrella-context 0.1.37 → 0.1.39

package/dist/config.d.ts

@@ -24,6 +24,9 @@ export interface HubRegistry {
     id: string;
     name: string;
     url: string;
+    authScheme?: "none" | "bearer" | "token" | "basic" | "custom-header";
+    token?: string;
+    headerName?: string;
     updatedAt: string;
 }
 export interface StoredCliState {
@@ -47,6 +50,7 @@ export declare class ConfigManager {
     get locations(): SavedLocation[];
     get providers(): SavedProvider[];
     upsertLocation(location: SavedLocation): void;
+    replaceLocations(locations: SavedLocation[]): void;
     upsertProvider(provider: SavedProvider): void;
     removeProvider(id: string): void;
     get configPath(): string;

package/dist/config.js

@@ -87,6 +87,11 @@ export class ConfigManager {
         locations.push(location);
         this.conf.set("locations", locations.sort((a, b) => a.repoRoot.localeCompare(b.repoRoot)));
     }
+    replaceLocations(locations) {
+        this.conf.set("locations", locations
+            .slice()
+            .sort((a, b) => a.repoRoot.localeCompare(b.repoRoot)));
+    }
     upsertProvider(provider) {
         const providers = this.providers.filter((entry) => entry.id !== provider.id && entry.name.toLowerCase() !== provider.name.toLowerCase());
         providers.push(provider);
@@ -115,6 +120,7 @@ export class ConfigManager {
                 id: "umbrella-default",
                 name: "Umbrella Hub",
                 url: "https://hub.umbrella.local/default",
+                authScheme: "none",
                 updatedAt: new Date(0).toISOString(),
             },
         ];

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { cac } from "cac";
+import { readFileSync } from "node:fs";
 import { setupCommand } from "./commands/setup.js";
 import { loginCommand } from "./commands/login.js";
 import { connectCommand } from "./commands/connect.js";
@@ -29,6 +30,16 @@ import { treeCommand } from "./commands/tree.js";
 import { transportCommand } from "./commands/transport.js";
 import { bridgeCommand } from "./commands/bridge.js";
 import { curateViewCommandAction } from "./commands/curate.js";
+function readCliVersion() {
+    try {
+        const packageJsonUrl = new URL("../package.json", import.meta.url);
+        const packageJson = JSON.parse(readFileSync(packageJsonUrl, "utf8"));
+        return packageJson.version ?? "0.0.0";
+    }
+    catch {
+        return "0.0.0";
+    }
+}
 const cli = cac("umbrella-context");
 cli.option("--config <path>", "Path to config file");
 import { seedCommand } from "./commands/seed.js";
@@ -61,12 +72,19 @@ tasksCommand(cli);
 treeCommand(cli);
 transportCommand(cli);
 bridgeCommand(cli);
-cli.command("query [...args]", "Alias for search").action(async (args) => {
+cli
+    .command("query [...args]", `Alias for search
+
+Ask a natural-language question about your codebase or saved team context.`)
+    .option("--format <format>", "Output format (text or json)")
+    .example('query "How does authentication work?"')
+    .example('query "How does auth work?" --format json')
+    .action(async (args, opts) => {
     const { searchCommandAction } = await import("./commands/search.js");
-    await searchCommandAction(args.join(" "));
+    await searchCommandAction(args.join(" "), opts);
 });
 cli.help();
-cli.version("0.1.37");
+cli.version(readCliVersion());
 const argv = process.argv.slice(2);
 if (argv[0] === "curate" && argv[1] === "view" && argv.length === 2) {
     await curateViewCommandAction();

package/dist/repo-state.d.ts

@@ -3,10 +3,49 @@ export type LocalMemoryEntry = {
     id: string;
     content: string;
     tags: string[];
+    keywords: string[];
+    category: string | null;
+    accessLevel: "space" | "company";
     systemType: string;
     source: string;
     createdAt: string;
 };
+export type LocalQueryCacheEntry = {
+    id: string;
+    query: string;
+    normalizedQuery: string;
+    fingerprint: string;
+    payload: {
+        companyName: string;
+        spaceName: string;
+        query: string;
+        localMatches: LocalMemoryEntry[];
+        serverMatches: Array<Record<string, unknown>>;
+        total: number;
+        suggestions: string[];
+        providerReady?: boolean;
+        providerRequiredForSynthesis?: boolean;
+        directAnswer?: {
+            summary: string;
+            details: string;
+            sources: string[];
+            confidence: "high" | "medium";
+            gaps?: string;
+        } | null;
+        synthesizedAnswer?: {
+            summary: string;
+            details: string;
+            sources: string[];
+            confidence: "high" | "medium";
+            gaps?: string;
+            provider?: string;
+            model?: string;
+        } | null;
+    };
+    createdAt: string;
+    updatedAt: string;
+    hits: number;
+};
 export type LocalFixEntry = {
     id: string;
     errorSignal: string;
@@ -219,6 +258,81 @@ export declare function getRepoContext(cwd?: string): Promise<{
 export declare function updateRepoContext(updater: (current: RepoContextState) => RepoContextState | Promise<RepoContextState>, cwd?: string): Promise<RepoContextState>;
 export declare function addPendingMemory(input: Omit<LocalMemoryEntry, "createdAt" | "id">, cwd?: string): Promise<LocalMemoryEntry>;
 export declare function getPendingMemories(cwd?: string): Promise<LocalMemoryEntry[]>;
+export declare function getQueryCacheEntries(cwd?: string): Promise<{
+    payload: {
+        localMatches: LocalMemoryEntry[];
+        serverMatches: Record<string, unknown>[];
+        suggestions: string[];
+        providerReady: boolean;
+        providerRequiredForSynthesis: boolean;
+        directAnswer: {
+            summary: string;
+            details: string;
+            sources: string[];
+            confidence: "high" | "medium";
+            gaps?: string;
+        } | null;
+        synthesizedAnswer: {
+            summary: string;
+            details: string;
+            sources: string[];
+            confidence: "high" | "medium";
+            gaps?: string;
+            provider?: string;
+            model?: string;
+        } | null;
+        total: number;
+        companyName: string;
+        spaceName: string;
+        query: string;
+    };
+    hits: number;
+    createdAt: string;
+    updatedAt: string;
+    id: string;
+    query: string;
+    normalizedQuery: string;
+    fingerprint: string;
+}[]>;
+export declare function getQueryCacheEntry(query: string, fingerprint: string, cwd?: string): Promise<{
+    payload: {
+        localMatches: LocalMemoryEntry[];
+        serverMatches: Record<string, unknown>[];
+        suggestions: string[];
+        providerReady: boolean;
+        providerRequiredForSynthesis: boolean;
+        directAnswer: {
+            summary: string;
+            details: string;
+            sources: string[];
+            confidence: "high" | "medium";
+            gaps?: string;
+        } | null;
+        synthesizedAnswer: {
+            summary: string;
+            details: string;
+            sources: string[];
+            confidence: "high" | "medium";
+            gaps?: string;
+            provider?: string;
+            model?: string;
+        } | null;
+        total: number;
+        companyName: string;
+        spaceName: string;
+        query: string;
+    };
+    hits: number;
+    createdAt: string;
+    updatedAt: string;
+    id: string;
+    query: string;
+    normalizedQuery: string;
+    fingerprint: string;
+} | null>;
+export declare function buildLocalQueryFingerprint(cwd?: string): Promise<string>;
+export declare function storeQueryCacheEntry(input: Omit<LocalQueryCacheEntry, "createdAt" | "hits" | "id" | "updatedAt">, cwd?: string): Promise<void>;
+export declare function markQueryCacheHit(entryId: string, cwd?: string): Promise<void>;
 export declare function clearPendingMemories(cwd?: string): Promise<void>;
 export declare function resetRepoState(cwd?: string): Promise<{
     repoRoot: string;
@@ -260,6 +374,7 @@ export declare function appendTaskStreamingContent(taskId: string, content: stri
 export declare function addTaskReasoningContent(taskId: string, content: string, isThinking?: boolean, cwd?: string): Promise<LocalTask | null>;
 export declare function addTaskToolCall(taskId: string, toolCall: TaskToolCallPatch, cwd?: string): Promise<LocalTask | null>;
 export declare function completeTask(taskId: string, status: "completed" | "failed", detail?: string | null, cwd?: string): Promise<LocalTask | null>;
+export declare function removeTask(taskId: string, cwd?: string): Promise<void>;
 export declare function addConnectorRun(input: Omit<LocalConnectorRun, "id" | "ranAt">, cwd?: string): Promise<LocalConnectorRun>;
 export declare function writeConnectorRunReport(run: LocalConnectorRun, cwd?: string): Promise<string>;
 export declare function getSessionState(cwd?: string): Promise<RepoSessionState | null>;

package/dist/repo-state.js

@@ -1,6 +1,6 @@
 import { promises as fs } from "fs";
 import path from "path";
-import { randomUUID } from "crypto";
+import { createHash, randomUUID } from "crypto";
 import { execFileSync } from "child_process";
 import { configManager } from "./config.js";
 const UM_DIR = ".um";
@@ -15,9 +15,42 @@ const SESSION_FILE = "session.json";
 const TASKS_FILE = "tasks.json";
 const TRANSPORT_FILE = "transport.json";
 const CONTEXT_TREE_STATE_FILE = "context-tree.json";
+const QUERY_CACHE_FILE = "query-cache.json";
 const HUB_ASSETS_DIR = "hub";
 const CONNECTOR_ASSETS_DIR = "connectors";
 const CONNECTOR_RUN_REPORTS_DIR = "connector-runs";
+const SESSION_PANEL_ALIASES = {
+    connect: "setup",
+    fix: "activity",
+    login: "setup",
+    projects: "spaces",
+    pull: "home",
+    push: "home",
+    query: "home",
+    record: "activity",
+    search: "home",
+    space: "spaces",
+};
+function normalizeSessionPanel(panel) {
+    if (!panel)
+        return null;
+    return SESSION_PANEL_ALIASES[panel] ?? panel;
+}
+function normalizeLocalMemoryEntry(entry) {
+    return {
+        ...entry,
+        tags: entry.tags ?? [],
+        keywords: entry.keywords ?? [],
+        category: entry.category ?? null,
+        accessLevel: entry.accessLevel ?? "space",
+        systemType: entry.systemType ?? "system1_knowledge",
+        source: entry.source ?? "cli",
+        createdAt: entry.createdAt ?? new Date().toISOString(),
+    };
+}
+function normalizeLocalMemoryEntries(entries) {
+    return entries.map((entry) => normalizeLocalMemoryEntry(entry));
+}
 function normalizeSessionState(state) {
     if (!state)
         return null;
@@ -27,14 +60,19 @@ function normalizeSessionState(state) {
         recentQueries: state.recentQueries ?? [],
         recentCurations: state.recentCurations ?? [],
         lastSummary: state.lastSummary ?? null,
-        currentPanel: state.currentPanel ?? null,
+        currentPanel: normalizeSessionPanel(state.currentPanel ?? null),
         currentFocus: state.currentFocus ?? null,
-        panelHistory: state.panelHistory ?? [],
+        panelHistory: (state.panelHistory ?? [])
+            .map((panel) => normalizeSessionPanel(panel))
+            .filter((panel) => Boolean(panel)),
         recentProviderIds: state.recentProviderIds ?? [],
         recentModels: state.recentModels ?? [],
         recentHubSlugs: state.recentHubSlugs ?? [],
         recentConnectorSources: state.recentConnectorSources ?? [],
-        events: state.events ?? [],
+        events: (state.events ?? []).map((event) => ({
+            ...event,
+            panel: normalizeSessionPanel(event.panel ?? null),
+        })),
     };
 }
 function normalizeTransportState(state) {
@@ -191,6 +229,9 @@ function getTransportFile(repoRoot) {
 function getContextTreeStateFile(repoRoot) {
     return path.join(getUmDir(repoRoot), CONTEXT_TREE_STATE_FILE);
 }
+function getQueryCacheFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), QUERY_CACHE_FILE);
+}
 async function ensureUmDir(repoRoot) {
     await fs.mkdir(getUmDir(repoRoot), { recursive: true });
 }
@@ -303,6 +344,9 @@ export async function addPendingMemory(input, cwd = process.cwd()) {
         id: randomUUID(),
         createdAt: new Date().toISOString(),
         ...input,
+        keywords: input.keywords ?? [],
+        category: input.category ?? null,
+        accessLevel: input.accessLevel ?? "space",
     };
     current.push(entry);
     await writeJsonFile(getPendingMemoriesFile(repoRoot), current);
@@ -315,7 +359,95 @@ export async function addPendingMemory(input, cwd = process.cwd()) {
 }
 export async function getPendingMemories(cwd = process.cwd()) {
     const { repoRoot } = await getRepoContext(cwd);
-    return readJsonFile(getPendingMemoriesFile(repoRoot), []);
+    const entries = await readJsonFile(getPendingMemoriesFile(repoRoot), []);
+    return normalizeLocalMemoryEntries(entries);
+}
+function normalizeQueryCacheEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        payload: {
+            ...entry.payload,
+            localMatches: normalizeLocalMemoryEntries(entry.payload.localMatches ?? []),
+            serverMatches: entry.payload.serverMatches ?? [],
+            suggestions: entry.payload.suggestions ?? [],
+            providerReady: entry.payload.providerReady ?? false,
+            providerRequiredForSynthesis: entry.payload.providerRequiredForSynthesis ?? false,
+            directAnswer: entry.payload.directAnswer ?? null,
+            synthesizedAnswer: entry.payload.synthesizedAnswer ?? null,
+            total: entry.payload.total ??
+                (entry.payload.localMatches?.length ?? 0) + (entry.payload.serverMatches?.length ?? 0),
+        },
+        hits: entry.hits ?? 0,
+        createdAt: entry.createdAt ?? new Date().toISOString(),
+        updatedAt: entry.updatedAt ?? new Date().toISOString(),
+    }));
+}
+export async function getQueryCacheEntries(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const entries = await readJsonFile(getQueryCacheFile(repoRoot), []);
+    return normalizeQueryCacheEntries(entries);
+}
+export async function getQueryCacheEntry(query, fingerprint, cwd = process.cwd()) {
+    const normalizedQuery = query.trim().toLowerCase();
+    const entries = await getQueryCacheEntries(cwd);
+    return (entries.find((entry) => entry.normalizedQuery === normalizedQuery && entry.fingerprint === fingerprint) ?? null);
+}
+export async function buildLocalQueryFingerprint(cwd = process.cwd()) {
+    const [pending, pulled] = await Promise.all([getPendingMemories(cwd), getPulledMemories(cwd)]);
+    const stablePayload = [...pending, ...pulled]
+        .map((entry) => ({
+        id: entry.id,
+        content: entry.content,
+        tags: [...entry.tags].sort(),
+        keywords: [...(entry.keywords ?? [])].sort(),
+        category: entry.category ?? null,
+        accessLevel: entry.accessLevel ?? "space",
+        source: entry.source,
+        systemType: entry.systemType,
+        createdAt: entry.createdAt,
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id));
+    return createHash("sha1")
+        .update(JSON.stringify(stablePayload))
+        .digest("hex");
+}
+export async function storeQueryCacheEntry(input, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    const entries = await getQueryCacheEntries(cwd);
+    const now = new Date().toISOString();
+    const existing = entries.find((entry) => entry.normalizedQuery === input.normalizedQuery && entry.fingerprint === input.fingerprint);
+    const nextEntries = existing
+        ? entries.map((entry) => entry.id === existing.id
+            ? {
+                ...entry,
+                query: input.query,
+                payload: input.payload,
+                updatedAt: now,
+            }
+            : entry)
+        : [
+            {
+                id: randomUUID(),
+                createdAt: now,
+                updatedAt: now,
+                hits: 0,
+                ...input,
+            },
+            ...entries,
+        ];
+    await writeJsonFile(getQueryCacheFile(repoRoot), nextEntries.slice(0, 50));
+}
+export async function markQueryCacheHit(entryId, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const entries = await getQueryCacheEntries(cwd);
+    await writeJsonFile(getQueryCacheFile(repoRoot), entries.map((entry) => entry.id === entryId
+        ? {
+            ...entry,
+            hits: (entry.hits ?? 0) + 1,
+            updatedAt: new Date().toISOString(),
+        }
+        : entry));
 }
 export async function clearPendingMemories(cwd = process.cwd()) {
     const { repoRoot } = await getRepoContext(cwd);
@@ -401,7 +533,7 @@ export async function resetRepoState(cwd = process.cwd()) {
 export async function setPulledMemories(memories, cwd = process.cwd()) {
     const { repoRoot } = await getRepoContext(cwd);
     await ensureUmDir(repoRoot);
-    await writeJsonFile(getPulledMemoriesFile(repoRoot), memories);
+    await writeJsonFile(getPulledMemoriesFile(repoRoot), normalizeLocalMemoryEntries(memories));
     await updateRepoContext((state) => ({
         ...state,
         updatedAt: new Date().toISOString(),
@@ -419,7 +551,8 @@ export async function setPulledMemories(memories, cwd = process.cwd()) {
 }
 export async function getPulledMemories(cwd = process.cwd()) {
     const { repoRoot } = await getRepoContext(cwd);
-    return readJsonFile(getPulledMemoriesFile(repoRoot), []);
+    const entries = await readJsonFile(getPulledMemoriesFile(repoRoot), []);
+    return normalizeLocalMemoryEntries(entries);
 }
 export async function setPulledFixes(fixes, cwd = process.cwd()) {
     const { repoRoot } = await getRepoContext(cwd);
@@ -867,6 +1000,14 @@ export async function completeTask(taskId, status, detail, cwd = process.cwd())
         result: detail ?? null,
     }, cwd);
 }
+export async function removeTask(taskId, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const tasks = await readJsonFile(getTasksFile(repoRoot), []);
+    const nextTasks = tasks.filter((task) => task.id !== taskId);
+    await writeJsonFile(getTasksFile(repoRoot), nextTasks);
+    await syncTransportFromTasks(cwd);
+    await rebuildContextTreeState(cwd);
+}
 export async function addConnectorRun(input, cwd = process.cwd()) {
     const { repoRoot } = await getRepoContext(cwd);
     await ensureUmDir(repoRoot);
@@ -1024,13 +1165,14 @@ export async function setSessionSummary(summary, cwd = process.cwd()) {
     }), cwd);
 }
 export async function setSessionPanel(panel, focus, cwd = process.cwd()) {
+    const normalizedPanel = normalizeSessionPanel(panel);
     return updateSessionState((state) => ({
         ...state,
         updatedAt: new Date().toISOString(),
-        currentPanel: panel,
+        currentPanel: normalizedPanel,
         currentFocus: focus ?? null,
-        panelHistory: panel
-            ? [panel, ...(state.panelHistory ?? []).filter((entry) => entry !== panel)].slice(0, 10)
+        panelHistory: normalizedPanel
+            ? [normalizedPanel, ...(state.panelHistory ?? []).filter((entry) => entry !== normalizedPanel)].slice(0, 10)
             : (state.panelHistory ?? []),
     }), cwd);
 }
@@ -1080,8 +1222,49 @@ export function summarizeLocalMemoryMatches(entries, query) {
     const needle = query.trim().toLowerCase();
     if (!needle)
         return [];
+    const normalizedWords = needle
+        .replace(/[?!.:,;()[\]{}]/g, " ")
+        .split(/\s+/)
+        .map((word) => word.trim())
+        .filter(Boolean)
+        .filter((word) => !new Set([
+        "a",
+        "an",
+        "and",
+        "are",
+        "do",
+        "does",
+        "how",
+        "implemented",
+        "is",
+        "the",
+        "what",
+        "where",
+        "why",
+    ]).has(word));
+    const synonymMap = {
+        auth: ["authentication", "signin", "sign-in", "jwt", "token", "cookie", "cookies"],
+        authentication: ["auth", "signin", "sign-in", "jwt", "token", "cookie", "cookies"],
+        rate: ["throttle", "limit", "limits", "limiting"],
+        limits: ["limit", "rate", "throttle", "limiting"],
+    };
     return entries.filter((entry) => {
-        const haystack = [entry.content, ...entry.tags].join(" ").toLowerCase();
-        return haystack.includes(needle);
+        const haystack = [entry.content, ...entry.tags, ...(entry.keywords ?? [])]
+            .join(" ")
+            .toLowerCase();
+        if (haystack.includes(needle))
+            return true;
+        let matchedWords = 0;
+        for (const word of normalizedWords) {
+            const variants = [word, ...(synonymMap[word] ?? [])];
+            if (variants.some((variant) => haystack.includes(variant))) {
+                matchedWords += 1;
+            }
+        }
+        if (normalizedWords.length === 0)
+            return false;
+        if (normalizedWords.length === 1)
+            return matchedWords >= 1;
+        return matchedWords >= Math.min(2, normalizedWords.length);
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umbrella-context",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "description": "Umbrella Context CLI for connecting a device to company context spaces, querying saved context, and syncing MCP access.",
   "type": "module",
   "bin": {
@@ -27,7 +27,7 @@
     "conf": "^13.1.0",
     "ink": "^5.2.1",
     "ink-spinner": "^5.0.0",
-    "ink-text-input": "^5.0.1",
+    "ink-text-input": "^6.0.0",
     "prompts": "^2.4.2",
     "react": "^18.3.1",
     "zod": "^3.25.76",