umbrella-context 0.1.2 → 0.1.20

package/dist/commands/catalog.d.ts

@@ -0,0 +1,33 @@
+import type { AgentMemoryConfig } from "../config.js";
+export type InteractiveContext = {
+    config: AgentMemoryConfig;
+    handleFix: (error: string, config: AgentMemoryConfig) => Promise<void>;
+    handleRecord: (parts: string[], config: AgentMemoryConfig) => Promise<void>;
+    handleSpaces: (config: AgentMemoryConfig) => Promise<void>;
+    handleHome: (config: AgentMemoryConfig) => Promise<void>;
+    handleRecent: (config: AgentMemoryConfig) => Promise<void>;
+    handleTimeline: () => Promise<void>;
+    handleHistory: () => Promise<void>;
+    handleSession: () => Promise<void>;
+    handleNewSession: () => Promise<void>;
+    handleRestart: () => Promise<void>;
+    handleDebug: () => Promise<void>;
+    handleLogout: () => Promise<void>;
+    handlePanel: () => Promise<void>;
+    handleContinue: () => Promise<void>;
+};
+export type CommandSpec = {
+    key: string;
+    usage: string;
+    description: string;
+    aliases?: string[];
+    action: (args: string[], context: InteractiveContext) => Promise<void>;
+};
+export declare const COMMAND_SPECS: CommandSpec[];
+export declare function parseInteractiveInput(input: string): {
+    command: string;
+    args: string[];
+    raw: string;
+};
+export declare function resolveCommand(name: string): CommandSpec | null;
+export declare function renderCommandList(): string;

package/dist/commands/catalog.js

@@ -0,0 +1,211 @@
+import { curateCommandAction } from "./curate.js";
+import { pushCommandAction } from "./push.js";
+import { pullCommandAction } from "./pull.js";
+import { searchCommandAction } from "./search.js";
+import { statusCommandAction } from "./status.js";
+import { providersCommandAction } from "./providers.js";
+import { modelCommandAction } from "./model.js";
+import { spaceCommandAction } from "./space.js";
+import { locationsCommandAction } from "./locations.js";
+import { hubCommandAction } from "./hub.js";
+import { connectorsCommandAction } from "./connectors.js";
+export const COMMAND_SPECS = [
+    {
+        key: "home",
+        usage: "/home",
+        aliases: ["dashboard"],
+        description: "Show the current Context home view",
+        action: async (_args, context) => context.handleHome(context.config),
+    },
+    {
+        key: "curate",
+        usage: "/curate <content>",
+        description: "Save a local context note into .um",
+        action: async (args) => {
+            if (args[0] === "view") {
+                const { curateViewCommandAction } = await import("./curate.js");
+                await curateViewCommandAction();
+                return;
+            }
+            await curateCommandAction(args.join(" "));
+        },
+    },
+    {
+        key: "query",
+        usage: "/query <question>",
+        aliases: ["search"],
+        description: "Search local context first, then the server",
+        action: async (args) => searchCommandAction(args.join(" ")),
+    },
+    {
+        key: "push",
+        usage: "/push",
+        description: "Sync local .um notes to the server",
+        action: async () => pushCommandAction(),
+    },
+    {
+        key: "pull",
+        usage: "/pull",
+        description: "Refresh the local .um snapshot from the server",
+        action: async () => pullCommandAction(),
+    },
+    {
+        key: "fix",
+        usage: "/fix <error>",
+        description: "Search known fixes",
+        action: async (args, context) => context.handleFix(args.join(" "), context.config),
+    },
+    {
+        key: "record",
+        usage: "/record <id> <success|failure>",
+        description: "Record whether a known fix worked",
+        action: async (args, context) => context.handleRecord(args, context.config),
+    },
+    {
+        key: "space",
+        usage: "/space list | /space switch",
+        aliases: ["spaces", "projects"],
+        description: "List or switch company spaces",
+        action: async (args, context) => {
+            if (args[0] === "list" || args[0] === "switch") {
+                await spaceCommandAction(args[0], args[1]);
+                return;
+            }
+            await context.handleSpaces(context.config);
+        },
+    },
+    {
+        key: "providers",
+        usage: "/providers list|inspect|recent|test|connect|switch|disconnect",
+        description: "Manage LLM providers on this device",
+        action: async (args) => {
+            await providersCommandAction(args[0] ?? "list");
+        },
+    },
+    {
+        key: "model",
+        usage: "/model list|inspect|recent|ready|switch",
+        description: "Choose the active model for the current provider",
+        action: async (args) => {
+            await modelCommandAction(args[0] ?? "list");
+        },
+    },
+    {
+        key: "status",
+        usage: "/status",
+        description: "Show current sync and model status",
+        action: async () => statusCommandAction(),
+    },
+    {
+        key: "panel",
+        usage: "/panel",
+        aliases: ["focus"],
+        description: "Show the current live session panel and focus",
+        action: async (_args, context) => context.handlePanel(),
+    },
+    {
+        key: "continue",
+        usage: "/continue",
+        aliases: ["resume"],
+        description: "Re-open the last session panel or focus",
+        action: async (_args, context) => context.handleContinue(),
+    },
+    {
+        key: "locations",
+        usage: "/locations",
+        description: "List repos connected on this device",
+        action: async () => locationsCommandAction(),
+    },
+    {
+        key: "recent",
+        usage: "/recent",
+        aliases: ["activity"],
+        description: "Show recent local drafts, pulls, and connector runs",
+        action: async (_args, context) => context.handleRecent(context.config),
+    },
+    {
+        key: "timeline",
+        usage: "/timeline",
+        aliases: ["events"],
+        description: "Show the recent session timeline for this repo",
+        action: async (_args, context) => context.handleTimeline(),
+    },
+    {
+        key: "history",
+        usage: "/history",
+        description: "Show commands used in this session",
+        action: async (_args, context) => context.handleHistory(),
+    },
+    {
+        key: "session",
+        usage: "/session",
+        description: "Show the current terminal session summary",
+        action: async (_args, context) => context.handleSession(),
+    },
+    {
+        key: "new",
+        usage: "/new",
+        description: "Start a fresh terminal session without clearing repo context data",
+        action: async (_args, context) => context.handleNewSession(),
+    },
+    {
+        key: "restart",
+        usage: "/restart",
+        description: "Refresh the live terminal session and keep local .um data",
+        action: async (_args, context) => context.handleRestart(),
+    },
+    {
+        key: "debug",
+        usage: "/debug",
+        description: "Show config paths, repo state, and session details",
+        action: async (_args, context) => context.handleDebug(),
+    },
+    {
+        key: "logout",
+        usage: "/logout",
+        description: "Disconnect this device from Umbrella Context",
+        action: async (_args, context) => context.handleLogout(),
+    },
+    {
+        key: "hub",
+        usage: "/hub list|install|inspect|recent|installed|registry",
+        description: "Browse, inspect, and install bundles, skills, and hub registries",
+        action: async (args) => {
+            await hubCommandAction(args[0] ?? "list", args[1]);
+        },
+    },
+    {
+        key: "connectors",
+        usage: "/connectors list|inspect|recent|outputs|install|run",
+        description: "Install and run repo connectors for hooks, MCP, rules, and skills",
+        action: async (args) => {
+            await connectorsCommandAction(args[0] ?? "list", args[1]);
+        },
+    },
+];
+function tokenizeInput(raw) {
+    const matches = raw.match(/"([^"]*)"|'([^']*)'|`([^`]*)`|[^\s]+/g) ?? [];
+    return matches.map((part) => part.replace(/^['"`]|['"`]$/g, ""));
+}
+export function parseInteractiveInput(input) {
+    const trimmed = input.trim();
+    const normalized = trimmed.startsWith("/") ? trimmed.slice(1) : trimmed;
+    const tokens = tokenizeInput(normalized);
+    const command = (tokens[0] ?? "").toLowerCase();
+    const args = tokens.slice(1);
+    return { command, args, raw: trimmed };
+}
+export function resolveCommand(name) {
+    return COMMAND_SPECS.find((entry) => entry.key === name || entry.aliases?.includes(name)) ?? null;
+}
+export function renderCommandList() {
+    const rows = COMMAND_SPECS.map((entry) => `${entry.usage.padEnd(34)} ${entry.description}`);
+    return [
+        "COMMANDS",
+        "------------------------------------------------------------",
+        ...rows,
+        "------------------------------------------------------------",
+        "/help or /                 Show this command list",
+        "/exit                      Quit",
+    ].join("\n");
+}

package/dist/commands/connect.js

@@ -17,14 +17,14 @@ export function connectCommand(cli) {
         .option("--api-key <key>", "Context API key")
         .action(async (options) => {
         const serverUrl = options.serverUrl?.trim();
-        const workspaceId = options.workspaceId?.trim();
-        const workspaceName = options.workspaceName?.trim();
-        const companyId = options.companyId?.trim() ?? workspaceId;
-        const companyName = options.companyName?.trim() ?? workspaceName;
-        const projectId = options.spaceId?.trim() ?? options.projectId?.trim();
-        const projectName = options.spaceName?.trim() ?? options.projectName?.trim();
+        const companyId = options.companyId?.trim() ?? options.workspaceId?.trim();
+        const companyName = options.companyName?.trim() ?? options.workspaceName?.trim();
+        const spaceId = options.spaceId?.trim() ?? options.projectId?.trim();
+        const spaceName = options.spaceName?.trim() ?? options.projectName?.trim();
+        const workspaceId = options.workspaceId?.trim() ?? companyId;
+        const workspaceName = options.workspaceName?.trim() ?? companyName;
         const apiKey = options.apiKey?.trim();
-        if (!serverUrl || !workspaceId || !workspaceName || !projectId || !projectName || !apiKey) {
+        if (!serverUrl || !companyId || !companyName || !spaceId || !spaceName || !apiKey) {
             console.log(chalk.red("\n Missing required connection details."));
             return;
         }
@@ -46,20 +46,20 @@ export function connectCommand(cli) {
                 companyName,
                 workspaceId,
                 workspaceName,
-                projectId,
-                projectName,
+                projectId: spaceId,
+                projectName: spaceName,
                 apiKey,
             });
             configManager.upsertLocation({
                 repoRoot: process.cwd(),
-                companyId: companyId ?? workspaceId,
-                companyName: companyName ?? workspaceName,
-                projectId,
-                projectName,
+                companyId,
+                companyName,
+                projectId: spaceId,
+                projectName: spaceName,
                 updatedAt: new Date().toISOString(),
             });
             await ensureRepoContext(configManager.config);
-            console.log(chalk.green(`\n Connected: ${companyName} / ${projectName}`));
+            console.log(chalk.green(`\n Connected: ${companyName} / ${spaceName}`));
             console.log(chalk.gray(` Config saved to ${configManager.configPath}`));
         }
         catch (err) {

package/dist/commands/connectors.d.ts

@@ -0,0 +1,15 @@
+export type ConnectorsCommandResult = {
+    action: "list" | "install" | "run" | "inspect" | "outputs";
+    changed: boolean;
+    connectorName?: string;
+    status?: "success" | "failure";
+    summary?: string;
+    assetPath?: string;
+    filePaths?: string[];
+    repoConfigPath?: string | null;
+    stagedMemoryId?: string | null;
+    reportPath?: string;
+    inspectedConnector?: string;
+};
+export declare function connectorsCommandAction(action: string, target?: string): Promise<ConnectorsCommandResult | void>;
+export declare function connectorsCommand(cli: any): void;