umbrella-context 0.1.2 → 0.1.32

package/dist/commands/search.js

@@ -1,6 +1,6 @@
 import chalk from "chalk";
 import { configManager } from "../config.js";
-import { getPendingMemories, getPulledMemories, summarizeLocalMemoryMatches } from "../repo-state.js";
+import { addTaskReasoningContent, addTaskToolCall, appendTaskStreamingContent, completeTask, createTask, getPendingMemories, getPulledMemories, patchTaskLifecycle, recordSessionEvent, recordSessionQuery, setSessionPanel, summarizeLocalMemoryMatches, } from "../repo-state.js";
 export async function searchCommandAction(query) {
     const config = configManager.config;
     if (!config) {
@@ -8,20 +8,75 @@ export async function searchCommandAction(query) {
         return;
     }
     try {
+        await setSessionPanel("query", query);
+        await recordSessionQuery(query);
+        const task = await createTask({
+            kind: "query",
+            title: `Query: ${query}`,
+            detail: "Searching local .um notes and shared server memory.",
+            status: "running",
+            panel: "query",
+            focus: query,
+        });
         const localMatches = summarizeLocalMemoryMatches([...(await getPendingMemories()), ...(await getPulledMemories())], query);
+        await addTaskReasoningContent(task.id, `Checked local repo context first and found ${localMatches.length} candidate match${localMatches.length === 1 ? "" : "es"}.`);
+        await addTaskToolCall(task.id, {
+            toolName: "server.memory.search",
+            status: "running",
+            args: { query },
+        });
+        await patchTaskLifecycle(task.id, {
+            status: "running",
+            detail: `Local scan complete. Querying shared memory for "${query}".`,
+            reason: "Moved from local scan to shared search.",
+        });
+        await appendTaskStreamingContent(task.id, `local=${localMatches.length};`);
         const res = await fetch(`${config.serverUrl}/api/memories/search?query=${encodeURIComponent(query)}`, {
             headers: { Authorization: `Bearer ${config.apiKey}` },
         });
         if (!res.ok) {
             const err = await res.json();
+            await addTaskToolCall(task.id, {
+                toolName: "server.memory.search",
+                status: "error",
+                args: { query },
+                error: err.error,
+            });
+            await completeTask(task.id, "failed", err.error || "Search failed.");
             console.log(chalk.red(`\n Failed: ${err.error}`));
             return;
         }
         const data = await res.json();
+        await addTaskToolCall(task.id, {
+            toolName: "server.memory.search",
+            status: "completed",
+            args: { query },
+            result: { total: data.results.length },
+        });
+        await appendTaskStreamingContent(task.id, `server=${data.results.length};`);
+        await addTaskReasoningContent(task.id, `Shared search returned ${data.results.length} match${data.results.length === 1 ? "" : "es"}.`);
         if (data.results.length === 0 && localMatches.length === 0) {
+            await completeTask(task.id, "completed", "No local or shared context matched this question.");
+            await recordSessionEvent({
+                kind: "query",
+                title: `No context found for "${query}"`,
+                detail: "The query did not match local drafts or server context.",
+                panel: "query",
+                focus: query,
+                status: "warning",
+            });
             console.log(chalk.yellow(`\n No context found for "${query}"`));
             return;
         }
+        await completeTask(task.id, "completed", `Found ${localMatches.length} local match${localMatches.length === 1 ? "" : "es"} and ${data.results.length} shared match${data.results.length === 1 ? "" : "es"}.`);
+        await recordSessionEvent({
+            kind: "query",
+            title: `Searched Context for "${query}"`,
+            detail: `Found ${localMatches.length} local match${localMatches.length === 1 ? "" : "es"} and ${data.results.length} server match${data.results.length === 1 ? "" : "es"}.`,
+            panel: "query",
+            focus: query,
+            status: "success",
+        });
         console.log(chalk.bold(`\n Found context for ${config.companyName} / ${config.projectName}:\n`));
         if (localMatches.length > 0) {
             console.log(chalk.cyan(" Local .um matches:\n"));
@@ -47,6 +102,15 @@ export async function searchCommandAction(query) {
         });
     }
     catch (err) {
+        const failedTask = await createTask({
+            kind: "query",
+            title: `Query failed: ${query}`,
+            detail: err.message,
+            status: "failed",
+            panel: "query",
+            focus: query,
+        });
+        await completeTask(failedTask.id, "failed", err.message);
         console.log(chalk.red(`\n Error: ${err.message}`));
     }
 }

package/dist/commands/session.d.ts

@@ -0,0 +1,2 @@
+export declare function sessionCommandAction(action?: string): Promise<void>;
+export declare function sessionCommand(cli: any): void;

package/dist/commands/session.js

@@ -0,0 +1,241 @@
+import chalk from "chalk";
+import { ensureSessionState, getConnectorRuns, getInstalledConnectors, getInstalledHubEntries, getPendingMemories, getPulledFixes, getPulledMemories, } from "../repo-state.js";
+import { connectorsCommandAction } from "./connectors.js";
+import { hubCommandAction } from "./hub.js";
+import { modelCommandAction } from "./model.js";
+import { providersCommandAction } from "./providers.js";
+import { getStatusSnapshot } from "./status.js";
+import { spaceCommandAction } from "./space.js";
+import { activityCommandAction } from "./activity.js";
+function divider() {
+    return chalk.gray("------------------------------------------------------------");
+}
+function line(label, value) {
+    return `  ${chalk.cyan(label.padEnd(18))} ${value}`;
+}
+async function printSessionSummary() {
+    const snapshot = await getStatusSnapshot();
+    const session = await ensureSessionState();
+    console.log(chalk.bold("\n Session Summary\n"));
+    console.log(line("Company", snapshot.companyName));
+    console.log(line("Space", snapshot.spaceName));
+    console.log(line("Current panel", snapshot.currentPanel));
+    console.log(line("Current focus", snapshot.currentFocus));
+    console.log(line("Latest event", snapshot.latestEvent));
+    console.log(line("Commands", String(session.commandHistory.length)));
+    console.log(line("Queries", String(session.recentQueries.length)));
+    console.log(line("Curations", String(session.recentCurations.length)));
+    console.log("");
+}
+async function printSessionTimeline() {
+    const session = await ensureSessionState();
+    console.log(chalk.bold("\n Session Timeline\n"));
+    console.log(divider());
+    if ((session.events?.length ?? 0) === 0) {
+        console.log(chalk.gray("  No session events yet."));
+        console.log("");
+        return;
+    }
+    session.events.slice(0, 12).forEach((entry, index) => {
+        const badge = entry.status === "success" ? chalk.green(`[${entry.kind}]`)
+            : entry.status === "warning" ? chalk.yellow(`[${entry.kind}]`)
+                : entry.status === "failure" ? chalk.red(`[${entry.kind}]`)
+                    : chalk.cyan(`[${entry.kind}]`);
+        console.log(`  ${index + 1}. ${badge} ${entry.title}`);
+        console.log(chalk.gray(`     ${new Date(entry.at).toLocaleString()}`));
+        if (entry.detail) {
+            console.log(chalk.gray(`     ${entry.detail}`));
+        }
+    });
+    console.log("");
+}
+async function printSessionPanel() {
+    const session = await ensureSessionState();
+    const latestPanelEvent = (session.events ?? []).find((entry) => entry.panel === session.currentPanel);
+    console.log(chalk.bold("\n Live Panel\n"));
+    console.log(divider());
+    console.log(line("Panel", session.currentPanel ?? "None"));
+    console.log(line("Focus", session.currentFocus ?? "None"));
+    console.log(line("Last panel event", latestPanelEvent?.title ?? "Nothing panel-specific yet"));
+    if (session.panelHistory.length > 0) {
+        console.log("");
+        console.log(chalk.bold(" Recent panels"));
+        session.panelHistory.slice(0, 5).forEach((entry, index) => {
+            console.log(`  ${index + 1}. ${entry}`);
+        });
+    }
+    console.log("");
+}
+async function printSessionRecent() {
+    const pending = await getPendingMemories();
+    const pulled = await getPulledMemories();
+    const fixes = await getPulledFixes();
+    const connectors = await getConnectorRuns();
+    const hub = await getInstalledHubEntries();
+    const installedConnectors = await getInstalledConnectors();
+    console.log(chalk.bold("\n Recent Repo Activity\n"));
+    console.log(divider());
+    console.log(line("Pending drafts", String(pending.length)));
+    console.log(line("Pulled context", String(pulled.length)));
+    console.log(line("Known fixes", String(fixes.length)));
+    console.log(line("Hub installs", String(hub.length)));
+    console.log(line("Connectors", String(installedConnectors.length)));
+    console.log(line("Connector runs", String(connectors.length)));
+    if (connectors[0]) {
+        console.log("");
+        console.log(chalk.bold(" Latest connector run"));
+        console.log(`  ${connectors[0].connectorName} (${connectors[0].status})`);
+        console.log(chalk.gray(`  ${connectors[0].summary}`));
+    }
+    console.log("");
+}
+async function printSessionActivity() {
+    await activityCommandAction();
+}
+async function printSessionHistory() {
+    const session = await ensureSessionState();
+    console.log(chalk.bold("\n Session History\n"));
+    console.log(divider());
+    if (session.commandHistory.length === 0) {
+        console.log(chalk.gray("  No commands recorded yet."));
+        console.log("");
+        return;
+    }
+    session.commandHistory.slice(0, 20).forEach((entry, index) => {
+        console.log(`  ${index + 1}. ${entry}`);
+    });
+    console.log("");
+}
+async function continueSessionFlow() {
+    const session = await ensureSessionState();
+    const panel = session.currentPanel;
+    const focus = session.currentFocus ?? undefined;
+    if (!panel || panel === "home") {
+        await printSessionSummary();
+        return;
+    }
+    if (panel === "timeline") {
+        await printSessionTimeline();
+        return;
+    }
+    if (panel === "recent") {
+        await printSessionRecent();
+        return;
+    }
+    if (panel === "activity") {
+        await printSessionActivity();
+        return;
+    }
+    if (panel === "session") {
+        await printSessionSummary();
+        return;
+    }
+    if (panel === "reset") {
+        console.log(chalk.yellow("\n The last saved panel was a local reset. Run status or home to rebuild your working view."));
+        return;
+    }
+    if (panel === "status") {
+        await import("./status.js").then((mod) => mod.statusCommandAction());
+        return;
+    }
+    if (panel === "providers") {
+        if (focus && focus !== "list") {
+            await providersCommandAction("inspect", focus);
+            return;
+        }
+        await providersCommandAction("list");
+        return;
+    }
+    if (panel === "model") {
+        if (focus && focus !== "list") {
+            await modelCommandAction("inspect", focus);
+            return;
+        }
+        await modelCommandAction("list");
+        return;
+    }
+    if (panel === "hub") {
+        if (focus?.startsWith("registry:")) {
+            await hubCommandAction("registry", "list");
+            return;
+        }
+        if (focus === "installed") {
+            await hubCommandAction("installed");
+            return;
+        }
+        if (focus && focus !== "list") {
+            await hubCommandAction("inspect", focus);
+            return;
+        }
+        await hubCommandAction("list");
+        return;
+    }
+    if (panel === "connectors") {
+        if (focus && focus !== "list") {
+            await connectorsCommandAction("inspect", focus);
+            return;
+        }
+        await connectorsCommandAction("list");
+        return;
+    }
+    if (panel === "space" || panel === "spaces" || panel === "projects") {
+        await spaceCommandAction("list");
+        return;
+    }
+    console.log(chalk.yellow(`\n No resume flow yet for panel "${panel}".`));
+}
+export async function sessionCommandAction(action = "summary") {
+    const normalized = action.toLowerCase();
+    if (normalized === "summary") {
+        await printSessionSummary();
+        return;
+    }
+    if (normalized === "timeline") {
+        await printSessionTimeline();
+        return;
+    }
+    if (normalized === "panel") {
+        await printSessionPanel();
+        return;
+    }
+    if (normalized === "recent") {
+        await printSessionRecent();
+        return;
+    }
+    if (normalized === "activity") {
+        await printSessionActivity();
+        return;
+    }
+    if (normalized === "history") {
+        await printSessionHistory();
+        return;
+    }
+    if (normalized === "continue") {
+        await continueSessionFlow();
+        return;
+    }
+    console.log(chalk.red("Use: session summary | session timeline | session panel | session recent | session activity | session history | session continue"));
+}
+export function sessionCommand(cli) {
+    cli.command("session [action]", "Show persistent terminal session views for this repo").action(async (action) => {
+        await sessionCommandAction(action ?? "summary");
+    });
+    cli.command("home", "Show the saved repo home/session summary").action(async () => {
+        await sessionCommandAction("summary");
+    });
+    cli.command("recent", "Show saved recent repo activity").action(async () => {
+        await sessionCommandAction("recent");
+    });
+    cli.command("activity", "Show the saved richer repo activity feed").action(async () => {
+        await sessionCommandAction("activity");
+    });
+    cli.command("timeline", "Show the saved session event timeline").action(async () => {
+        await sessionCommandAction("timeline");
+    });
+    cli.command("panel", "Show the saved live panel and focus").action(async () => {
+        await sessionCommandAction("panel");
+    });
+    cli.command("continue", "Resume the last saved panel flow outside the live shell").action(async () => {
+        await sessionCommandAction("continue");
+    });
+}

package/dist/commands/setup.js

@@ -1,10 +1,17 @@
 import chalk from "chalk";
 import prompts from "prompts";
 import { configManager } from "../config.js";
-import { ensureRepoContext } from "../repo-state.js";
-import { createContextSpace, createUmbrellaCompany, getCliSetup, getCompanyContextSummary, getUmbrellaHealth, listUmbrellaCompanies, signInToUmbrella, toContextSpaces, } from "../umbrella.js";
-function normalizeServerUrl(value) {
-    return value.trim().replace(/\/+$/, "");
+import { checkUmbrellaOnboardingServer, connectUmbrellaDevice, createUmbrellaOnboardingCompany, createUmbrellaOnboardingSpace, loadUmbrellaOnboardingSpaces, normalizeUmbrellaServerUrl, signInUmbrellaOnboarding, } from "../adapters/umbrella-onboarding.js";
+const DEFAULT_UMBRELLA_SERVER_URL = "http://5.161.55.138:3100";
+function isLocalOnlyServerUrl(value) {
+    try {
+        const parsed = new URL(value);
+        const host = parsed.hostname.toLowerCase();
+        return host === "127.0.0.1" || host === "localhost" || host === "::1";
+    }
+    catch {
+        return false;
+    }
 }
 function printConnected(setup) {
     console.log(chalk.green(`\n Connected to ${setup.companyName} / ${setup.activeSpaceName}`));
@@ -22,9 +29,6 @@ async function chooseCompany(serverUrl, companies, cookie, initialCompanyId) {
             return matched;
     }
     const companyPrompt = await prompts({
-        type: "select",
-        name: "value",
-        message: "Choose a company from Umbrella",
         choices: [
             ...companies.map((company) => ({
                 title: `${company.name} (${company.issuePrefix})`,
@@ -32,6 +36,9 @@ async function chooseCompany(serverUrl, companies, cookie, initialCompanyId) {
             })),
             { title: "+ Create new company", value: "__create__" },
         ],
+        message: "Choose a company from Umbrella",
+        name: "value",
+        type: "select",
     });
     if (!companyPrompt.value)
         return null;
@@ -39,14 +46,15 @@ async function chooseCompany(serverUrl, companies, cookie, initialCompanyId) {
         return companies.find((company) => company.id === companyPrompt.value) ?? null;
     }
     const createdPrompt = await prompts({
-        type: "text",
-        name: "value",
         message: "New company name",
+        name: "value",
+        type: "text",
         validate: (value) => (value.trim().length > 0 ? true : "Enter a company name"),
     });
     if (!createdPrompt.value)
         return null;
-    return createUmbrellaCompany(serverUrl, createdPrompt.value.trim(), cookie);
+    const created = await createUmbrellaOnboardingCompany(serverUrl, createdPrompt.value.trim(), cookie);
+    return created.company;
 }
 async function chooseSpace(serverUrl, companyId, spaces, cookie, initialSpaceId) {
     if (initialSpaceId) {
@@ -55,9 +63,6 @@ async function chooseSpace(serverUrl, companyId, spaces, cookie, initialSpaceId)
             return matched.id;
     }
     const spacePrompt = await prompts({
-        type: "select",
-        name: "value",
-        message: "Choose a context space",
         choices: [
             ...spaces.map((space) => ({
                 title: space.isPrimary ? `${space.name} (core)` : space.name,
@@ -65,42 +70,24 @@ async function chooseSpace(serverUrl, companyId, spaces, cookie, initialSpaceId)
             })),
             { title: "+ Create new space", value: "__create__" },
         ],
+        message: "Choose a context space",
+        name: "value",
+        type: "select",
     });
     if (!spacePrompt.value)
         return null;
     if (spacePrompt.value !== "__create__")
         return spacePrompt.value;
     const createdPrompt = await prompts({
-        type: "text",
-        name: "value",
         message: "New context space name",
+        name: "value",
+        type: "text",
         validate: (value) => (value.trim().length > 0 ? true : "Enter a space name"),
     });
     if (!createdPrompt.value)
         return null;
-    const summary = await createContextSpace(serverUrl, companyId, createdPrompt.value.trim(), cookie);
-    return summary.activeProjectId;
-}
-function saveSetup(setup, umbrellaUrl) {
-    configManager.set({
-        umbrellaUrl,
-        serverUrl: setup.baseUrl,
-        companyId: setup.companyId,
-        companyName: setup.companyName,
-        workspaceId: setup.workspaceId,
-        workspaceName: setup.workspaceName,
-        projectId: setup.activeSpaceId,
-        projectName: setup.activeSpaceName,
-        apiKey: setup.apiKey,
-    });
-    configManager.upsertLocation({
-        repoRoot: process.cwd(),
-        companyId: setup.companyId,
-        companyName: setup.companyName,
-        projectId: setup.activeSpaceId,
-        projectName: setup.activeSpaceName,
-        updatedAt: new Date().toISOString(),
-    });
+    const created = await createUmbrellaOnboardingSpace(serverUrl, companyId, createdPrompt.value.trim(), cookie);
+    return created.activeSpaceId;
 }
 export function setupCommand(cli) {
     cli
@@ -113,26 +100,39 @@ export function setupCommand(cli) {
         .action(async (options) => {
         console.log(chalk.bold("\n Umbrella Context Setup\n"));
         const existing = configManager.config;
+        const envServerUrl = process.env.UMBRELLA_SERVER_URL?.trim();
+        const suggestedServerUrl = options.serverUrl?.trim() ||
+            envServerUrl ||
+            existing?.umbrellaUrl ||
+            existing?.serverUrl ||
+            DEFAULT_UMBRELLA_SERVER_URL;
+        console.log(chalk.gray(` Defaulting to the live Umbrella server at ${DEFAULT_UMBRELLA_SERVER_URL}. Only use 127.0.0.1 if you are intentionally running Umbrella on this same computer instead.`));
         const serverUrlPrompt = await prompts({
-            type: options.serverUrl ? null : "text",
-            name: "value",
+            initial: suggestedServerUrl,
             message: "Umbrella server URL",
-            initial: existing?.serverUrl || "http://127.0.0.1:3100",
+            name: "value",
+            type: options.serverUrl ? null : "text",
         });
-        const serverUrl = normalizeServerUrl(options.serverUrl?.trim() || serverUrlPrompt.value || existing?.serverUrl || "http://127.0.0.1:3100");
+        const serverUrl = normalizeUmbrellaServerUrl(options.serverUrl?.trim() ||
+            serverUrlPrompt.value ||
+            envServerUrl ||
+            existing?.umbrellaUrl ||
+            existing?.serverUrl ||
+            DEFAULT_UMBRELLA_SERVER_URL);
         try {
-            const health = await getUmbrellaHealth(serverUrl);
             let cookie = null;
-            if (health.deploymentMode === "authenticated") {
+            let companies = [];
+            const serverCheck = await checkUmbrellaOnboardingServer(serverUrl);
+            if (serverCheck.deploymentMode === "authenticated") {
                 const emailPrompt = await prompts({
-                    type: options.email ? null : "text",
-                    name: "value",
                     message: "Umbrella email",
+                    name: "value",
+                    type: options.email ? null : "text",
                 });
                 const passwordPrompt = await prompts({
-                    type: options.password ? null : "password",
-                    name: "value",
                     message: "Umbrella password",
+                    name: "value",
+                    type: options.password ? null : "password",
                 });
                 const email = options.email?.trim() || emailPrompt.value;
                 const password = options.password?.trim() || passwordPrompt.value;
@@ -140,31 +140,33 @@ export function setupCommand(cli) {
                     console.log(chalk.red("\n Sign-in cancelled."));
                     return;
                 }
-                const session = await signInToUmbrella(serverUrl, email, password);
-                cookie = session.cookie;
+                const signIn = await signInUmbrellaOnboarding(serverUrl, email, password);
+                cookie = signIn.cookie;
+                companies = signIn.companies;
             }
             else {
                 console.log(chalk.gray(" Local trusted mode detected. Using the local board access path."));
+                companies = serverCheck.companies;
             }
-            const companies = await listUmbrellaCompanies(serverUrl, cookie);
             const company = await chooseCompany(serverUrl, companies, cookie, options.companyId?.trim());
             if (!company) {
                 console.log(chalk.yellow("\n No company selected."));
                 return;
             }
-            const summary = await getCompanyContextSummary(serverUrl, company.id, cookie);
-            const spaces = toContextSpaces(summary);
+            const spaces = await loadUmbrellaOnboardingSpaces(serverUrl, company.id, cookie);
             const selectedSpaceId = await chooseSpace(serverUrl, company.id, spaces, cookie, options.spaceId?.trim());
             if (!selectedSpaceId) {
                 console.log(chalk.yellow("\n No context space selected."));
                 return;
             }
-            const setup = await getCliSetup(serverUrl, company.id, selectedSpaceId, cookie);
-            saveSetup(setup, serverUrl);
-            await ensureRepoContext(configManager.config);
+            const setup = await connectUmbrellaDevice(serverUrl, company.id, selectedSpaceId, cookie);
             printConnected(setup);
         }
         catch (err) {
+            if (isLocalOnlyServerUrl(serverUrl)) {
+                console.log(chalk.yellow("\n Hint: 127.0.0.1 points to this same computer only."));
+                console.log(chalk.yellow(" If Umbrella is running on another machine or server, re-run setup and enter that machine's real URL or IP."));
+            }
             console.log(chalk.red(`\n Error: ${err.message}`));
         }
     });

package/dist/commands/space.d.ts

@@ -1 +1,13 @@
+export type SpaceCommandResult = {
+    action: "create" | "list" | "switch";
+    changed: boolean;
+    companyName: string;
+    currentSpaceName: string | null;
+    spaces: Array<{
+        id: string;
+        isPrimary: boolean;
+        name: string;
+    }>;
+};
+export declare function spaceCommandAction(action: string, spaceArg?: string): Promise<SpaceCommandResult | void>;
 export declare function spaceCommand(cli: any): void;