umbrella-context 0.1.2 → 0.1.20

package/dist/commands/curate.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { configManager } from "../config.js";
-import { addPendingMemory, ensureRepoContext, getRepoContext } from "../repo-state.js";
+import { addPendingMemory, ensureRepoContext, getPendingMemories, getRepoContext, recordSessionCuration, recordSessionEvent, setSessionPanel } from "../repo-state.js";
 export async function curateCommandAction(content, opts = {}) {
     const config = configManager.config;
     if (!config) {
@@ -12,6 +12,7 @@ export async function curateCommandAction(content, opts = {}) {
         return;
     }
     await ensureRepoContext(config);
+    await setSessionPanel("curate", content.trim());
     const entry = await addPendingMemory({
         content: content.trim(),
         tags: opts.tag ? (Array.isArray(opts.tag) ? opts.tag : [opts.tag]) : [],
@@ -19,17 +20,52 @@ export async function curateCommandAction(content, opts = {}) {
         systemType: opts.type || "system1_knowledge",
     });
     const { umDir } = await getRepoContext();
+    await recordSessionCuration(content.trim());
+    await recordSessionEvent({
+        kind: "curate",
+        title: "Saved a new local Context note",
+        detail: `Draft ${entry.id} was added to .um for ${config.companyName} / ${config.projectName}.`,
+        panel: "curate",
+        focus: entry.id,
+        status: "success",
+    });
     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() {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    await ensureRepoContext(config);
+    await setSessionPanel("curate", "view");
+    const entries = await getPendingMemories();
+    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."));
+        console.log(chalk.gray(' Try: umbrella-context curate "What you learned"'));
+        return;
+    }
+    entries.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}`));
+    });
+}
 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")
         .option("--tag <tag>", "Add tags (repeatable)")
         .option("--type <type>", "system1_knowledge or system2_reasoning")
         .action(async (content, opts) => {
-        await curateCommandAction(content, opts);
+        const parts = Array.isArray(content) ? content : [content];
+        if (parts.length === 1 && parts[0] === "view") {
+            await curateViewCommandAction();
+            return;
+        }
+        await curateCommandAction(parts.join(" "), opts);
     });
 }

package/dist/commands/debug.d.ts

@@ -0,0 +1,2 @@
+export declare function debugCommandAction(): Promise<void>;
+export declare function debugCommand(cli: any): void;

package/dist/commands/debug.js

@@ -0,0 +1,55 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+import { ensureSessionState, getConnectorRuns, getInstalledConnectors, getInstalledHubEntries, getPendingMemories, getPulledFixes, getPulledMemories, getRepoContext, } from "../repo-state.js";
+export async function debugCommandAction() {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    const { repoRoot, state, umDir } = await getRepoContext();
+    const session = await ensureSessionState();
+    const pending = await getPendingMemories();
+    const pulled = await getPulledMemories();
+    const fixes = await getPulledFixes();
+    const connectors = await getInstalledConnectors();
+    const hubEntries = await getInstalledHubEntries();
+    const runs = await getConnectorRuns();
+    console.log(chalk.bold("\n Umbrella Context Debug\n"));
+    console.log(chalk.cyan(" Config"));
+    console.log(`  Config Path: ${configManager.configPath}`);
+    console.log(`  Umbrella URL: ${config.umbrellaUrl ?? "Not saved"}`);
+    console.log(`  Server URL: ${config.serverUrl}`);
+    console.log(`  Company: ${config.companyName} (${config.companyId})`);
+    console.log(`  Space: ${config.projectName} (${config.projectId})`);
+    console.log(`  Workspace: ${config.workspaceName} (${config.workspaceId})`);
+    console.log("");
+    console.log(chalk.cyan(" Repo State"));
+    console.log(`  Repo Root: ${repoRoot}`);
+    console.log(`  .um Folder: ${umDir}`);
+    console.log(`  Context Initialized: ${state ? "Yes" : "No"}`);
+    console.log(`  Last Push: ${state?.lastPushAt ?? "Never"}`);
+    console.log(`  Last Pull: ${state?.lastPullAt ?? "Never"}`);
+    console.log("");
+    console.log(chalk.cyan(" Local Counts"));
+    console.log(`  Pending Curations: ${pending.length}`);
+    console.log(`  Pulled Context Notes: ${pulled.length}`);
+    console.log(`  Pulled Known Fixes: ${fixes.length}`);
+    console.log(`  Installed Hub Entries: ${hubEntries.length}`);
+    console.log(`  Installed Connectors: ${connectors.length}`);
+    console.log(`  Connector Runs: ${runs.length}`);
+    console.log("");
+    console.log(chalk.cyan(" Session"));
+    console.log(`  Session ID: ${session.id}`);
+    console.log(`  Started: ${session.startedAt}`);
+    console.log(`  Updated: ${session.updatedAt}`);
+    console.log(`  Commands: ${session.commandHistory.length}`);
+    console.log(`  Queries: ${session.recentQueries.length}`);
+    console.log(`  Curations: ${session.recentCurations.length}`);
+    console.log(`  Last Summary: ${session.lastSummary ?? "Nothing recorded yet"}`);
+}
+export function debugCommand(cli) {
+    cli.command("debug", "Show detailed local runtime paths, counts, and session state").action(async () => {
+        await debugCommandAction();
+    });
+}

package/dist/commands/hub.d.ts

@@ -0,0 +1,20 @@
+type HubEntry = {
+    slug: string;
+    name: string;
+    type: "bundle" | "skill" | "connector";
+    description: string;
+    includes: string[];
+    nextSteps: string[];
+    installsConnector?: string;
+};
+export type HubCommandResult = {
+    action: "list" | "install" | "inspect" | "installed" | "registry";
+    changed: boolean;
+    installedEntry?: HubEntry;
+    assetPath?: string;
+    filePaths?: string[];
+    recommendedConnector?: string;
+};
+export declare function hubCommandAction(action: string, subAction?: string): Promise<HubCommandResult | void>;
+export declare function hubCommand(cli: any): void;
+export {};

package/dist/commands/hub.js

@@ -0,0 +1,429 @@
+import { randomUUID } from "crypto";
+import chalk from "chalk";
+import prompts from "prompts";
+import { configManager } from "../config.js";
+import { getInstalledHubEntries, getSessionState, recordSessionEvent, recordSessionHubEntry, setInstalledHubEntries, setSessionPanel, writeHubAsset, writeHubAssetFiles } from "../repo-state.js";
+import { connectorsCommandAction } from "./connectors.js";
+const DEFAULT_HUB_ENTRIES = [
+    {
+        slug: "quick-ping-growth-bundle",
+        name: "Quick Ping Growth Bundle",
+        type: "bundle",
+        description: "Context prompts, SEO helpers, and research habits for the Quick Ping growth team.",
+        includes: ["Growth query pack", "Capture template", "Quick Ping growth playbook"],
+        nextSteps: [
+            "umbrella-context query \"What messaging already worked for Quick Ping?\"",
+            "umbrella-context curate \"...\"",
+            "umbrella-context push",
+        ],
+    },
+    {
+        slug: "engineering-debug-skill-pack",
+        name: "Engineering Debug Skill Pack",
+        type: "skill",
+        description: "A reusable troubleshooting pack for recurring engineering bugs and known-fix workflows.",
+        includes: ["Debug checklist", "Root cause template"],
+        nextSteps: [
+            "umbrella-context fix \"<error signal>\"",
+            "umbrella-context record <id> success",
+        ],
+    },
+    {
+        slug: "umbrella-context-mcp-connector",
+        name: "Umbrella Context MCP Connector",
+        type: "connector",
+        description: "A ready-made MCP connector bundle for IDE agents that should talk to Context.",
+        includes: ["Connector install notes", "Repo MCP bridge wiring"],
+        nextSteps: [
+            "umbrella-context connectors install codex-mcp",
+            "umbrella-context connectors run codex-mcp",
+            "umbrella-context status",
+        ],
+        installsConnector: "codex-mcp",
+    },
+];
+function buildHubAsset(entry) {
+    return [
+        `# ${entry.name}`,
+        "",
+        `Type: ${entry.type}`,
+        `Slug: ${entry.slug}`,
+        "",
+        "## Why this exists",
+        "",
+        entry.description,
+        "",
+        "## Suggested use",
+        "",
+        "- Review this file before running related Context workflows.",
+        "- Copy the reusable parts into prompts, rules, or team playbooks as needed.",
+        "- Keep the repo-specific details nearby so future operators reuse the same pattern.",
+        "",
+        "## Next commands",
+        "",
+        ...entry.nextSteps.map((step) => `- \`${step}\``),
+        "",
+    ].join("\n");
+}
+function buildHubFiles(entry) {
+    if (entry.slug === "quick-ping-growth-bundle") {
+        return [
+            {
+                name: "overview.md",
+                content: [
+                    "# Quick Ping Growth Bundle",
+                    "",
+                    "Use this bundle when you are working on Quick Ping growth work inside this repo.",
+                    "",
+                    "## What is inside",
+                    "",
+                    "- Growth context reminders",
+                    "- Reusable query prompts",
+                    "- Capture patterns for turning work into shared context",
+                    "",
+                    "## Recommended flow",
+                    "",
+                    "1. Run `umbrella-context query \"What do we already know about this audience?\"`",
+                    "2. Do the work.",
+                    "3. Run `umbrella-context curate \"...\"` with the result.",
+                    "4. Run `umbrella-context push` when it is worth sharing.",
+                    "",
+                ].join("\n"),
+            },
+            {
+                name: "queries.md",
+                content: [
+                    "# Growth Queries",
+                    "",
+                    "- `umbrella-context query \"What messaging already worked for Quick Ping?\"`",
+                    "- `umbrella-context query \"What objections have job seekers shown before?\"`",
+                    "- `umbrella-context query \"Which channels have we already tested?\"`",
+                    "",
+                ].join("\n"),
+            },
+            {
+                name: "capture-template.md",
+                content: [
+                    "# Capture Template",
+                    "",
+                    "Use this shape when you turn work into shared context:",
+                    "",
+                    "```text",
+                    "We learned that ...",
+                    "Why it mattered: ...",
+                    "Where we saw it: ...",
+                    "What to do next time: ...",
+                    "```",
+                    "",
+                ].join("\n"),
+            },
+        ];
+    }
+    if (entry.slug === "engineering-debug-skill-pack") {
+        return [
+            {
+                name: "debug-checklist.md",
+                content: [
+                    "# Engineering Debug Checklist",
+                    "",
+                    "1. Reproduce the problem.",
+                    "2. Search Context for prior fixes.",
+                    "3. Capture the exact error signal.",
+                    "4. Write down the root cause once confirmed.",
+                    "5. Record the fix outcome with `umbrella-context record`.",
+                    "",
+                ].join("\n"),
+            },
+            {
+                name: "root-cause-template.md",
+                content: [
+                    "# Root Cause Template",
+                    "",
+                    "```text",
+                    "Bug: ...",
+                    "Signal: ...",
+                    "Root cause: ...",
+                    "Fix: ...",
+                    "How to prevent it next time: ...",
+                    "```",
+                    "",
+                ].join("\n"),
+            },
+        ];
+    }
+    if (entry.slug === "umbrella-context-mcp-connector") {
+        return [
+            {
+                name: "install-next.md",
+                content: [
+                    "# Umbrella Context MCP Connector",
+                    "",
+                    "This bundle pairs with the `codex-mcp` connector.",
+                    "",
+                    "## Next step",
+                    "",
+                    "Run:",
+                    "",
+                    "```bash",
+                    "umbrella-context connectors install codex-mcp",
+                    "```",
+                    "",
+                    "Then verify with:",
+                    "",
+                    "```bash",
+                    "umbrella-context connectors run codex-mcp",
+                    "```",
+                    "",
+                ].join("\n"),
+            },
+        ];
+    }
+    return [];
+}
+function printInstalled(installed) {
+    console.log(chalk.bold("\n Installed Hub Entries\n"));
+    if (installed.length === 0) {
+        console.log(chalk.yellow(" No hub entries installed in this repo yet."));
+        return;
+    }
+    installed.forEach((entry, index) => {
+        console.log(` ${index + 1}. ${entry.name} [${entry.type}]`);
+        console.log(chalk.gray(`    ${entry.description}`));
+        console.log(chalk.gray(`    Installed from ${entry.registryName} at ${new Date(entry.installedAt).toLocaleString()}`));
+    });
+}
+function printRegistryList() {
+    console.log(chalk.bold("\n Hub Registries\n"));
+    configManager.hubRegistries.forEach((registry, index) => {
+        console.log(` ${index + 1}. ${registry.name}`);
+        console.log(chalk.gray(`    ${registry.url}`));
+    });
+}
+export async function hubCommandAction(action, subAction) {
+    const normalized = action.toLowerCase();
+    await setSessionPanel("hub", subAction ?? normalized);
+    if (normalized === "list") {
+        await setSessionPanel("hub", "list");
+        console.log(chalk.bold("\n Hub Catalog\n"));
+        DEFAULT_HUB_ENTRIES.forEach((entry, index) => {
+            console.log(` ${index + 1}. ${entry.name} [${entry.type}]`);
+            console.log(chalk.gray(`    ${entry.description}`));
+        });
+        const installed = await getInstalledHubEntries();
+        if (installed.length > 0) {
+            console.log(chalk.gray(`\n Installed in this repo: ${installed.length}`));
+        }
+        return { action: "list", changed: false };
+    }
+    if (normalized === "install") {
+        const installed = await getInstalledHubEntries();
+        let selected = subAction ? DEFAULT_HUB_ENTRIES.find((entry) => entry.slug === subAction) : undefined;
+        if (!selected) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a hub entry to install into this repo",
+                choices: DEFAULT_HUB_ENTRIES.map((entry) => ({
+                    title: `${entry.name} (${entry.type})`,
+                    description: entry.description,
+                    value: entry.slug,
+                })),
+            });
+            selected = DEFAULT_HUB_ENTRIES.find((entry) => entry.slug === answer.value);
+        }
+        if (!selected) {
+            console.log(chalk.yellow("\n No hub entry selected."));
+            return;
+        }
+        await setSessionPanel("hub", selected.slug);
+        await recordSessionHubEntry(selected.slug);
+        if (installed.some((entry) => entry.slug === selected.slug)) {
+            await recordSessionEvent({
+                kind: "hub",
+                title: `${selected.name} was already installed`,
+                detail: "No repo files changed because this bundle was already present.",
+                panel: "hub",
+                focus: selected.slug,
+                status: "info",
+            });
+            console.log(chalk.yellow(`\n ${selected.name} is already installed in this repo.`));
+            return {
+                action: "install",
+                changed: false,
+                installedEntry: selected,
+            };
+        }
+        const registry = configManager.hubRegistries[0];
+        await setInstalledHubEntries([
+            ...installed,
+            {
+                id: randomUUID(),
+                slug: selected.slug,
+                name: selected.name,
+                type: selected.type,
+                description: selected.description,
+                installedAt: new Date().toISOString(),
+                registryName: registry?.name ?? "Umbrella Hub",
+            },
+        ]);
+        const assetPath = await writeHubAsset(selected.slug, buildHubAsset(selected));
+        const filePaths = await writeHubAssetFiles(selected.slug, buildHubFiles(selected));
+        await recordSessionEvent({
+            kind: "hub",
+            title: `Installed hub entry ${selected.name}`,
+            detail: `${selected.includes.length} packaged item${selected.includes.length === 1 ? "" : "s"} are now available in this repo.`,
+            panel: "hub",
+            focus: selected.slug,
+            status: "success",
+        });
+        console.log(chalk.green(`\n Installed ${selected.name} into this repo.`));
+        console.log(chalk.gray(` Asset written to ${assetPath}`));
+        filePaths.forEach((filePath) => {
+            console.log(chalk.gray(` Added bundle file ${filePath}`));
+        });
+        if (selected.slug === "umbrella-context-mcp-connector") {
+            console.log(chalk.gray(" Installing the recommended codex-mcp connector next..."));
+            await connectorsCommandAction("install", selected.installsConnector ?? "codex-mcp");
+        }
+        return {
+            action: "install",
+            changed: true,
+            installedEntry: selected,
+            assetPath,
+            filePaths,
+            recommendedConnector: selected.installsConnector,
+        };
+    }
+    if (normalized === "inspect") {
+        const target = subAction
+            ? DEFAULT_HUB_ENTRIES.find((entry) => entry.slug === subAction)
+            : undefined;
+        if (!target) {
+            console.log(chalk.red("Use: hub inspect <slug>"));
+            return;
+        }
+        const installed = await getInstalledHubEntries();
+        const isInstalled = installed.some((entry) => entry.slug === target.slug);
+        await setSessionPanel("hub", target.slug);
+        await recordSessionHubEntry(target.slug);
+        await recordSessionEvent({
+            kind: "hub",
+            title: `Inspected hub entry ${target.name}`,
+            detail: `Viewed the bundle details and next steps for ${target.slug}.`,
+            panel: "hub",
+            focus: target.slug,
+            status: "info",
+        });
+        console.log(chalk.bold(`\n ${target.name}\n`));
+        console.log(` Type: ${target.type}`);
+        console.log(` Slug: ${target.slug}`);
+        console.log(` Installed: ${isInstalled ? "Yes" : "No"}`);
+        console.log(chalk.gray(` ${target.description}`));
+        console.log("");
+        console.log(chalk.cyan(" Includes"));
+        target.includes.forEach((item) => {
+            console.log(`  - ${item}`);
+        });
+        console.log("");
+        console.log(chalk.cyan(" Next Steps"));
+        target.nextSteps.forEach((step) => {
+            console.log(`  - ${step}`);
+        });
+        if (target.installsConnector) {
+            console.log("");
+            console.log(chalk.cyan(" Connector"));
+            console.log(`  - Installs ${target.installsConnector}`);
+        }
+        return {
+            action: "inspect",
+            changed: false,
+            installedEntry: target,
+            recommendedConnector: target.installsConnector,
+        };
+    }
+    if (normalized === "recent") {
+        const session = await getSessionState();
+        const slug = session?.recentHubSlugs?.[0];
+        if (!slug) {
+            console.log(chalk.yellow("\n No recent hub entry in this session yet."));
+            return;
+        }
+        return hubCommandAction("inspect", slug);
+    }
+    if (normalized === "installed") {
+        await setSessionPanel("hub", "installed");
+        await printInstalled(await getInstalledHubEntries());
+        return { action: "installed", changed: false };
+    }
+    if (normalized === "registry") {
+        await setSessionPanel("hub", `registry:${subAction ?? "list"}`);
+        const mode = (subAction ?? "list").toLowerCase();
+        if (mode === "list") {
+            printRegistryList();
+            return { action: "registry", changed: false };
+        }
+        if (mode === "add") {
+            const answer = await prompts([
+                { type: "text", name: "name", message: "Registry name" },
+                { type: "text", name: "url", message: "Registry URL" },
+            ]);
+            if (!answer.name || !answer.url) {
+                console.log(chalk.yellow("\n Registry add cancelled."));
+                return;
+            }
+            configManager.upsertHubRegistry({
+                id: randomUUID(),
+                name: answer.name,
+                url: answer.url,
+                updatedAt: new Date().toISOString(),
+            });
+            await recordSessionEvent({
+                kind: "hub",
+                title: `Added hub registry ${answer.name}`,
+                detail: `The CLI can now see bundles from ${answer.url}.`,
+                panel: "hub",
+                focus: `registry:${answer.name}`,
+                status: "success",
+            });
+            console.log(chalk.green(`\n Added registry ${answer.name}.`));
+            return { action: "registry", changed: true };
+        }
+        if (mode === "remove") {
+            const registries = configManager.hubRegistries;
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a registry to remove",
+                choices: registries.map((entry) => ({
+                    title: entry.name,
+                    description: entry.url,
+                    value: entry.id,
+                })),
+            });
+            if (!answer.value) {
+                console.log(chalk.yellow("\n No registry selected."));
+                return;
+            }
+            const selected = registries.find((entry) => entry.id === answer.value);
+            configManager.removeHubRegistry(answer.value);
+            await recordSessionEvent({
+                kind: "hub",
+                title: `Removed hub registry ${selected?.name ?? "registry"}`,
+                detail: "The registry was removed from this device configuration.",
+                panel: "hub",
+                focus: `registry:${selected?.name ?? "removed"}`,
+                status: "warning",
+            });
+            console.log(chalk.green(`\n Removed registry ${selected?.name ?? "registry"}.`));
+            return { action: "registry", changed: true };
+        }
+        console.log(chalk.red("Use: hub registry list | add | remove"));
+        return;
+    }
+    console.log(chalk.red("Use: hub list | hub install [slug] | hub inspect <slug> | hub recent | hub installed | hub registry list|add|remove"));
+}
+export function hubCommand(cli) {
+    cli.command("hub <action> [subAction]", "Browse and install skills, bundles, and registries").action(async (action, subAction) => {
+        await hubCommandAction(action, subAction);
+    });
+}

package/dist/commands/interactive.d.ts

@@ -1 +1,3 @@
+import { renderCommandList } from "./catalog.js";
 export declare function interactiveCommand(_args: string[]): Promise<void>;
+export { renderCommandList };