umbrella-context 0.1.2 → 0.1.32

package/bin/um.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "../dist/index.js";

package/dist/adapters/byterover-context-runtime-store.d.ts

@@ -0,0 +1,15 @@
+import { type VendorBridgeRuntimeSnapshot } from "./byterover-runtime-bridge.js";
+export declare const useUmbrellaContextRuntimeBridgeStore: any;
+export declare function hydrateUmbrellaContextRuntimeBridgeFromSnapshot(snapshot: VendorBridgeRuntimeSnapshot): void;
+export declare function hydrateUmbrellaContextRuntimeBridge(cwd?: string): Promise<VendorBridgeRuntimeSnapshot>;
+export declare function getUmbrellaContextRuntimeSummary(): {
+    companyName: any;
+    generatedAt: any;
+    isHydrated: any;
+    modelName: any;
+    providerName: any;
+    runtimeStatus: any;
+    spaceCount: any;
+    spaceName: any;
+    treeNodes: any;
+};

package/dist/adapters/byterover-context-runtime-store.js

@@ -0,0 +1,57 @@
+import { create } from "zustand";
+import { buildVendorRuntimeBridgeSnapshot, } from "./byterover-runtime-bridge.js";
+const initialContextRuntimeState = {
+    company: { id: null, name: null },
+    connectorsStore: null,
+    generatedAt: null,
+    hubStore: null,
+    isHydrated: false,
+    modelStore: null,
+    providerStore: null,
+    repo: null,
+    services: null,
+    space: { id: null, name: null },
+    spaceStore: null,
+    treeStore: null,
+};
+export const useUmbrellaContextRuntimeBridgeStore = create()((set) => ({
+    ...initialContextRuntimeState,
+    hydrateFromSnapshot: (snapshot) => set({
+        company: snapshot.company,
+        connectorsStore: snapshot.stores.connectors,
+        generatedAt: snapshot.generatedAt,
+        hubStore: snapshot.stores.hub,
+        isHydrated: true,
+        modelStore: snapshot.stores.model,
+        providerStore: snapshot.stores.provider,
+        repo: snapshot.repo,
+        services: snapshot.services,
+        space: snapshot.space,
+        spaceStore: snapshot.stores.space,
+        treeStore: snapshot.stores.contextTree,
+    }),
+    reset: () => set(initialContextRuntimeState),
+}));
+export function hydrateUmbrellaContextRuntimeBridgeFromSnapshot(snapshot) {
+    useUmbrellaContextRuntimeBridgeStore.getState().hydrateFromSnapshot(snapshot);
+}
+export async function hydrateUmbrellaContextRuntimeBridge(cwd = process.cwd()) {
+    const snapshot = await buildVendorRuntimeBridgeSnapshot(cwd);
+    hydrateUmbrellaContextRuntimeBridgeFromSnapshot(snapshot);
+    return snapshot;
+}
+export function getUmbrellaContextRuntimeSummary() {
+    const state = useUmbrellaContextRuntimeBridgeStore.getState();
+    return {
+        companyName: state.company.name,
+        generatedAt: state.generatedAt,
+        isHydrated: state.isHydrated,
+        modelName: state.modelStore?.activeModel ?? null,
+        providerName: state.providerStore?.providers.find((provider) => provider.id === state.providerStore?.activeProviderId)?.name ??
+            null,
+        runtimeStatus: state.treeStore?.runtime.transportStatus ?? "idle",
+        spaceCount: state.spaceStore?.spaces.length ?? 0,
+        spaceName: state.space.name,
+        treeNodes: state.treeStore?.nodes.length ?? 0,
+    };
+}

package/dist/adapters/byterover-runtime-bridge.d.ts

@@ -0,0 +1,218 @@
+import { type ContextTreeNode, type LocalConnectorEntry, type LocalConnectorRun, type LocalHubInstall, type RepoContextTreeState, type RepoTransportEvent, type RepoTransportState } from "../repo-state.js";
+export type VendorBridgeConnectionState = "connected" | "connecting" | "disconnected";
+export type VendorBridgeTaskStatus = "cancelled" | "completed" | "created" | "error" | "started";
+export type VendorBridgeTaskType = "curate" | "query";
+export type VendorBridgeToolCallEvent = {
+    args: Record<string, unknown>;
+    callId?: string;
+    error?: string;
+    errorType?: string;
+    result?: unknown;
+    sessionId?: string | null;
+    status: "completed" | "error" | "running";
+    timestamp: number;
+    toolName: string;
+};
+export type VendorBridgeReasoningContentItem = {
+    content: string;
+    isThinking?: boolean;
+    timestamp: number;
+};
+export type VendorBridgeTask = {
+    completedAt?: number;
+    content: string;
+    createdAt: number;
+    error?: {
+        message: string;
+    };
+    files?: string[];
+    folders?: string[];
+    input: string;
+    isStreaming?: boolean;
+    reasoningContents?: VendorBridgeReasoningContentItem[];
+    result?: string;
+    sessionId?: string;
+    startedAt?: number;
+    status: VendorBridgeTaskStatus;
+    streamingContent?: string;
+    taskId: string;
+    toolCalls: VendorBridgeToolCallEvent[];
+    type: VendorBridgeTaskType;
+};
+export type VendorBridgeTasksState = {
+    recentTaskIds: string[];
+    stats: {
+        cancelled: number;
+        completed: number;
+        created: number;
+        error: number;
+        started: number;
+    };
+    tasks: Record<string, VendorBridgeTask>;
+};
+export type VendorBridgeTransportState = {
+    connectionState: VendorBridgeConnectionState;
+    error: string | null;
+    eventCount: number;
+    events: Array<{
+        at: number;
+        detail: string | null;
+        kind: RepoTransportEvent["kind"];
+        status: RepoTransportEvent["status"];
+        taskId: string | null;
+        title: string;
+    }>;
+    isConnected: boolean;
+    lastPullAt: number | null;
+    lastPushAt: number | null;
+    lastRuntimeCheckAt: number | null;
+    queue: RepoTransportState["queue"];
+    reconnectCount: number;
+    status: RepoTransportState["status"];
+    subscriptions: string[];
+    updatedAt: number;
+    version: string;
+};
+export type VendorBridgeContextTreeState = {
+    generatedAt: number;
+    nodes: Array<ContextTreeNode & {
+        depth: number;
+    }>;
+    runtime: RepoContextTreeState["runtime"];
+    stats: RepoContextTreeState["stats"];
+    summaryHandle: string;
+};
+export type VendorBridgeRuntimeSnapshot = {
+    company: {
+        id: string | null;
+        name: string | null;
+    };
+    generatedAt: string;
+    repo: {
+        pendingDrafts: number;
+        pulledContext: number;
+        pulledFixes: number;
+        repoRoot: string;
+        umDir: string;
+    };
+    services: {
+        activeModel: string | null;
+        activeProvider: string | null;
+        connectorsInstalled: number;
+        connectorRuns: number;
+        hubEntriesInstalled: number;
+    };
+    space: {
+        id: string | null;
+        name: string | null;
+    };
+    stores: {
+        connectors: VendorBridgeConnectorsState;
+        contextTree: VendorBridgeContextTreeState;
+        hub: VendorBridgeHubState;
+        model: VendorBridgeModelState;
+        provider: VendorBridgeProviderState;
+        space: VendorBridgeSpaceState;
+        tasks: VendorBridgeTasksState;
+        transport: VendorBridgeTransportState;
+    };
+    vendorParityTargets: readonly string[];
+};
+export type VendorBridgeProviderState = {
+    activeProviderId: string | null;
+    isLoading: boolean;
+    providers: Array<{
+        baseUrl?: string;
+        hasApiKey: boolean;
+        id: string;
+        kind: string;
+        name: string;
+        updatedAt: number | null;
+    }>;
+};
+export type VendorBridgeModelState = {
+    activeModel: string | null;
+    favorites: string[];
+    isLoading: boolean;
+    models: Array<{
+        id: string;
+        isActive: boolean;
+        label: string;
+        providerId: string | null;
+    }>;
+    recent: string[];
+};
+export type VendorBridgeSpaceState = {
+    activeSpaceId: string | null;
+    activeSpaceName: string | null;
+    companyId: string | null;
+    companyName: string | null;
+    isLoading: boolean;
+    spaces: Array<{
+        id: string;
+        isPrimary: boolean;
+        isSelected: boolean;
+        name: string;
+    }>;
+};
+export type VendorBridgeHubState = {
+    installed: LocalHubInstall[];
+    installedSlugs: string[];
+    isLoading: boolean;
+    recentSlug: string | null;
+    registryCount: number;
+};
+export type VendorBridgeConnectorsState = {
+    installed: LocalConnectorEntry[];
+    installedSources: string[];
+    isLoading: boolean;
+    recentRunSource: string | null;
+    recentSource: string | null;
+    runs: LocalConnectorRun[];
+};
+export declare function buildVendorRuntimeBridgeSnapshot(cwd?: string): Promise<VendorBridgeRuntimeSnapshot>;
+export declare function buildVendorRuntimeBridgeSummary(cwd?: string): Promise<{
+    company: string;
+    repoRoot: string;
+    space: string;
+    tasks: {
+        completed: number;
+        created: number;
+        error: number;
+        started: number;
+        total: number;
+    };
+    transport: {
+        connectionState: VendorBridgeConnectionState;
+        events: number;
+        queueDepth: number;
+        status: "failure" | "warning" | "running" | "idle";
+    };
+    provider: {
+        active: string | null;
+        count: number;
+    };
+    model: {
+        active: string | null;
+        count: number;
+    };
+    spaces: {
+        active: string | null;
+        count: number;
+    };
+    hub: {
+        installed: number;
+        recent: string | null;
+    };
+    connectors: {
+        installed: number;
+        recent: string | null;
+        runs: number;
+    };
+    tree: {
+        nodes: number;
+        runtimeProvider: string | null;
+        runtimeStatus: "failure" | "warning" | "running" | "idle";
+        summaryHandle: string;
+    };
+}>;

package/dist/adapters/byterover-runtime-bridge.js

@@ -0,0 +1,343 @@
+import { configManager } from "../config.js";
+import { getModelsForActiveProvider } from "../commands/model.js";
+import { getConnectorRuns, getContextTreeState, getInstalledConnectors, getInstalledHubEntries, getPendingMemories, getPulledFixes, getPulledMemories, getRepoContext, getSessionState, getTasks, getTransportState, } from "../repo-state.js";
+import { getCompanyContextSummary, toContextSpaces } from "../umbrella.js";
+function toEpoch(value) {
+    if (!value)
+        return null;
+    const next = Date.parse(value);
+    return Number.isNaN(next) ? null : next;
+}
+function mapTransportConnectionState(status) {
+    if (status === "running")
+        return "connecting";
+    if (status === "failure")
+        return "disconnected";
+    return "connected";
+}
+function mapTaskStatus(task) {
+    if (task.status === "completed")
+        return "completed";
+    if (task.status === "failed")
+        return "error";
+    if (task.status === "running")
+        return "started";
+    return "created";
+}
+function mapTaskType(task) {
+    return task.kind === "curate" ? "curate" : "query";
+}
+function mapTask(task) {
+    return {
+        completedAt: toEpoch(task.finishedAt ?? null) ?? undefined,
+        content: task.detail ?? task.title,
+        createdAt: toEpoch(task.createdAt) ?? Date.now(),
+        error: task.status === "failed" ? { message: task.detail ?? task.result ?? "Task failed" } : undefined,
+        files: task.files,
+        folders: task.folders,
+        input: task.input ?? task.focus ?? task.title,
+        isStreaming: Boolean(task.streamingContent && task.status === "running"),
+        reasoningContents: (task.reasoningContents ?? []).map((item) => ({
+            content: item.content,
+            isThinking: item.isThinking,
+            timestamp: toEpoch(item.timestamp) ?? Date.now(),
+        })),
+        result: task.result ?? undefined,
+        sessionId: task.sessionId ?? undefined,
+        startedAt: toEpoch(task.startedAt ?? null) ?? undefined,
+        status: mapTaskStatus(task),
+        streamingContent: task.streamingContent ?? undefined,
+        taskId: task.id,
+        toolCalls: (task.toolCalls ?? []).map((call) => ({
+            args: call.args,
+            callId: call.callId,
+            error: call.error,
+            errorType: call.errorType,
+            result: call.result,
+            sessionId: call.sessionId,
+            status: call.status,
+            timestamp: toEpoch(call.timestamp) ?? Date.now(),
+            toolName: call.toolName,
+        })),
+        type: mapTaskType(task),
+    };
+}
+function buildTaskStats(tasks) {
+    return tasks.reduce((acc, task) => {
+        if (task.status === "created")
+            acc.created += 1;
+        else if (task.status === "started")
+            acc.started += 1;
+        else if (task.status === "completed")
+            acc.completed += 1;
+        else if (task.status === "error")
+            acc.error += 1;
+        else
+            acc.cancelled += 1;
+        return acc;
+    }, { cancelled: 0, completed: 0, created: 0, error: 0, started: 0 });
+}
+function buildNodeDepthMap(nodes) {
+    const byId = new Map(nodes.map((node) => [node.id, node]));
+    const depthCache = new Map();
+    const getDepth = (node) => {
+        if (depthCache.has(node.id))
+            return depthCache.get(node.id) ?? 0;
+        if (!node.parentId || !byId.has(node.parentId)) {
+            depthCache.set(node.id, 0);
+            return 0;
+        }
+        const parent = byId.get(node.parentId);
+        const depth = getDepth(parent) + 1;
+        depthCache.set(node.id, depth);
+        return depth;
+    };
+    return nodes.map((node) => ({ ...node, depth: getDepth(node) }));
+}
+function buildTransportSnapshot(transport) {
+    const connectionState = mapTransportConnectionState(transport.status);
+    return {
+        connectionState,
+        error: transport.status === "failure" ? "Transport entered failure state" : null,
+        eventCount: transport.events.length,
+        events: transport.events.map((event) => ({
+            at: toEpoch(event.at) ?? Date.now(),
+            detail: event.detail,
+            kind: event.kind,
+            status: event.status,
+            taskId: event.taskId,
+            title: event.title,
+        })),
+        isConnected: connectionState === "connected",
+        lastPullAt: toEpoch(transport.lastPullAt),
+        lastPushAt: toEpoch(transport.lastPushAt),
+        lastRuntimeCheckAt: toEpoch(transport.lastRuntimeCheckAt),
+        queue: transport.queue,
+        reconnectCount: transport.status === "running" ? 1 : 0,
+        status: transport.status,
+        subscriptions: transport.subscriptions,
+        updatedAt: toEpoch(transport.updatedAt) ?? Date.now(),
+        version: "umbrella-bridge-1",
+    };
+}
+async function buildProviderSnapshot() {
+    const activeProviderId = configManager.config?.activeProvider ?? null;
+    return {
+        activeProviderId,
+        isLoading: false,
+        providers: configManager.providers.map((provider) => ({
+            baseUrl: provider.baseUrl,
+            hasApiKey: Boolean(provider.apiKey),
+            id: provider.id,
+            kind: provider.kind,
+            name: provider.name,
+            updatedAt: toEpoch(provider.updatedAt),
+        })),
+    };
+}
+async function buildModelSnapshot() {
+    const activeProviderId = configManager.config?.activeProvider ?? null;
+    const activeModel = configManager.config?.activeModel ?? null;
+    const models = getModelsForActiveProvider();
+    const sessionState = await import("../repo-state.js").then((mod) => mod.getSessionState());
+    return {
+        activeModel,
+        favorites: activeModel ? [activeModel] : [],
+        isLoading: false,
+        models: models.map((model) => ({
+            id: model,
+            isActive: model === activeModel,
+            label: model,
+            providerId: activeProviderId,
+        })),
+        recent: sessionState?.recentModels ?? [],
+    };
+}
+async function buildSpaceSnapshot(cwd = process.cwd()) {
+    const repoContext = await getRepoContext(cwd);
+    const config = configManager.config;
+    if (!config?.umbrellaUrl) {
+        return {
+            activeSpaceId: repoContext.state?.projectId ?? null,
+            activeSpaceName: repoContext.state?.projectName ?? null,
+            companyId: repoContext.state?.companyId ?? null,
+            companyName: repoContext.state?.companyName ?? null,
+            isLoading: false,
+            spaces: repoContext.state
+                ? [
+                    {
+                        id: repoContext.state.projectId,
+                        isPrimary: true,
+                        isSelected: true,
+                        name: repoContext.state.projectName,
+                    },
+                ]
+                : [],
+        };
+    }
+    const summary = await getCompanyContextSummary(config.umbrellaUrl, config.companyId);
+    const spaces = toContextSpaces(summary);
+    return {
+        activeSpaceId: config.projectId,
+        activeSpaceName: config.projectName,
+        companyId: config.companyId,
+        companyName: config.companyName,
+        isLoading: false,
+        spaces: spaces.map((space) => ({
+            id: space.id,
+            isPrimary: space.isPrimary,
+            isSelected: space.id === config.projectId,
+            name: space.name,
+        })),
+    };
+}
+async function buildHubSnapshot(cwd = process.cwd()) {
+    const [installed, sessionState] = await Promise.all([getInstalledHubEntries(cwd), getSessionState(cwd)]);
+    return {
+        installed,
+        installedSlugs: installed.map((entry) => entry.slug),
+        isLoading: false,
+        recentSlug: sessionState?.recentHubSlugs?.[0] ?? null,
+        registryCount: 3,
+    };
+}
+async function buildConnectorsSnapshot(cwd = process.cwd()) {
+    const [installed, runs, sessionState] = await Promise.all([
+        getInstalledConnectors(cwd),
+        getConnectorRuns(cwd),
+        getSessionState(cwd),
+    ]);
+    return {
+        installed,
+        installedSources: installed.map((entry) => entry.source),
+        isLoading: false,
+        recentRunSource: runs[0]?.source ?? null,
+        recentSource: sessionState?.recentConnectorSources?.[0] ?? null,
+        runs,
+    };
+}
+export async function buildVendorRuntimeBridgeSnapshot(cwd = process.cwd()) {
+    const [repoContext, pending, pulled, fixes, hubEntries, connectors, connectorRuns, localTasks, transport, contextTree, providerStore, modelStore, spaceStore, hubStore, connectorsStore,] = await Promise.all([
+        getRepoContext(cwd),
+        getPendingMemories(cwd),
+        getPulledMemories(cwd),
+        getPulledFixes(cwd),
+        getInstalledHubEntries(cwd),
+        getInstalledConnectors(cwd),
+        getConnectorRuns(cwd),
+        getTasks(cwd),
+        getTransportState(cwd),
+        getContextTreeState(cwd),
+        buildProviderSnapshot(),
+        buildModelSnapshot(),
+        buildSpaceSnapshot(cwd),
+        buildHubSnapshot(cwd),
+        buildConnectorsSnapshot(cwd),
+    ]);
+    const activeProvider = configManager.providers.find((entry) => entry.id === configManager.config?.activeProvider) ?? null;
+    const mappedTasks = localTasks.map(mapTask);
+    const tasksState = {
+        recentTaskIds: mappedTasks.map((task) => task.taskId),
+        stats: buildTaskStats(mappedTasks),
+        tasks: Object.fromEntries(mappedTasks.map((task) => [task.taskId, task])),
+    };
+    return {
+        company: {
+            id: repoContext.state?.companyId ?? null,
+            name: repoContext.state?.companyName ?? null,
+        },
+        generatedAt: new Date().toISOString(),
+        repo: {
+            pendingDrafts: pending.length,
+            pulledContext: pulled.length,
+            pulledFixes: fixes.length,
+            repoRoot: repoContext.repoRoot,
+            umDir: repoContext.umDir,
+        },
+        services: {
+            activeModel: configManager.config?.activeModel ?? null,
+            activeProvider: activeProvider ? `${activeProvider.name} (${activeProvider.kind})` : null,
+            connectorsInstalled: connectors.length,
+            connectorRuns: connectorRuns.length,
+            hubEntriesInstalled: hubEntries.length,
+        },
+        space: {
+            id: repoContext.state?.projectId ?? null,
+            name: repoContext.state?.projectName ?? null,
+        },
+        stores: {
+            connectors: connectorsStore,
+            contextTree: {
+                generatedAt: toEpoch(contextTree.generatedAt) ?? Date.now(),
+                nodes: buildNodeDepthMap(contextTree.nodes),
+                runtime: contextTree.runtime,
+                stats: contextTree.stats,
+                summaryHandle: contextTree.summaryHandle,
+            },
+            hub: hubStore,
+            model: modelStore,
+            provider: providerStore,
+            space: spaceStore,
+            tasks: tasksState,
+            transport: buildTransportSnapshot(transport),
+        },
+        vendorParityTargets: [
+            "tui/stores/transport-store",
+            "tui/features/tasks/tasks/stores/tasks-store",
+            "agent/infra/map/context-tree-store",
+            "tui/features/provider/provider/stores/provider-store",
+            "tui/features/model/model/stores/model-store",
+            "tui/features/space/space/api/get-spaces",
+            "tui/features/hub/hub",
+            "tui/features/connectors/connectors",
+        ],
+    };
+}
+export async function buildVendorRuntimeBridgeSummary(cwd = process.cwd()) {
+    const snapshot = await buildVendorRuntimeBridgeSnapshot(cwd);
+    return {
+        company: snapshot.company.name ?? "Unlinked company",
+        repoRoot: snapshot.repo.repoRoot,
+        space: snapshot.space.name ?? "Unlinked space",
+        tasks: {
+            completed: snapshot.stores.tasks.stats.completed,
+            created: snapshot.stores.tasks.stats.created,
+            error: snapshot.stores.tasks.stats.error,
+            started: snapshot.stores.tasks.stats.started,
+            total: snapshot.stores.tasks.recentTaskIds.length,
+        },
+        transport: {
+            connectionState: snapshot.stores.transport.connectionState,
+            events: snapshot.stores.transport.eventCount,
+            queueDepth: snapshot.stores.transport.queue.length,
+            status: snapshot.stores.transport.status,
+        },
+        provider: {
+            active: snapshot.stores.provider.providers.find((provider) => provider.id === snapshot.stores.provider.activeProviderId)?.name ?? null,
+            count: snapshot.stores.provider.providers.length,
+        },
+        model: {
+            active: snapshot.stores.model.activeModel,
+            count: snapshot.stores.model.models.length,
+        },
+        spaces: {
+            active: snapshot.stores.space.activeSpaceName,
+            count: snapshot.stores.space.spaces.length,
+        },
+        hub: {
+            installed: snapshot.stores.hub.installed.length,
+            recent: snapshot.stores.hub.recentSlug,
+        },
+        connectors: {
+            installed: snapshot.stores.connectors.installed.length,
+            recent: snapshot.stores.connectors.recentSource,
+            runs: snapshot.stores.connectors.runs.length,
+        },
+        tree: {
+            nodes: snapshot.stores.contextTree.nodes.length,
+            runtimeProvider: snapshot.stores.contextTree.runtime.provider,
+            runtimeStatus: snapshot.stores.contextTree.runtime.transportStatus,
+            summaryHandle: snapshot.stores.contextTree.summaryHandle,
+        },
+    };
+}

package/dist/adapters/byterover-transport-task-store.d.ts

@@ -0,0 +1,13 @@
+import { type VendorBridgeRuntimeSnapshot } from "./byterover-runtime-bridge.js";
+export declare const useUmbrellaTransportTaskBridgeStore: any;
+export declare function hydrateUmbrellaTransportTaskBridgeFromSnapshot(snapshot: VendorBridgeRuntimeSnapshot): void;
+export declare function hydrateUmbrellaTransportTaskBridge(cwd?: string): Promise<VendorBridgeRuntimeSnapshot>;
+export declare function getUmbrellaTransportTaskBridgeSummary(): {
+    activeTaskId: any;
+    generatedAt: any;
+    isHydrated: any;
+    queueDepth: any;
+    recentTaskCount: any;
+    startedTasks: any;
+    transportStatus: any;
+};