umbrella-context 0.1.2 → 0.1.32

package/dist/config.d.ts

@@ -8,6 +8,22 @@ export interface AgentMemoryConfig {
     projectName: string;
     workspaceId: string;
     workspaceName: string;
+    activeProvider?: string;
+    activeModel?: string;
+}
+export interface SavedProvider {
+    id: string;
+    name: string;
+    kind: string;
+    apiKey?: string;
+    baseUrl?: string;
+    updatedAt: string;
+}
+export interface HubRegistry {
+    id: string;
+    name: string;
+    url: string;
+    updatedAt: string;
 }
 export interface SavedLocation {
     repoRoot: string;
@@ -23,8 +39,15 @@ export declare class ConfigManager {
     get config(): AgentMemoryConfig | null;
     set(config: Partial<AgentMemoryConfig>): void;
     clear(): void;
+    clearUmbrellaSession(): void;
     get locations(): SavedLocation[];
+    get providers(): SavedProvider[];
     upsertLocation(location: SavedLocation): void;
+    upsertProvider(provider: SavedProvider): void;
+    removeProvider(id: string): void;
     get configPath(): string;
+    get hubRegistries(): HubRegistry[];
+    upsertHubRegistry(registry: HubRegistry): void;
+    removeHubRegistry(id: string): void;
 }
 export declare const configManager: ConfigManager;

package/dist/config.js

@@ -21,6 +21,8 @@ export class ConfigManager {
                 projectName: this.conf.get("projectName"),
                 workspaceId: this.conf.get("workspaceId"),
                 workspaceName: this.conf.get("workspaceName"),
+                activeProvider: this.conf.get("activeProvider"),
+                activeModel: this.conf.get("activeModel"),
             }
             : null;
     }
@@ -43,21 +45,88 @@ export class ConfigManager {
             this.conf.set("workspaceId", config.workspaceId);
         if (config.workspaceName)
             this.conf.set("workspaceName", config.workspaceName);
+        if (Object.prototype.hasOwnProperty.call(config, "activeProvider")) {
+            if (config.activeProvider === undefined) {
+                this.conf.delete("activeProvider");
+            }
+            else {
+                this.conf.set("activeProvider", config.activeProvider);
+            }
+        }
+        if (Object.prototype.hasOwnProperty.call(config, "activeModel")) {
+            if (config.activeModel === undefined) {
+                this.conf.delete("activeModel");
+            }
+            else {
+                this.conf.set("activeModel", config.activeModel);
+            }
+        }
     }
     clear() {
         this.conf.clear();
     }
+    clearUmbrellaSession() {
+        this.conf.delete("umbrellaUrl");
+        this.conf.delete("serverUrl");
+        this.conf.delete("apiKey");
+        this.conf.delete("companyId");
+        this.conf.delete("companyName");
+        this.conf.delete("projectId");
+        this.conf.delete("projectName");
+        this.conf.delete("workspaceId");
+        this.conf.delete("workspaceName");
+    }
     get locations() {
         return this.conf.get("locations") ?? [];
     }
+    get providers() {
+        return this.conf.get("providers") ?? [];
+    }
     upsertLocation(location) {
         const locations = this.locations.filter((entry) => entry.repoRoot !== location.repoRoot);
         locations.push(location);
         this.conf.set("locations", locations.sort((a, b) => a.repoRoot.localeCompare(b.repoRoot)));
     }
+    upsertProvider(provider) {
+        const providers = this.providers.filter((entry) => entry.id !== provider.id && entry.name.toLowerCase() !== provider.name.toLowerCase());
+        providers.push(provider);
+        this.conf.set("providers", providers.sort((a, b) => a.name.localeCompare(b.name)));
+    }
+    removeProvider(id) {
+        const providers = this.providers.filter((entry) => entry.id !== id);
+        this.conf.set("providers", providers);
+        const current = this.config;
+        if (current?.activeProvider === id) {
+            this.conf.delete("activeProvider");
+            this.conf.delete("activeModel");
+        }
+    }
     get configPath() {
         return this.conf.path
             ?? path.join(os.homedir(), ".config", "umbrella-context", "config.json");
     }
+    get hubRegistries() {
+        const stored = this.conf.get("hubRegistries") ?? [];
+        if (stored.length > 0) {
+            return stored;
+        }
+        return [
+            {
+                id: "umbrella-default",
+                name: "Umbrella Hub",
+                url: "https://hub.umbrella.local/default",
+                updatedAt: new Date(0).toISOString(),
+            },
+        ];
+    }
+    upsertHubRegistry(registry) {
+        const registries = this.hubRegistries.filter((entry) => entry.id !== registry.id && entry.url !== registry.url);
+        registries.push(registry);
+        this.conf.set("hubRegistries", registries.sort((a, b) => a.name.localeCompare(b.name)));
+    }
+    removeHubRegistry(id) {
+        const registries = this.hubRegistries.filter((entry) => entry.id !== id);
+        this.conf.set("hubRegistries", registries);
+    }
 }
 export const configManager = new ConfigManager();

package/dist/index.js

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 import { cac } from "cac";
 import { setupCommand } from "./commands/setup.js";
 import { loginCommand } from "./commands/login.js";
@@ -8,11 +9,26 @@ import { searchCommand } from "./commands/search.js";
 import { fixCommand } from "./commands/fix.js";
 import { recordCommand } from "./commands/record.js";
 import { mcpCommand } from "./commands/mcp.js";
-import { interactiveCommand } from "./commands/interactive.js";
 import { curateCommand } from "./commands/curate.js";
 import { statusCommand } from "./commands/status.js";
 import { locationsCommand } from "./commands/locations.js";
 import { spaceCommand } from "./commands/space.js";
+import { providersCommand } from "./commands/providers.js";
+import { modelCommand } from "./commands/model.js";
+import { hubCommand } from "./commands/hub.js";
+import { connectorsCommand } from "./commands/connectors.js";
+import { logoutCommand } from "./commands/logout.js";
+import { restartCommand } from "./commands/restart.js";
+import { debugCommand } from "./commands/debug.js";
+import { sessionCommand } from "./commands/session.js";
+import { activityCommand } from "./commands/activity.js";
+import { resetCommand } from "./commands/reset.js";
+import { tuiCommand, runTui } from "./commands/tui.js";
+import { tasksCommand } from "./commands/tasks.js";
+import { treeCommand } from "./commands/tree.js";
+import { transportCommand } from "./commands/transport.js";
+import { bridgeCommand } from "./commands/bridge.js";
+import { curateViewCommandAction } from "./commands/curate.js";
 const cli = cac("umbrella-context");
 cli.option("--config <path>", "Path to config file");
 import { seedCommand } from "./commands/seed.js";
@@ -30,13 +46,33 @@ curateCommand(cli);
 statusCommand(cli);
 locationsCommand(cli);
 spaceCommand(cli);
+providersCommand(cli);
+modelCommand(cli);
+hubCommand(cli);
+connectorsCommand(cli);
+logoutCommand(cli);
+restartCommand(cli);
+debugCommand(cli);
+sessionCommand(cli);
+activityCommand(cli);
+resetCommand(cli);
+tuiCommand(cli);
+tasksCommand(cli);
+treeCommand(cli);
+transportCommand(cli);
+bridgeCommand(cli);
 cli.command("query [...args]", "Alias for search").action(async (args) => {
     const { searchCommandAction } = await import("./commands/search.js");
     await searchCommandAction(args.join(" "));
 });
-cli.command("", "Interactive mode").action(async () => {
-    await interactiveCommand([]);
-});
 cli.help();
-cli.version("0.1.2");
+cli.version("0.1.32");
+const argv = process.argv.slice(2);
+if (argv[0] === "curate" && argv[1] === "view" && argv.length === 2) {
+    await curateViewCommandAction();
+    process.exit(0);
+}
 cli.parse();
+if (process.argv.length <= 2 && process.stdin.isTTY && process.stdout.isTTY) {
+    await runTui();
+}

package/dist/repo-state.d.ts

@@ -1,4 +1,4 @@
-import type { AgentMemoryConfig } from "./config.js";
+import { type AgentMemoryConfig } from "./config.js";
 export type LocalMemoryEntry = {
     id: string;
     content: string;
@@ -34,6 +34,181 @@ export type RepoContextState = {
     lastPushAt: null | string;
     lastPullAt: null | string;
 };
+export type LocalConnectorEntry = {
+    id: string;
+    name: string;
+    type: "hook" | "mcp" | "rule" | "skill";
+    description: string;
+    installedAt: string;
+    source: string;
+};
+export type LocalHubInstall = {
+    id: string;
+    slug: string;
+    name: string;
+    type: "bundle" | "skill" | "connector";
+    description: string;
+    installedAt: string;
+    registryName: string;
+};
+export type LocalConnectorRun = {
+    id: string;
+    connectorId: string;
+    connectorName: string;
+    status: "success" | "failure";
+    summary: string;
+    ranAt: string;
+};
+export type RepoSessionState = {
+    version: 1;
+    id: string;
+    startedAt: string;
+    updatedAt: string;
+    commandHistory: string[];
+    recentQueries: string[];
+    recentCurations: string[];
+    lastSummary: string | null;
+    currentPanel: string | null;
+    currentFocus: string | null;
+    panelHistory: string[];
+    recentProviderIds: string[];
+    recentModels: string[];
+    recentHubSlugs: string[];
+    recentConnectorSources: string[];
+    events: RepoSessionEvent[];
+};
+export type RepoSessionEvent = {
+    id: string;
+    at: string;
+    kind: "query" | "curate" | "push" | "pull" | "space" | "provider" | "model" | "hub" | "connector" | "session";
+    title: string;
+    detail: string | null;
+    panel: string | null;
+    focus: string | null;
+    status: "info" | "success" | "warning" | "failure";
+};
+export type LocalTaskStatus = "queued" | "running" | "completed" | "failed";
+export type LocalTaskKind = "query" | "curate" | "push" | "pull" | "provider" | "model" | "space" | "hub" | "connector" | "setup";
+export type LocalTask = {
+    id: string;
+    kind: LocalTaskKind;
+    title: string;
+    input?: string | null;
+    detail: string | null;
+    status: LocalTaskStatus;
+    sessionId?: string | null;
+    startedAt?: string | null;
+    streamingContent?: string | null;
+    result?: string | null;
+    files?: string[];
+    folders?: string[];
+    reasoningContents?: Array<{
+        content: string;
+        isThinking?: boolean;
+        timestamp: string;
+    }>;
+    toolCalls?: Array<{
+        args: Record<string, unknown>;
+        callId?: string;
+        error?: string;
+        errorType?: string;
+        result?: unknown;
+        sessionId?: string | null;
+        status: "completed" | "error" | "running";
+        timestamp: string;
+        toolName: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+    finishedAt: string | null;
+    panel: string | null;
+    focus: string | null;
+};
+export type RepoTransportEvent = {
+    id: string;
+    at: string;
+    kind: "task-created" | "task-started" | "task-completed" | "task-failed" | "sync-push" | "sync-pull" | "runtime-check" | "context-tree";
+    title: string;
+    detail: string | null;
+    status: "info" | "success" | "warning" | "failure";
+    taskId: string | null;
+};
+export type RepoTransportState = {
+    version: 1;
+    status: "idle" | "running" | "warning" | "failure";
+    activeTaskId: string | null;
+    queue: Array<{
+        id: string;
+        kind: LocalTaskKind;
+        title: string;
+        status: LocalTaskStatus;
+    }>;
+    stats: {
+        queued: number;
+        running: number;
+        completed: number;
+        failed: number;
+    };
+    subscriptions: string[];
+    lastPushAt: string | null;
+    lastPullAt: string | null;
+    lastRuntimeCheckAt: string | null;
+    taskKinds: Partial<Record<LocalTaskKind, number>>;
+    updatedAt: string;
+    events: RepoTransportEvent[];
+};
+export type TaskLifecyclePatch = {
+    detail?: string | null;
+    reason?: string | null;
+    result?: string | null;
+    sessionId?: string | null;
+    status: LocalTaskStatus;
+    streamingContent?: string | null;
+};
+export type TaskToolCallPatch = {
+    args: Record<string, unknown>;
+    callId?: string;
+    error?: string;
+    errorType?: string;
+    result?: unknown;
+    sessionId?: string | null;
+    status: "completed" | "error" | "running";
+    toolName: string;
+};
+export type ContextTreeNode = {
+    id: string;
+    label: string;
+    kind: "company" | "space" | "folder" | "collection" | "runtime" | "summary";
+    parentId: string | null;
+    detail: string | null;
+    count?: number;
+};
+export type RepoContextTreeState = {
+    version: 1;
+    repoRoot: string;
+    umDir: string;
+    generatedAt: string;
+    summaryHandle: string;
+    stats: {
+        pendingDrafts: number;
+        pulledContext: number;
+        pulledFixes: number;
+        hubEntries: number;
+        connectors: number;
+        connectorRuns: number;
+        tasks: number;
+    };
+    runtime: {
+        companyName: string | null;
+        spaceName: string | null;
+        provider: string | null;
+        model: string | null;
+        transportStatus: RepoTransportState["status"];
+        lastPushAt: string | null;
+        lastPullAt: string | null;
+    };
+    nodes: ContextTreeNode[];
+};
 export declare function findRepoRoot(startDir?: string): Promise<string>;
 export declare function ensureRepoContext(config: AgentMemoryConfig, cwd?: string): Promise<string>;
 export declare function getRepoContext(cwd?: string): Promise<{
@@ -45,9 +220,60 @@ export declare function updateRepoContext(updater: (current: RepoContextState) =
 export declare function addPendingMemory(input: Omit<LocalMemoryEntry, "createdAt" | "id">, cwd?: string): Promise<LocalMemoryEntry>;
 export declare function getPendingMemories(cwd?: string): Promise<LocalMemoryEntry[]>;
 export declare function clearPendingMemories(cwd?: string): Promise<void>;
+export declare function resetRepoState(cwd?: string): Promise<{
+    repoRoot: string;
+    umDir: string;
+    resetAt: string;
+}>;
 export declare function setPulledMemories(memories: LocalMemoryEntry[], cwd?: string): Promise<void>;
 export declare function getPulledMemories(cwd?: string): Promise<LocalMemoryEntry[]>;
 export declare function setPulledFixes(fixes: LocalFixEntry[], cwd?: string): Promise<void>;
 export declare function getPulledFixes(cwd?: string): Promise<LocalFixEntry[]>;
 export declare function markPushCompleted(cwd?: string): Promise<RepoContextState>;
+export declare function getInstalledConnectors(cwd?: string): Promise<LocalConnectorEntry[]>;
+export declare function setInstalledConnectors(connectors: LocalConnectorEntry[], cwd?: string): Promise<void>;
+export declare function getInstalledHubEntries(cwd?: string): Promise<LocalHubInstall[]>;
+export declare function setInstalledHubEntries(entries: LocalHubInstall[], cwd?: string): Promise<void>;
+export declare function writeHubAsset(slug: string, content: string, cwd?: string): Promise<string>;
+export declare function writeHubAssetFiles(slug: string, files: Array<{
+    name: string;
+    content: string;
+}>, cwd?: string): Promise<string[]>;
+export declare function writeConnectorAsset(source: string, content: unknown, cwd?: string): Promise<string>;
+export declare function writeConnectorAssetFiles(source: string, files: Array<{
+    name: string;
+    content: string;
+}>, cwd?: string): Promise<string[]>;
+export declare function getConnectorRuns(cwd?: string): Promise<LocalConnectorRun[]>;
+export declare function getTasks(cwd?: string): Promise<LocalTask[]>;
+export declare function getTaskById(taskId: string, cwd?: string): Promise<LocalTask | null>;
+export declare function ensureTransportState(cwd?: string): Promise<RepoTransportState>;
+export declare function getTransportState(cwd?: string): Promise<RepoTransportState>;
+export declare function updateTransportState(updater: (current: RepoTransportState) => RepoTransportState | Promise<RepoTransportState>, cwd?: string): Promise<RepoTransportState>;
+export declare function recordTransportEvent(event: Omit<RepoTransportEvent, "at" | "id">, cwd?: string): Promise<RepoTransportState>;
+export declare function getContextTreeState(cwd?: string): Promise<RepoContextTreeState>;
+export declare function rebuildContextTreeState(cwd?: string): Promise<RepoContextTreeState>;
+export declare function createTask(input: Omit<LocalTask, "createdAt" | "finishedAt" | "id" | "updatedAt">, cwd?: string): Promise<LocalTask>;
+export declare function updateTask(taskId: string, updater: (task: LocalTask) => LocalTask, cwd?: string): Promise<LocalTask | null>;
+export declare function patchTaskLifecycle(taskId: string, patch: TaskLifecyclePatch, cwd?: string): Promise<LocalTask | null>;
+export declare function appendTaskStreamingContent(taskId: string, content: string, cwd?: string): Promise<LocalTask | null>;
+export declare function addTaskReasoningContent(taskId: string, content: string, isThinking?: boolean, cwd?: string): Promise<LocalTask | null>;
+export declare function addTaskToolCall(taskId: string, toolCall: TaskToolCallPatch, cwd?: string): Promise<LocalTask | null>;
+export declare function completeTask(taskId: string, status: "completed" | "failed", detail?: string | null, cwd?: string): Promise<LocalTask | null>;
+export declare function addConnectorRun(input: Omit<LocalConnectorRun, "id" | "ranAt">, cwd?: string): Promise<LocalConnectorRun>;
+export declare function writeConnectorRunReport(run: LocalConnectorRun, cwd?: string): Promise<string>;
+export declare function getSessionState(cwd?: string): Promise<RepoSessionState | null>;
+export declare function ensureSessionState(cwd?: string): Promise<RepoSessionState>;
+export declare function resetSessionState(cwd?: string): Promise<RepoSessionState>;
+export declare function updateSessionState(updater: (current: RepoSessionState) => RepoSessionState | Promise<RepoSessionState>, cwd?: string): Promise<RepoSessionState>;
+export declare function recordSessionCommand(command: string, cwd?: string): Promise<RepoSessionState>;
+export declare function recordSessionQuery(query: string, cwd?: string): Promise<RepoSessionState>;
+export declare function recordSessionCuration(content: string, cwd?: string): Promise<RepoSessionState>;
+export declare function setSessionSummary(summary: string | null, cwd?: string): Promise<RepoSessionState>;
+export declare function setSessionPanel(panel: string | null, focus?: string | null, cwd?: string): Promise<RepoSessionState>;
+export declare function recordSessionProvider(providerId: string, cwd?: string): Promise<RepoSessionState>;
+export declare function recordSessionModel(modelId: string, cwd?: string): Promise<RepoSessionState>;
+export declare function recordSessionHubEntry(slug: string, cwd?: string): Promise<RepoSessionState>;
+export declare function recordSessionConnector(source: string, cwd?: string): Promise<RepoSessionState>;
+export declare function recordSessionEvent(event: Omit<RepoSessionEvent, "at" | "id">, cwd?: string): Promise<RepoSessionState>;
 export declare function summarizeLocalMemoryMatches(entries: LocalMemoryEntry[], query: string): LocalMemoryEntry[];