umbrella-context 0.1.2 → 0.1.32

package/dist/commands/hub.js

@@ -0,0 +1,487 @@
+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";
+async function runHubBrowseFlow() {
+    const answer = await prompts({
+        type: "select",
+        name: "value",
+        message: "Choose a hub entry to browse",
+        choices: DEFAULT_HUB_ENTRIES.map((entry) => ({
+            title: `${entry.name} (${entry.type})`,
+            description: entry.description,
+            value: entry.slug,
+        })),
+    });
+    if (!answer.value) {
+        console.log(chalk.yellow("\n No hub entry selected."));
+        return;
+    }
+    const inspectResult = await hubCommandAction("inspect", answer.value);
+    if (!inspectResult?.installedEntry)
+        return;
+    const next = await prompts({
+        type: "select",
+        name: "value",
+        message: `What do you want to do with ${inspectResult.installedEntry.name}?`,
+        choices: [
+            { title: "Install it into this repo", value: "install" },
+            ...(inspectResult.recommendedConnector
+                ? [{ title: `Install and run ${inspectResult.recommendedConnector}`, value: "connector" }]
+                : []),
+            { title: "Back", value: "back" },
+        ],
+    });
+    if (!next.value || next.value === "back") {
+        return {
+            action: "browse",
+            changed: false,
+            installedEntry: inspectResult.installedEntry,
+            recommendedConnector: inspectResult.recommendedConnector,
+        };
+    }
+    const installResult = await hubCommandAction("install", inspectResult.installedEntry.slug);
+    if (next.value === "connector" && inspectResult.recommendedConnector) {
+        await connectorsCommandAction("run", inspectResult.recommendedConnector);
+    }
+    return {
+        action: "browse",
+        changed: Boolean(installResult?.changed),
+        installedEntry: installResult?.installedEntry ?? inspectResult.installedEntry,
+        assetPath: installResult?.assetPath,
+        filePaths: installResult?.filePaths,
+        recommendedConnector: inspectResult.recommendedConnector,
+    };
+}
+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",
+    },
+];
+export function listHubRegistryEntries() {
+    return [...DEFAULT_HUB_ENTRIES];
+}
+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 === "browse") {
+        await setSessionPanel("hub", "browse");
+        return runHubBrowseFlow();
+    }
+    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 browse | 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 };