umbrella-context 0.1.37 → 0.1.38

package/README.md

@@ -14,10 +14,17 @@ Or install it inside the current project:
 npm i umbrella-context
 ```
 
-For local testing from a tarball:
+For local testing from a tarball built from this repo:
 
 ```bash
-npm install -g ./umbrella-context-0.1.1.tgz
+pnpm pack:umbrella-context:local
+npm install -g ./.artifacts/umbrella-context-local/umbrella-context-<version>.tgz
+```
+
+If you want to pack it and launch the packed copy immediately without publishing:
+
+```bash
+pnpm run:umbrella-context:local
 ```
 
 ## First-time setup

package/dist/adapters/umbrella-onboarding.js

@@ -1,5 +1,5 @@
 import { configManager } from "../config.js";
-import { ensureRepoContext } from "../repo-state.js";
+import { ensureRepoContext, findRepoRoot } from "../repo-state.js";
 import { createContextSpace, createUmbrellaCompany, getCliSetup, getCompanyContextSummary, getUmbrellaHealth, listUmbrellaCompanies, signInToUmbrella, toContextSpaces, } from "../umbrella.js";
 export function normalizeUmbrellaServerUrl(value) {
     return value.trim().replace(/\/+$/, "");
@@ -50,6 +50,7 @@ export async function createUmbrellaOnboardingSpace(serverUrl, companyId, name,
     };
 }
 export async function saveUmbrellaDeviceLink(setup, umbrellaUrl, cwd = process.cwd()) {
+    const repoRoot = await findRepoRoot(cwd);
     configManager.set({
         umbrellaUrl,
         serverUrl: setup.baseUrl,
@@ -62,7 +63,7 @@ export async function saveUmbrellaDeviceLink(setup, umbrellaUrl, cwd = process.c
         apiKey: setup.apiKey,
     });
     configManager.upsertLocation({
-        repoRoot: cwd,
+        repoRoot,
         companyId: setup.companyId,
         companyName: setup.companyName,
         projectId: setup.activeSpaceId,

package/dist/commands/connect.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { configManager } from "../config.js";
-import { ensureRepoContext } from "../repo-state.js";
+import { ensureRepoContext, findRepoRoot } from "../repo-state.js";
 export function connectCommand(cli) {
     cli
         .command("connect", "Connect this device directly to a company context space without the interactive setup flow")
@@ -29,6 +29,7 @@ export function connectCommand(cli) {
             return;
         }
         try {
+            const repoRoot = await findRepoRoot(process.cwd());
             const res = await fetch(`${serverUrl}/api/memories?limit=1`, {
                 headers: {
                     Authorization: `Bearer ${apiKey}`,
@@ -51,7 +52,7 @@ export function connectCommand(cli) {
                 apiKey,
             });
             configManager.upsertLocation({
-                repoRoot: process.cwd(),
+                repoRoot,
                 companyId,
                 companyName,
                 projectId: spaceId,

package/dist/commands/connectors.js

@@ -130,6 +130,9 @@ async function applyConnectorRunEffects(entry, cwd = process.cwd()) {
         const staged = await addPendingMemory({
             content: "Slack growth hook captured a reusable campaign note. Replace this placeholder with the real signal before pushing.",
             tags: ["slack", "growth", "draft"],
+            keywords: ["slack", "growth", "campaign"],
+            category: "team",
+            accessLevel: "space",
             systemType: "connector_capture",
             source: "slack-growth-hook",
         }, cwd);

package/dist/commands/curate.d.ts

@@ -1,6 +1,18 @@
+type OutputFormat = "text" | "json";
+type CurateViewStatus = "pending";
 export declare function curateCommandAction(content: string, opts?: {
+    format?: OutputFormat;
     tag?: string | string[];
     type?: string;
 }): Promise<void>;
-export declare function curateViewCommandAction(): Promise<void>;
+export declare function curateViewCommandAction(opts?: {
+    before?: string;
+    detail?: boolean;
+    format?: OutputFormat;
+    id?: string;
+    limit?: number;
+    since?: string;
+    status?: CurateViewStatus | CurateViewStatus[];
+}): Promise<void>;
 export declare function curateCommand(cli: any): void;
+export {};

package/dist/commands/curate.js

@@ -1,14 +1,78 @@
 import chalk from "chalk";
 import { configManager } from "../config.js";
 import { addPendingMemory, completeTask, createTask, ensureRepoContext, getPendingMemories, getRepoContext, recordSessionCuration, recordSessionEvent, setSessionPanel, } from "../repo-state.js";
+const RELATIVE_TIME_PATTERN = /^(\d+)(m|h|d|w)$/;
+function printCurateResult(format, payload) {
+    if (format === "json") {
+        console.log(JSON.stringify(payload, null, 2));
+    }
+}
+function parseTimeFilter(value) {
+    if (!value?.trim())
+        return null;
+    const relative = RELATIVE_TIME_PATTERN.exec(value.trim());
+    if (relative) {
+        const amount = Number(relative[1]);
+        const unit = relative[2];
+        const multipliers = {
+            m: 60_000,
+            h: 3_600_000,
+            d: 86_400_000,
+            w: 604_800_000,
+        };
+        return Date.now() - amount * multipliers[unit];
+    }
+    const timestamp = new Date(value).getTime();
+    return Number.isNaN(timestamp) ? null : timestamp;
+}
+function normalizeStatuses(status) {
+    if (!status)
+        return ["pending"];
+    return Array.isArray(status) ? status : [status];
+}
+function filterCurations(entries, opts) {
+    const after = parseTimeFilter(opts.since);
+    const before = parseTimeFilter(opts.before);
+    const statuses = normalizeStatuses(opts.status);
+    if ((opts.since && after === null) || (opts.before && before === null)) {
+        return {
+            error: 'Invalid time filter. Use ISO date (2026-04-07 or 2026-04-07T09:30:00Z) or relative time like "1h", "24h", "7d", or "2w".',
+            filtered: [],
+        };
+    }
+    let filtered = [...entries]
+        .filter(() => statuses.includes("pending"))
+        .filter((entry) => {
+        const createdAt = new Date(entry.createdAt).getTime();
+        if (after !== null && createdAt < after)
+            return false;
+        if (before !== null && createdAt > before)
+            return false;
+        return true;
+    });
+    if (opts.id) {
+        filtered = filtered.filter((entry) => entry.id === opts.id);
+    }
+    const limit = typeof opts.limit === "number" && Number.isFinite(opts.limit) && opts.limit > 0 ? opts.limit : 10;
+    return { error: null, filtered: filtered.slice(0, limit) };
+}
 export async function curateCommandAction(content, opts = {}) {
     const config = configManager.config;
+    const format = opts.format === "json" ? "json" : "text";
     if (!config) {
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, error: "Not configured. Run: umbrella-context setup" }, null, 2));
+            return;
+        }
         console.log(chalk.red("Not configured. Run: umbrella-context setup"));
         return;
     }
     if (!content?.trim()) {
-        console.log(chalk.red("\n Usage: umbrella-context curate \"What we learned\""));
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, error: 'Usage: umbrella-context curate "What we learned"' }, null, 2));
+            return;
+        }
+        console.log(chalk.red('\n Usage: umbrella-context curate "What we learned"'));
         return;
     }
     await ensureRepoContext(config);
@@ -21,9 +85,13 @@ export async function curateCommandAction(content, opts = {}) {
         panel: "curate",
         focus: content.trim(),
     });
+    const tags = opts.tag ? (Array.isArray(opts.tag) ? opts.tag : [opts.tag]) : [];
     const entry = await addPendingMemory({
         content: content.trim(),
-        tags: opts.tag ? (Array.isArray(opts.tag) ? opts.tag : [opts.tag]) : [],
+        tags,
+        keywords: tags,
+        category: null,
+        accessLevel: "space",
         source: "cli",
         systemType: opts.type || "system1_knowledge",
     });
@@ -38,41 +106,109 @@ export async function curateCommandAction(content, opts = {}) {
         status: "success",
     });
     await completeTask(task.id, "completed", `Saved local draft ${entry.id} in .um.`);
+    printCurateResult(format, {
+        ok: true,
+        action: "curate",
+        companyName: config.companyName,
+        spaceName: config.projectName,
+        pendingEntryId: entry.id,
+        tags: entry.tags,
+        type: entry.systemType,
+        accessLevel: entry.accessLevel,
+        umDir,
+    });
+    if (format === "json") {
+        return;
+    }
     console.log(chalk.green(`\n Saved locally to ${config.companyName} / ${config.projectName}`));
     console.log(chalk.gray(`   Pending entry: ${entry.id}`));
     console.log(chalk.gray(`   Repo context folder: ${umDir}`));
     console.log(chalk.gray('   Run "umbrella-context push" when you want to sync this to the server.'));
 }
-export async function curateViewCommandAction() {
+export async function curateViewCommandAction(opts = {}) {
     const config = configManager.config;
+    const format = opts.format === "json" ? "json" : "text";
     if (!config) {
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, error: "Not configured. Run: umbrella-context setup" }, null, 2));
+            return;
+        }
         console.log(chalk.red("Not configured. Run: umbrella-context setup"));
         return;
     }
     await ensureRepoContext(config);
-    await setSessionPanel("curate", "view");
+    await setSessionPanel("curate", opts.id ?? "view");
     const entries = await getPendingMemories();
+    const { error, filtered } = filterCurations(entries, opts);
+    if (error) {
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "curate.view", error }, null, 2));
+            return;
+        }
+        console.log(chalk.red(error));
+        return;
+    }
+    if (format === "json") {
+        console.log(JSON.stringify({
+            ok: true,
+            action: "curate.view",
+            companyName: config.companyName,
+            spaceName: config.projectName,
+            total: filtered.length,
+            statuses: normalizeStatuses(opts.status),
+            detail: Boolean(opts.detail || opts.id),
+            entries: filtered,
+        }, null, 2));
+        return;
+    }
     console.log(chalk.bold(`\n Local Curations for ${config.companyName} / ${config.projectName}\n`));
-    if (entries.length === 0) {
-        console.log(chalk.yellow(" No local curations staged yet."));
+    if (filtered.length === 0) {
+        console.log(chalk.yellow(" No local curations matched this view."));
         console.log(chalk.gray(' Try: umbrella-context curate "What you learned"'));
         return;
     }
-    entries.forEach((entry, index) => {
+    filtered.forEach((entry, index) => {
         const tags = entry.tags.length > 0 ? ` [${entry.tags.join(", ")}]` : "";
         console.log(` ${index + 1}. ${entry.content}${tags}`);
-        console.log(chalk.gray(`    ${entry.systemType} • ${entry.createdAt} • ${entry.id}`));
+        console.log(chalk.gray(`    pending • ${entry.systemType} • ${entry.createdAt} • ${entry.id}`));
+        if (opts.detail || opts.id) {
+            const keywords = entry.keywords.length > 0 ? entry.keywords.join(", ") : "none";
+            console.log(chalk.gray(`    access: ${entry.accessLevel} • category: ${entry.category ?? "uncategorized"} • source: ${entry.source}`));
+            console.log(chalk.gray(`    keywords: ${keywords}`));
+        }
     });
 }
 export function curateCommand(cli) {
     cli
-        .command("curate [...content]", "Save context locally in this repo so it can be pushed later")
+        .command("curate [...content]", `Save context locally in this repo so it can be pushed later
+
+Good examples:
+- "Auth uses JWT with 24h expiry in httpOnly cookies via auth middleware"
+- "Rate limit is 100 req/min per user using Redis sliding windows"
+Bad examples:
+- "Authentication"
+- "Rate limiting"`)
         .option("--tag <tag>", "Add tags (repeatable)")
         .option("--type <type>", "system1_knowledge or system2_reasoning")
+        .option("--format <format>", "Output format (text or json)")
+        .option("--detail", "When used with curate view, show richer entry detail")
+        .option("--limit <limit>", "When used with curate view, limit the number of entries returned")
+        .option("--since <time>", "When used with curate view, show entries after a time like 1h, 24h, 7d, or an ISO date")
+        .option("--before <time>", "When used with curate view, show entries before a time like 1h, 24h, 7d, or an ISO date")
+        .option("--status <status>", "When used with curate view, filter by status (currently: pending)")
+        .example('curate "JWT auth uses httpOnly cookies"')
+        .example('curate "Auth middleware" --tag auth --tag cookies --format json')
+        .example("curate view")
+        .example("curate view --since 1h --detail")
+        .example("curate view 123e4567-e89b-12d3-a456-426614174000 --format json")
         .action(async (content, opts) => {
         const parts = Array.isArray(content) ? content : [content];
         if (parts.length === 1 && parts[0] === "view") {
-            await curateViewCommandAction();
+            await curateViewCommandAction(opts);
+            return;
+        }
+        if (parts[0] === "view") {
+            await curateViewCommandAction({ ...opts, id: parts[1] });
             return;
         }
         await curateCommandAction(parts.join(" "), opts);

package/dist/commands/fix.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { configManager } from "../config.js";
-import { addTaskReasoningContent, addTaskToolCall, appendTaskStreamingContent, completeTask, createTask, patchTaskLifecycle, recordSessionEvent, setSessionPanel, } from "../repo-state.js";
+import { addTaskReasoningContent, addTaskToolCall, appendTaskStreamingContent, completeTask, createTask, patchTaskLifecycle, removeTask, recordSessionEvent, setSessionPanel, } from "../repo-state.js";
 export function fixCommand(cli) {
     cli.command("fix <error>", "Search for known fixes to an error").action(async (error) => {
         const config = configManager.config;
@@ -54,15 +54,7 @@ export function fixCommand(cli) {
             });
             await addTaskReasoningContent(task.id, `Server returned ${data.results.length} known fix candidate${data.results.length === 1 ? "" : "s"}.`);
             if (data.results.length === 0) {
-                await completeTask(task.id, "completed", `No known fixes found for "${error}".`);
-                await recordSessionEvent({
-                    kind: "query",
-                    title: `No known fixes found for "${error}"`,
-                    detail: "The shared fixes store did not contain this error signal.",
-                    panel: "fix",
-                    focus: error,
-                    status: "warning",
-                });
+                await removeTask(task.id);
                 console.log(chalk.yellow(`\n No known fixes for "${error}"`));
                 return;
             }

package/dist/commands/interactive.js

@@ -46,7 +46,7 @@ function printWelcomeHeader(providerLabel, modelLabel) {
     console.log(`  ${chalk.yellow("/reset")}        Reset this repo's local Context state`);
     console.log(`  ${chalk.yellow("/")}             Full command list`);
     console.log(divider());
-    console.log(`  ${chalk.gray("Shortcuts:")} type plain text to query, or start with ${chalk.yellow("+")} to curate quickly.`);
+    console.log(`  ${chalk.gray("Shortcuts:")} start with ${chalk.yellow("?")} to query, or start with ${chalk.yellow("+")} to curate quickly.`);
     console.log("");
 }
 async function printRuntimeSnapshot() {
@@ -794,7 +794,7 @@ export async function interactiveCommand(_args) {
     await setSessionPanel("home", configManager.config.projectName);
     await printRuntimeSnapshot();
     await printHomeView(configManager.config);
-    console.log(chalk.gray(" Type / to see commands. Use plain text to query or start with + to curate.\n"));
+    console.log(chalk.gray(" Type / to see commands. Use ? to query or + to curate.\n"));
     while (true) {
         const currentConfig = configManager.config;
         if (!currentConfig) {
@@ -837,21 +837,32 @@ export async function interactiveCommand(_args) {
             }
             continue;
         }
-        const { command, args } = parseInteractiveInput(raw);
-        const spec = resolveCommand(command);
-        if (!raw.startsWith("/") && !spec) {
-            commandHistory.push(`/query ${raw}`);
-            await recordSessionCommand(`/query ${raw}`);
-            await recordSessionQuery(raw);
-            await setSessionSummary(`Queried Context: ${raw.length > 48 ? `${raw.slice(0, 48)}...` : raw}`);
+        if (raw.startsWith("?")) {
+            const query = raw.slice(1).trim();
+            if (!query) {
+                console.log(chalk.yellow("Use ? followed by a real question, for example ? what do we already know about auth timeouts"));
+                continue;
+            }
+            commandHistory.push(`/query ${query}`);
+            await recordSessionCommand(`/query ${query}`);
+            await recordSessionQuery(query);
+            await setSessionSummary(`Queried Context: ${query.length > 48 ? `${query.slice(0, 48)}...` : query}`);
             try {
-                await searchCommandAction(raw);
+                await searchCommandAction(query);
             }
             catch (err) {
                 console.log(chalk.red(`Command failed: ${err.message}`));
             }
             continue;
         }
+        const { command, args } = parseInteractiveInput(raw);
+        const spec = resolveCommand(command);
+        if (!raw.startsWith("/") && !spec) {
+            console.log(chalk.yellow("That text was not run automatically."));
+            console.log(chalk.gray("Use /query <question> or start with ? to search Context."));
+            console.log(chalk.gray("Use /curate <note> or start with + to save something locally."));
+            continue;
+        }
         if (!spec) {
             console.log(chalk.yellow(`Unknown command: ${raw}. Type / to see available commands.`));
             continue;

package/dist/commands/locations.d.ts

@@ -1,2 +1,7 @@
-export declare function locationsCommandAction(): Promise<void>;
+type OutputFormat = "text" | "json";
+export declare function locationsCommandAction(opts?: {
+    format?: OutputFormat;
+    detail?: boolean;
+}): Promise<void>;
 export declare function locationsCommand(cli: any): void;
+export {};

package/dist/commands/locations.js

@@ -1,20 +1,106 @@
 import chalk from "chalk";
+import { promises as fs } from "fs";
+import path from "path";
 import { configManager } from "../config.js";
-export async function locationsCommandAction() {
-    const locations = configManager.locations;
+import { findRepoRoot, getRepoContext } from "../repo-state.js";
+async function getCurrentRepoRoot() {
+    try {
+        const { repoRoot } = await getRepoContext();
+        return repoRoot;
+    }
+    catch {
+        return null;
+    }
+}
+async function summarizeSavedLocations() {
+    const currentRepoRoot = await getCurrentRepoRoot();
+    const storedLocations = configManager.locations;
+    const normalizedLocations = await Promise.all(storedLocations.map(async (location) => {
+        try {
+            const canonicalRepoRoot = await findRepoRoot(location.repoRoot);
+            return canonicalRepoRoot === location.repoRoot ? location : { ...location, repoRoot: canonicalRepoRoot };
+        }
+        catch {
+            return location;
+        }
+    }));
+    const dedupedLocations = Array.from(new Map(normalizedLocations.map((location) => [
+        location.repoRoot,
+        location,
+    ])).values());
+    const locationChanged = dedupedLocations.length !== storedLocations.length
+        || dedupedLocations.some((location, index) => {
+            const original = storedLocations[index];
+            return !original || original.repoRoot !== location.repoRoot;
+        });
+    if (locationChanged) {
+        configManager.replaceLocations(dedupedLocations);
+    }
+    const snapshots = await Promise.all(dedupedLocations.map(async (location) => {
+        const umDir = path.join(location.repoRoot, ".um");
+        const contextFile = path.join(umDir, "context.json");
+        const [umDirStat, contextStat] = await Promise.allSettled([fs.stat(umDir), fs.stat(contextFile)]);
+        const hasUmDir = umDirStat.status === "fulfilled" && umDirStat.value.isDirectory();
+        const hasContextFile = contextStat.status === "fulfilled" && contextStat.value.isFile();
+        return {
+            ...location,
+            isCurrentRepo: currentRepoRoot !== null && currentRepoRoot === location.repoRoot,
+            hasUmDir,
+            hasContextFile,
+            isLinked: hasUmDir && hasContextFile,
+        };
+    }));
+    return snapshots.sort((a, b) => a.repoRoot.localeCompare(b.repoRoot));
+}
+function printLocationsJson(locations) {
+    console.log(JSON.stringify({
+        ok: true,
+        action: "locations",
+        count: locations.length,
+        locations,
+    }, null, 2));
+}
+export async function locationsCommandAction(opts = {}) {
+    const locations = await summarizeSavedLocations();
     if (locations.length === 0) {
+        if (opts.format === "json") {
+            printLocationsJson([]);
+            return;
+        }
         console.log(chalk.yellow("\n No repo locations saved yet."));
         return;
     }
+    if (opts.format === "json") {
+        printLocationsJson(locations);
+        return;
+    }
     console.log(chalk.bold("\n Saved Context Locations\n"));
     locations.forEach((location, index) => {
-        console.log(chalk.cyan(` ${index + 1}. ${location.companyName} / ${location.projectName}`));
+        const badges = [];
+        if (location.isCurrentRepo)
+            badges.push(chalk.green("CURRENT"));
+        if (location.isLinked)
+            badges.push(chalk.cyan("LINKED"));
+        else
+            badges.push(chalk.yellow("SAVED ONLY"));
+        console.log(chalk.cyan(` ${index + 1}. ${location.companyName} / ${location.projectName} ${badges.join(" ")}`));
         console.log(chalk.gray(`    ${location.repoRoot}`));
         console.log(chalk.gray(`    Updated: ${new Date(location.updatedAt).toLocaleString()}`));
+        if (opts.detail) {
+            console.log(chalk.gray(`    .um folder: ${location.hasUmDir ? "Yes" : "No"}`));
+            console.log(chalk.gray(`    .um/context.json: ${location.hasContextFile ? "Yes" : "No"}`));
+        }
     });
 }
 export function locationsCommand(cli) {
-    cli.command("locations", "List repo folders that have been connected on this machine").action(async () => {
-        await locationsCommandAction();
+    cli
+        .command("locations", "List repo folders that have been connected on this machine")
+        .option("--format <format>", "Output format (text or json)")
+        .option("--detail", "Show whether each saved repo still has a linked .um folder and context file")
+        .example("locations")
+        .example("locations --detail")
+        .example("locations --format json")
+        .action(async (opts) => {
+        await locationsCommandAction(opts);
     });
 }

package/dist/commands/mcp.js

@@ -22,11 +22,16 @@ export function mcpCommand(cli) {
                 const data = await res.json();
                 return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
             });
-            server.tool("memory_push", "Save a memory or note to the current context space", { content: z.string().describe("The memory content"), tags: z.array(z.string()).optional() }, async ({ content, tags }) => {
+            server.tool("memory_push", "Save a memory or note to the current context space", {
+                content: z.string().describe("The memory content"),
+                tags: z.array(z.string()).optional(),
+                category: z.enum(["project", "team", "convention", "environment", "preference", "incident", "other"]).optional(),
+                accessLevel: z.enum(["space", "company"]).optional(),
+            }, async ({ content, tags, category, accessLevel }) => {
                 const res = await fetch(`${config.serverUrl}/api/memories`, {
                     method: "POST",
                     headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.apiKey}` },
-                    body: JSON.stringify({ content, tags: tags || [], source: "mcp" }),
+                    body: JSON.stringify({ content, tags: tags || [], category, accessLevel, source: "mcp" }),
                 });
                 const data = await res.json();
                 return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };

package/dist/commands/pull.d.ts

@@ -1,2 +1,7 @@
-export declare function pullCommandAction(): Promise<void>;
+type OutputFormat = "text" | "json";
+export declare function pullCommandAction(opts?: {
+    format?: OutputFormat;
+    dryRun?: boolean;
+}): Promise<void>;
 export declare function pullCommand(cli: any): void;
+export {};