umbrella-context 0.1.2 → 0.1.32

package/dist/commands/connectors.js

@@ -0,0 +1,626 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+import chalk from "chalk";
+import prompts from "prompts";
+import { addPendingMemory, addConnectorRun, getRepoContext, getInstalledConnectors, getSessionState, recordSessionEvent, recordSessionConnector, setInstalledConnectors, setSessionPanel, writeConnectorAsset, writeConnectorAssetFiles, writeConnectorRunReport, } from "../repo-state.js";
+const CONNECTOR_TEMPLATES = [
+    {
+        key: "codex-mcp",
+        name: "Codex MCP Connector",
+        type: "mcp",
+        description: "Connect IDE agents to Umbrella Context through the local MCP server.",
+    },
+    {
+        key: "github-review-rule",
+        name: "GitHub Review Rule",
+        type: "rule",
+        description: "Push review takeaways and known fixes back into Context after PR work completes.",
+    },
+    {
+        key: "slack-growth-hook",
+        name: "Slack Growth Hook",
+        type: "hook",
+        description: "Capture useful campaign learnings from Slack threads into the current company space.",
+    },
+    {
+        key: "seo-skill-bridge",
+        name: "SEO Skill Bridge",
+        type: "skill",
+        description: "Attach OpenSEO-backed operator skills to the current repo workflow.",
+    },
+];
+export function listConnectorTemplates() {
+    return [...CONNECTOR_TEMPLATES];
+}
+function describeConnectorRun(type, name) {
+    if (type === "mcp") {
+        return `${name} validated the local MCP bridge and confirmed this repo can expose Context tools to IDE agents.`;
+    }
+    if (type === "rule") {
+        return `${name} checked the repo workflow and prepared a rule for saving review takeaways back into Context.`;
+    }
+    if (type === "hook") {
+        return `${name} captured a reusable signal from an external collaboration source and staged it for Context sync.`;
+    }
+    return `${name} attached a reusable skill bridge to this repo so future runs can reuse the same workflow.`;
+}
+function buildConnectorAsset(entry) {
+    return {
+        name: entry.name,
+        type: entry.type,
+        source: entry.key,
+        enabled: true,
+        summary: entry.description,
+        steps: [
+            "Review the connector purpose before enabling it in a workflow.",
+            "Use umbrella-context status to confirm the repo ecosystem state.",
+            "Run umbrella-context connectors run <key> to log a first execution.",
+        ],
+    };
+}
+async function runConnectorCheck(entry, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    if (entry.source === "codex-mcp") {
+        const filePath = path.join(repoRoot, ".mcp.json");
+        try {
+            const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+            const configured = Boolean(parsed?.mcpServers?.["umbrella-context"]);
+            return {
+                status: configured ? "success" : "failure",
+                summary: configured
+                    ? `${entry.name} verified that .mcp.json exposes the umbrella-context MCP server for this repo.`
+                    : `${entry.name} could not find an umbrella-context MCP entry in .mcp.json.`,
+            };
+        }
+        catch {
+            return {
+                status: "failure",
+                summary: `${entry.name} could not read the repo .mcp.json file.`,
+            };
+        }
+    }
+    if (entry.source === "github-review-rule") {
+        return {
+            status: "success",
+            summary: `${entry.name} prepared a repo-local review rule pack so PR lessons can be curated back into Context.`,
+        };
+    }
+    if (entry.source === "slack-growth-hook") {
+        return {
+            status: "success",
+            summary: `${entry.name} prepared a Slack capture template for turning campaign conversations into shared Context notes.`,
+        };
+    }
+    return {
+        status: "success",
+        summary: `${entry.name} attached a reusable skill bridge to this repo so future runs can reuse the same workflow.`,
+    };
+}
+async function applyConnectorRunEffects(entry, cwd = process.cwd()) {
+    if (entry.source === "github-review-rule") {
+        const now = new Date().toISOString();
+        const filePaths = await writeConnectorAssetFiles(entry.source, [
+            {
+                name: "review-capture-template.md",
+                content: [
+                    "# Review Capture Template",
+                    "",
+                    "Use this after a pull request or code review to turn what happened into reusable Context.",
+                    "",
+                    "```text",
+                    "PR or Issue: ...",
+                    "Bug or risk: ...",
+                    "What changed: ...",
+                    "Known fix: ...",
+                    "What to remember next time: ...",
+                    "```",
+                    "",
+                    `Last refreshed: ${now}`,
+                    "",
+                ].join("\n"),
+            },
+        ], cwd);
+        return {
+            filePaths,
+            stagedMemory: null,
+        };
+    }
+    if (entry.source === "slack-growth-hook") {
+        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"],
+            systemType: "connector_capture",
+            source: "slack-growth-hook",
+        }, cwd);
+        const filePaths = await writeConnectorAssetFiles(entry.source, [
+            {
+                name: "last-capture.md",
+                content: [
+                    "# Slack Capture Draft",
+                    "",
+                    "A new local Context draft was staged from the Slack growth hook.",
+                    "",
+                    `Draft ID: ${staged.id}`,
+                    "",
+                    "Edit the local draft with:",
+                    "",
+                    "```bash",
+                    "umbrella-context status",
+                    "umbrella-context push",
+                    "```",
+                    "",
+                ].join("\n"),
+            },
+        ], cwd);
+        return {
+            filePaths,
+            stagedMemory: staged.id,
+        };
+    }
+    if (entry.source === "seo-skill-bridge") {
+        const filePaths = await writeConnectorAssetFiles(entry.source, [
+            {
+                name: "operator-brief.md",
+                content: [
+                    "# SEO Operator Brief",
+                    "",
+                    "This bridge prepares the repo for SEO-focused Context work.",
+                    "",
+                    "Suggested next steps:",
+                    "- Run `umbrella-context query \"What do we already know about this domain?\"`",
+                    "- Use `$umbrella-seo-operator` for OpenSEO-backed workflows",
+                    "- Save the best takeaways with `umbrella-context curate`",
+                    "",
+                ].join("\n"),
+            },
+        ], cwd);
+        return {
+            filePaths,
+            stagedMemory: null,
+        };
+    }
+    return {
+        filePaths: [],
+        stagedMemory: null,
+    };
+}
+function buildConnectorFiles(entry) {
+    if (entry.key === "codex-mcp") {
+        return [
+            {
+                name: "README.md",
+                content: [
+                    "# Codex MCP Connector",
+                    "",
+                    "This connector makes the current repo expose `umbrella-context mcp` to IDE agents.",
+                    "",
+                    "## What it should change",
+                    "",
+                    "- Add an `umbrella-context` server entry to the repo `.mcp.json` file",
+                    "- Keep the local `.um` folder as the repo-native context store",
+                    "",
+                    "## Verify it",
+                    "",
+                    "```bash",
+                    "umbrella-context connectors run codex-mcp",
+                    "umbrella-context status",
+                    "```",
+                    "",
+                ].join("\n"),
+            },
+        ];
+    }
+    if (entry.key === "github-review-rule") {
+        return [
+            {
+                name: "github-review-rule.md",
+                content: [
+                    "# GitHub Review Rule",
+                    "",
+                    "After review work finishes, save the useful outcome back into Context.",
+                    "",
+                    "## Checklist",
+                    "",
+                    "1. Capture the bug, regression, or lesson.",
+                    "2. Curate it into Context.",
+                    "3. Record a known fix if one exists.",
+                    "",
+                ].join("\n"),
+            },
+        ];
+    }
+    if (entry.key === "slack-growth-hook") {
+        return [
+            {
+                name: "slack-capture-template.md",
+                content: [
+                    "# Slack Growth Capture Template",
+                    "",
+                    "Use this when Slack reveals a reusable campaign lesson.",
+                    "",
+                    "```text",
+                    "Signal from Slack: ...",
+                    "Why it matters: ...",
+                    "Next action: ...",
+                    "```",
+                    "",
+                ].join("\n"),
+            },
+        ];
+    }
+    if (entry.key === "seo-skill-bridge") {
+        return [
+            {
+                name: "seo-skill-bridge.md",
+                content: [
+                    "# SEO Skill Bridge",
+                    "",
+                    "Use the OpenSEO operator flow when this repo needs domain, keyword, or audit work.",
+                    "",
+                    "Suggested skill:",
+                    "- `$umbrella-seo-operator`",
+                    "",
+                ].join("\n"),
+            },
+        ];
+    }
+    return [];
+}
+async function installUmbrellaMcpIntoRepo(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const filePath = path.join(repoRoot, ".mcp.json");
+    let current = { mcpServers: {} };
+    try {
+        current = JSON.parse(await fs.readFile(filePath, "utf8"));
+    }
+    catch {
+        current = { mcpServers: {} };
+    }
+    const next = {
+        ...current,
+        mcpServers: {
+            ...(current.mcpServers ?? {}),
+            "umbrella-context": {
+                description: "Repo-local Context bridge for query, curate, push, pull, and known-fix workflows.",
+                command: "umbrella-context",
+                args: ["mcp"],
+            },
+        },
+    };
+    await fs.writeFile(filePath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    return filePath;
+}
+async function getConnectorOutputSummary(source, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const connectorDir = path.join(repoRoot, ".um", "connectors", source);
+    let files = [];
+    try {
+        files = (await fs.readdir(connectorDir)).map((name) => path.join(connectorDir, name));
+    }
+    catch {
+        files = [];
+    }
+    const runs = await import("../repo-state.js").then((mod) => mod.getConnectorRuns(cwd));
+    const latestRun = runs.find((entry) => entry.connectorName && entry.connectorName.toLowerCase().includes(source.replace(/-/g, " "))) ?? runs[0] ?? null;
+    return { files, latestRun };
+}
+export async function connectorsCommandAction(action, target) {
+    const normalized = action.toLowerCase();
+    await setSessionPanel("connectors", target ?? normalized);
+    if (normalized === "list") {
+        await setSessionPanel("connectors", "list");
+        const installed = await getInstalledConnectors();
+        console.log(chalk.bold("\n Repo Connectors\n"));
+        if (installed.length === 0) {
+            console.log(chalk.yellow(" No connectors installed in this repo yet."));
+            console.log(chalk.gray(" Run: umbrella-context connectors install"));
+            return { action: "list", changed: false };
+        }
+        installed.forEach((entry, index) => {
+            console.log(` ${index + 1}. ${entry.name} [${entry.type}]`);
+            console.log(chalk.gray(`    ${entry.description}`));
+            console.log(chalk.gray(`    Source: ${entry.source}`));
+        });
+        return { action: "list", changed: false };
+    }
+    if (normalized === "inspect") {
+        const installed = await getInstalledConnectors();
+        if (installed.length === 0) {
+            console.log(chalk.yellow("\n No connectors installed in this repo yet."));
+            return { action: "inspect", changed: false };
+        }
+        let selected = target
+            ? installed.find((entry) => entry.id === target || entry.source === target || entry.name.toLowerCase() === target.toLowerCase())
+            : undefined;
+        if (!selected) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a connector to inspect",
+                choices: installed.map((entry) => ({
+                    title: `${entry.name} (${entry.type})`,
+                    value: entry.id,
+                })),
+            });
+            selected = installed.find((entry) => entry.id === answer.value);
+        }
+        if (!selected) {
+            console.log(chalk.yellow("\n No connector selected."));
+            return { action: "inspect", changed: false };
+        }
+        await setSessionPanel("connectors", selected.source);
+        await recordSessionConnector(selected.source);
+        await recordSessionEvent({
+            kind: "connector",
+            title: `Inspected connector ${selected.name}`,
+            detail: `Viewed the repo wiring and next steps for ${selected.source}.`,
+            panel: "connectors",
+            focus: selected.source,
+            status: "info",
+        });
+        console.log(chalk.bold(`\n ${selected.name}\n`));
+        console.log(` Type: ${selected.type}`);
+        console.log(` Source: ${selected.source}`);
+        console.log(` Installed: ${new Date(selected.installedAt).toLocaleString()}`);
+        console.log("");
+        console.log(chalk.cyan(" Recommended Next Step"));
+        console.log(`  - Run umbrella-context connectors run ${selected.source}`);
+        if (selected.source === "codex-mcp") {
+            console.log("  - Then run umbrella-context status to verify MCP wiring.");
+        }
+        else if (selected.source === "slack-growth-hook") {
+            console.log('  - Then inspect ".um/pending-memories.json" or run umbrella-context push.');
+        }
+        return {
+            action: "inspect",
+            changed: false,
+            connectorName: selected.name,
+            inspectedConnector: selected.source,
+        };
+    }
+    if (normalized === "recent") {
+        const session = await getSessionState();
+        const recent = session?.recentConnectorSources?.[0];
+        if (!recent) {
+            console.log(chalk.yellow("\n No recent connector in this session yet."));
+            return { action: "inspect", changed: false };
+        }
+        return connectorsCommandAction("inspect", recent);
+    }
+    if (normalized === "outputs") {
+        const installed = await getInstalledConnectors();
+        let selected = target
+            ? installed.find((entry) => entry.id === target || entry.source === target || entry.name.toLowerCase() === target.toLowerCase())
+            : installed[0];
+        if (!selected) {
+            console.log(chalk.yellow("\n No connectors installed in this repo yet."));
+            return { action: "outputs", changed: false };
+        }
+        const outputs = await getConnectorOutputSummary(selected.source);
+        await setSessionPanel("connectors", selected.source);
+        await recordSessionConnector(selected.source);
+        await recordSessionEvent({
+            kind: "connector",
+            title: `Viewed outputs for ${selected.name}`,
+            detail: `${outputs.files.length} connector file${outputs.files.length === 1 ? "" : "s"} currently exist for this repo.`,
+            panel: "connectors",
+            focus: selected.source,
+            status: "info",
+        });
+        console.log(chalk.bold(`\n Outputs for ${selected.name}\n`));
+        if (outputs.files.length === 0) {
+            console.log(chalk.yellow(" No connector files have been written yet."));
+        }
+        else {
+            outputs.files.forEach((filePath, index) => {
+                console.log(` ${index + 1}. ${filePath}`);
+            });
+        }
+        console.log("");
+        console.log(chalk.cyan(" Latest Run"));
+        if (!outputs.latestRun) {
+            console.log("  No connector run has been recorded yet.");
+        }
+        else {
+            console.log(`  ${outputs.latestRun.connectorName} (${outputs.latestRun.status})`);
+            console.log(chalk.gray(`  ${outputs.latestRun.summary}`));
+            console.log(chalk.gray(`  ${new Date(outputs.latestRun.ranAt).toLocaleString()}`));
+        }
+        return {
+            action: "outputs",
+            changed: false,
+            connectorName: selected.name,
+            inspectedConnector: selected.source,
+        };
+    }
+    if (normalized === "install") {
+        const installed = await getInstalledConnectors();
+        let selected = target ? CONNECTOR_TEMPLATES.find((entry) => entry.key === target) : undefined;
+        if (!selected) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a connector to install into this repo",
+                choices: CONNECTOR_TEMPLATES.map((entry) => ({
+                    title: `${entry.name} (${entry.type})`,
+                    description: entry.description,
+                    value: entry.key,
+                })),
+            });
+            selected = CONNECTOR_TEMPLATES.find((entry) => entry.key === answer.value);
+        }
+        if (!selected) {
+            console.log(chalk.yellow("\n No connector selected."));
+            return;
+        }
+        await setSessionPanel("connectors", selected.key);
+        await recordSessionConnector(selected.key);
+        const existing = installed.find((entry) => entry.source === selected.key);
+        if (existing) {
+            const filePaths = await writeConnectorAssetFiles(selected.key, buildConnectorFiles(selected));
+            let repoConfigPath = null;
+            if (selected.key === "codex-mcp") {
+                repoConfigPath = await installUmbrellaMcpIntoRepo();
+            }
+            await recordSessionEvent({
+                kind: "connector",
+                title: `${selected.name} was already installed`,
+                detail: "The existing install stayed in place, but the repo wiring and connector files were refreshed.",
+                panel: "connectors",
+                focus: selected.key,
+                status: "info",
+            });
+            console.log(chalk.yellow(`\n ${selected.name} is already installed in this repo.`));
+            if (filePaths.length > 0) {
+                filePaths.forEach((filePath) => {
+                    console.log(chalk.gray(` Refreshed connector file ${filePath}`));
+                });
+            }
+            if (repoConfigPath) {
+                console.log(chalk.gray(` Refreshed repo MCP config at ${repoConfigPath}`));
+            }
+            console.log(chalk.gray(" Existing installs are kept, but repo wiring was refreshed."));
+            return {
+                action: "install",
+                changed: false,
+                connectorName: selected.name,
+                filePaths,
+                repoConfigPath,
+                inspectedConnector: selected.key,
+            };
+        }
+        await setInstalledConnectors([
+            ...installed,
+            {
+                id: randomUUID(),
+                name: selected.name,
+                type: selected.type,
+                description: selected.description,
+                installedAt: new Date().toISOString(),
+                source: selected.key,
+            },
+        ]);
+        const assetPath = await writeConnectorAsset(selected.key, buildConnectorAsset(selected));
+        const filePaths = await writeConnectorAssetFiles(selected.key, buildConnectorFiles(selected));
+        let repoConfigPath = null;
+        if (selected.key === "codex-mcp") {
+            repoConfigPath = await installUmbrellaMcpIntoRepo();
+        }
+        await recordSessionEvent({
+            kind: "connector",
+            title: `Installed connector ${selected.name}`,
+            detail: `${filePaths.length} repo file${filePaths.length === 1 ? "" : "s"} and connector metadata were added or refreshed.`,
+            panel: "connectors",
+            focus: selected.key,
+            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 connector file ${filePath}`));
+        });
+        if (repoConfigPath) {
+            console.log(chalk.gray(` Updated repo MCP config at ${repoConfigPath}`));
+        }
+        return {
+            action: "install",
+            changed: true,
+            connectorName: selected.name,
+            assetPath,
+            filePaths,
+            repoConfigPath,
+            inspectedConnector: selected.key,
+        };
+    }
+    if (normalized === "run") {
+        const installed = await getInstalledConnectors();
+        if (installed.length === 0) {
+            console.log(chalk.yellow("\n No connectors installed in this repo yet."));
+            console.log(chalk.gray(" Run: umbrella-context connectors install"));
+            return { action: "run", changed: false };
+        }
+        let selected = target
+            ? installed.find((entry) => entry.id === target || entry.source === target || entry.name.toLowerCase() === target.toLowerCase())
+            : undefined;
+        if (!selected) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a connector to run",
+                choices: installed.map((entry) => ({
+                    title: `${entry.name} (${entry.type})`,
+                    description: entry.description,
+                    value: entry.id,
+                })),
+            });
+            selected = installed.find((entry) => entry.id === answer.value);
+        }
+        if (!selected) {
+            console.log(chalk.yellow("\n No connector selected."));
+            return { action: "run", changed: false };
+        }
+        await setSessionPanel("connectors", selected.source);
+        await recordSessionConnector(selected.source);
+        const execution = await runConnectorCheck({
+            source: selected.source,
+            name: selected.name,
+            type: selected.type,
+        });
+        const effects = execution.status === "success"
+            ? await applyConnectorRunEffects({
+                source: selected.source,
+                name: selected.name,
+                type: selected.type,
+            })
+            : { filePaths: [], stagedMemory: null };
+        const summary = execution.summary || describeConnectorRun(selected.type, selected.name);
+        const run = await addConnectorRun({
+            connectorId: selected.id,
+            connectorName: selected.name,
+            status: execution.status,
+            summary,
+        });
+        const reportPath = await writeConnectorRunReport(run);
+        await recordSessionEvent({
+            kind: "connector",
+            title: `Ran connector ${selected.name}`,
+            detail: summary,
+            panel: "connectors",
+            focus: selected.source,
+            status: execution.status,
+        });
+        if (execution.status === "success") {
+            console.log(chalk.green(`\n Ran ${selected.name}.`));
+        }
+        else {
+            console.log(chalk.red(`\n ${selected.name} failed its repo check.`));
+        }
+        console.log(chalk.gray(` ${summary}`));
+        effects.filePaths.forEach((filePath) => {
+            console.log(chalk.gray(` Wrote connector output ${filePath}`));
+        });
+        if (effects.stagedMemory) {
+            console.log(chalk.gray(` Staged local Context draft ${effects.stagedMemory} in .um pending memories.`));
+        }
+        console.log(chalk.gray(` Saved in .um as connector run ${run.id}.`));
+        console.log(chalk.gray(` Report written to ${reportPath}`));
+        return {
+            action: "run",
+            changed: true,
+            connectorName: selected.name,
+            status: execution.status,
+            summary,
+            filePaths: effects.filePaths,
+            stagedMemoryId: effects.stagedMemory,
+            reportPath,
+            inspectedConnector: selected.source,
+        };
+    }
+    console.log(chalk.red("Use: connectors list | connectors inspect [key|name|id] | connectors recent | connectors outputs [key|name|id] | connectors install [key] | connectors run [key|name|id]"));
+}
+export function connectorsCommand(cli) {
+    cli.command("connectors <action> [target]", "Manage repo connectors for rules, hooks, MCP, and skills").action(async (action, target) => {
+        await connectorsCommandAction(action, target);
+    });
+}

package/dist/commands/curate.d.ts

@@ -2,4 +2,5 @@ export declare function curateCommandAction(content: string, opts?: {
     tag?: string | string[];
     type?: string;
 }): Promise<void>;
+export declare function curateViewCommandAction(): Promise<void>;
 export declare function curateCommand(cli: any): void;