umbrella-context 0.1.2

package/dist/commands/search.js

@@ -0,0 +1,57 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+import { getPendingMemories, getPulledMemories, summarizeLocalMemoryMatches } from "../repo-state.js";
+export async function searchCommandAction(query) {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    try {
+        const localMatches = summarizeLocalMemoryMatches([...(await getPendingMemories()), ...(await getPulledMemories())], query);
+        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();
+            console.log(chalk.red(`\n Failed: ${err.error}`));
+            return;
+        }
+        const data = await res.json();
+        if (data.results.length === 0 && localMatches.length === 0) {
+            console.log(chalk.yellow(`\n No context found for "${query}"`));
+            return;
+        }
+        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"));
+            localMatches.forEach((result, index) => {
+                console.log(chalk.cyan(`  ${index + 1}. [local]`));
+                console.log(`     ${result.content}`);
+                if (result.tags?.length)
+                    console.log(chalk.gray(`     Tags: ${result.tags.join(", ")}`));
+                console.log(chalk.gray(`     Saved: ${new Date(result.createdAt).toLocaleString()}`));
+                console.log("");
+            });
+        }
+        if (data.results.length > 0) {
+            console.log(chalk.cyan(" Server matches:\n"));
+        }
+        data.results.forEach((result, index) => {
+            console.log(chalk.cyan(`  ${index + 1}. [${result.systemType}]`));
+            console.log(`     ${result.content}`);
+            if (result.tags?.length)
+                console.log(chalk.gray(`     Tags: ${result.tags.join(", ")}`));
+            console.log(chalk.gray(`     Source: ${result.source} | ${new Date(result.createdAt).toLocaleDateString()}`));
+            console.log("");
+        });
+    }
+    catch (err) {
+        console.log(chalk.red(`\n Error: ${err.message}`));
+    }
+}
+export function searchCommand(cli) {
+    cli.command("search <query>", "Search saved context by keyword").action(async (query) => {
+        await searchCommandAction(query);
+    });
+}

package/dist/commands/seed.d.ts

@@ -0,0 +1 @@
+export declare function seedCommand(cli: any): void;

package/dist/commands/seed.js

@@ -0,0 +1,117 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { configManager } from "../config.js";
+export function seedCommand(cli) {
+    cli.command("seed", "Create first workspace, user, and project").action(async () => {
+        console.log(chalk.bold("\n Seed - Create your first workspace\n"));
+        const serverUrl = await prompts({
+            type: "text",
+            name: "value",
+            message: "Server URL",
+            initial: "http://localhost:3000",
+        });
+        if (!serverUrl.value)
+            return;
+        const workspaceName = await prompts({
+            type: "text",
+            name: "value",
+            message: "Workspace name",
+            initial: "Personal",
+        });
+        if (!workspaceName.value)
+            return;
+        const email = await prompts({
+            type: "text",
+            name: "value",
+            message: "Email",
+        });
+        if (!email.value)
+            return;
+        const password = await prompts({
+            type: "password",
+            name: "value",
+            message: "Password (min 6 chars)",
+        });
+        if (!password.value)
+            return;
+        const projectName = await prompts({
+            type: "text",
+            name: "value",
+            message: "First project name",
+            initial: "Default",
+        });
+        if (!projectName.value)
+            return;
+        try {
+            const seedRes = await fetch(`${serverUrl.value}/api/auth/seed-user`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    email: email.value,
+                    password: password.value,
+                    workspaceName: workspaceName.value,
+                }),
+            });
+            if (!seedRes.ok && seedRes.status !== 409) {
+                const err = await seedRes.json();
+                console.log(chalk.red(`\n Failed to create user: ${err.error}`));
+                return;
+            }
+            if (seedRes.status === 409) {
+                console.log(chalk.yellow("\n User already exists, continuing..."));
+            }
+            else {
+                console.log(chalk.green("\n User created"));
+            }
+            const loginRes = await fetch(`${serverUrl.value}/api/auth/login`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ email: email.value, password: password.value }),
+            });
+            const loginData = await loginRes.json();
+            if (loginData.projects?.length > 0) {
+                console.log(chalk.green(`\n Workspace "${loginData.workspace.name}" already has ${loginData.projects.length} project(s)`));
+                configManager.set({
+                    serverUrl: serverUrl.value,
+                    apiKey: loginData.projects[0].apiKey,
+                    projectId: loginData.projects[0].id,
+                    projectName: loginData.projects[0].name,
+                    workspaceId: loginData.workspace.id,
+                    workspaceName: loginData.workspace.name,
+                });
+                console.log(chalk.gray(`\n Connected to: ${loginData.workspace.name} / ${loginData.projects[0].name}`));
+                return;
+            }
+            const projectRes = await fetch(`${serverUrl.value}/api/auth/projects`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    workspaceId: loginData.workspaceId || loginData.workspace.id,
+                    name: projectName.value,
+                }),
+            });
+            if (!projectRes.ok) {
+                const err = await projectRes.json();
+                console.log(chalk.red(`\n Failed to create project: ${err.error}`));
+                return;
+            }
+            const project = await projectRes.json();
+            configManager.set({
+                serverUrl: serverUrl.value,
+                apiKey: project.apiKey,
+                projectId: project.id,
+                projectName: project.name,
+                workspaceId: loginData.workspaceId || loginData.workspace.id,
+                workspaceName: loginData.workspace.name,
+            });
+            console.log(chalk.green("\n All set!"));
+            console.log(chalk.green(`  Workspace: ${loginData.workspace.name}`));
+            console.log(chalk.green(`  Project: ${project.name}`));
+            console.log(chalk.green(`  API Key: ${project.apiKey}`));
+            console.log(chalk.gray("\n Run umbrella-context to start."));
+        }
+        catch (err) {
+            console.log(chalk.red(`\n Error: ${err.message}`));
+        }
+    });
+}

package/dist/commands/setup.d.ts

@@ -0,0 +1 @@
+export declare function setupCommand(cli: any): void;

package/dist/commands/setup.js

@@ -0,0 +1,171 @@
+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(/\/+$/, "");
+}
+function printConnected(setup) {
+    console.log(chalk.green(`\n Connected to ${setup.companyName} / ${setup.activeSpaceName}`));
+    console.log(chalk.gray(` Context space: ${setup.activeSpaceName}`));
+    console.log(chalk.gray(` Saved config to ${configManager.configPath}`));
+    console.log(chalk.gray("\n Next commands:"));
+    console.log(chalk.gray("   umbrella-context query \"What do we already know?\""));
+    console.log(chalk.gray("   umbrella-context curate \"We learned that...\""));
+    console.log(chalk.gray("   umbrella-context mcp"));
+}
+async function chooseCompany(serverUrl, companies, cookie, initialCompanyId) {
+    if (initialCompanyId) {
+        const matched = companies.find((company) => company.id === initialCompanyId);
+        if (matched)
+            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})`,
+                value: company.id,
+            })),
+            { title: "+ Create new company", value: "__create__" },
+        ],
+    });
+    if (!companyPrompt.value)
+        return null;
+    if (companyPrompt.value !== "__create__") {
+        return companies.find((company) => company.id === companyPrompt.value) ?? null;
+    }
+    const createdPrompt = await prompts({
+        type: "text",
+        name: "value",
+        message: "New company name",
+        validate: (value) => (value.trim().length > 0 ? true : "Enter a company name"),
+    });
+    if (!createdPrompt.value)
+        return null;
+    return createUmbrellaCompany(serverUrl, createdPrompt.value.trim(), cookie);
+}
+async function chooseSpace(serverUrl, companyId, spaces, cookie, initialSpaceId) {
+    if (initialSpaceId) {
+        const matched = spaces.find((space) => space.id === initialSpaceId);
+        if (matched)
+            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,
+                value: space.id,
+            })),
+            { title: "+ Create new space", value: "__create__" },
+        ],
+    });
+    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",
+        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(),
+    });
+}
+export function setupCommand(cli) {
+    cli
+        .command("setup", "Sign into Umbrella, choose a company, and connect this device to a context space")
+        .option("--server-url <url>", "Umbrella server URL")
+        .option("--email <email>", "Umbrella email for authenticated mode")
+        .option("--password <password>", "Umbrella password for authenticated mode")
+        .option("--company-id <id>", "Existing Umbrella company ID")
+        .option("--space-id <id>", "Existing context space ID")
+        .action(async (options) => {
+        console.log(chalk.bold("\n Umbrella Context Setup\n"));
+        const existing = configManager.config;
+        const serverUrlPrompt = await prompts({
+            type: options.serverUrl ? null : "text",
+            name: "value",
+            message: "Umbrella server URL",
+            initial: existing?.serverUrl || "http://127.0.0.1:3100",
+        });
+        const serverUrl = normalizeServerUrl(options.serverUrl?.trim() || serverUrlPrompt.value || existing?.serverUrl || "http://127.0.0.1:3100");
+        try {
+            const health = await getUmbrellaHealth(serverUrl);
+            let cookie = null;
+            if (health.deploymentMode === "authenticated") {
+                const emailPrompt = await prompts({
+                    type: options.email ? null : "text",
+                    name: "value",
+                    message: "Umbrella email",
+                });
+                const passwordPrompt = await prompts({
+                    type: options.password ? null : "password",
+                    name: "value",
+                    message: "Umbrella password",
+                });
+                const email = options.email?.trim() || emailPrompt.value;
+                const password = options.password?.trim() || passwordPrompt.value;
+                if (!email || !password) {
+                    console.log(chalk.red("\n Sign-in cancelled."));
+                    return;
+                }
+                const session = await signInToUmbrella(serverUrl, email, password);
+                cookie = session.cookie;
+            }
+            else {
+                console.log(chalk.gray(" Local trusted mode detected. Using the local board access path."));
+            }
+            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 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);
+            printConnected(setup);
+        }
+        catch (err) {
+            console.log(chalk.red(`\n Error: ${err.message}`));
+        }
+    });
+}

package/dist/commands/space.d.ts

@@ -0,0 +1 @@
+export declare function spaceCommand(cli: any): void;

package/dist/commands/space.js

@@ -0,0 +1,75 @@
+import chalk from "chalk";
+import prompts from "prompts";
+import { configManager } from "../config.js";
+import { ensureRepoContext } from "../repo-state.js";
+import { getCliSetup, getCompanyContextSummary, toContextSpaces } from "../umbrella.js";
+export function spaceCommand(cli) {
+    cli
+        .command("space <action> [space]", "List or switch context spaces for the current company")
+        .action(async (action, spaceArg) => {
+        const config = configManager.config;
+        if (!config) {
+            console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+            return;
+        }
+        if (!config.umbrellaUrl) {
+            console.log(chalk.red("No Umbrella URL saved for this device. Run umbrella-context setup to enable space commands."));
+            return;
+        }
+        const normalizedAction = action.toLowerCase();
+        const summary = await getCompanyContextSummary(config.umbrellaUrl, config.companyId);
+        const spaces = toContextSpaces(summary);
+        if (normalizedAction === "list") {
+            console.log(chalk.bold(`\n Spaces for ${config.companyName}\n`));
+            spaces.forEach((entry, index) => {
+                const active = entry.id === config.projectId ? " (active)" : "";
+                const primary = entry.isPrimary ? " [core]" : "";
+                console.log(` ${index + 1}. ${entry.name}${primary}${active}`);
+            });
+            return;
+        }
+        if (normalizedAction !== "switch") {
+            console.log(chalk.red("Use either 'umbrella-context space list' or 'umbrella-context space switch'."));
+            return;
+        }
+        let chosen = spaces.find((entry) => entry.id === spaceArg || entry.name.toLowerCase() === (spaceArg ?? "").toLowerCase()) ?? null;
+        if (!chosen) {
+            const answer = await prompts({
+                type: "select",
+                name: "value",
+                message: "Choose a context space",
+                choices: spaces.map((entry) => ({
+                    title: entry.isPrimary ? `${entry.name} (core)` : entry.name,
+                    value: entry.id,
+                })),
+            });
+            chosen = spaces.find((entry) => entry.id === answer.value) ?? null;
+        }
+        if (!chosen) {
+            console.log(chalk.yellow("\n No space selected."));
+            return;
+        }
+        const setup = await getCliSetup(config.umbrellaUrl, config.companyId, chosen.id);
+        configManager.set({
+            umbrellaUrl: config.umbrellaUrl,
+            serverUrl: setup.baseUrl,
+            apiKey: setup.apiKey,
+            companyId: setup.companyId,
+            companyName: setup.companyName,
+            workspaceId: setup.workspaceId,
+            workspaceName: setup.workspaceName,
+            projectId: setup.activeSpaceId,
+            projectName: setup.activeSpaceName,
+        });
+        configManager.upsertLocation({
+            repoRoot: process.cwd(),
+            companyId: setup.companyId,
+            companyName: setup.companyName,
+            projectId: setup.activeSpaceId,
+            projectName: setup.activeSpaceName,
+            updatedAt: new Date().toISOString(),
+        });
+        await ensureRepoContext(configManager.config);
+        console.log(chalk.green(`\n Switched to ${setup.companyName} / ${setup.activeSpaceName}`));
+    });
+}

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+export declare function statusCommandAction(): Promise<void>;
+export declare function statusCommand(cli: any): void;

package/dist/commands/status.js

@@ -0,0 +1,32 @@
+import chalk from "chalk";
+import { configManager } from "../config.js";
+import { getPendingMemories, getPulledFixes, getPulledMemories, getRepoContext } from "../repo-state.js";
+export async function statusCommandAction() {
+    const config = configManager.config;
+    if (!config) {
+        console.log(chalk.red("Not configured. Run: umbrella-context setup"));
+        return;
+    }
+    const { repoRoot, state, umDir } = await getRepoContext();
+    const pending = await getPendingMemories();
+    const pulledMemories = await getPulledMemories();
+    const pulledFixes = await getPulledFixes();
+    console.log(chalk.bold("\n Umbrella Context Status\n"));
+    console.log(` Company: ${config.companyName}`);
+    console.log(` Space: ${config.projectName}`);
+    console.log(` Umbrella: ${config.umbrellaUrl ?? "Not saved"}`);
+    console.log(` Server: ${config.serverUrl}`);
+    console.log(` Current Directory: ${process.cwd()}`);
+    console.log(` Repo Root: ${repoRoot}`);
+    console.log(` Local Context Folder: ${umDir}`);
+    console.log(` Pending Local Context: ${pending.length}`);
+    console.log(` Pulled Context Snapshot: ${pulledMemories.length}`);
+    console.log(` Pulled Known Fixes: ${pulledFixes.length}`);
+    console.log(` Last Push: ${state?.lastPushAt ?? "Never"}`);
+    console.log(` Last Pull: ${state?.lastPullAt ?? "Never"}`);
+}
+export function statusCommand(cli) {
+    cli.command("status", "Show the current repo, company, space, and local sync state").action(async () => {
+        await statusCommandAction();
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,30 @@
+export interface AgentMemoryConfig {
+    umbrellaUrl?: string;
+    serverUrl: string;
+    apiKey: string;
+    companyId: string;
+    companyName: string;
+    projectId: string;
+    projectName: string;
+    workspaceId: string;
+    workspaceName: string;
+}
+export interface SavedLocation {
+    repoRoot: string;
+    companyId: string;
+    companyName: string;
+    projectId: string;
+    projectName: string;
+    updatedAt: string;
+}
+export declare class ConfigManager {
+    private conf;
+    constructor();
+    get config(): AgentMemoryConfig | null;
+    set(config: Partial<AgentMemoryConfig>): void;
+    clear(): void;
+    get locations(): SavedLocation[];
+    upsertLocation(location: SavedLocation): void;
+    get configPath(): string;
+}
+export declare const configManager: ConfigManager;

package/dist/config.js

@@ -0,0 +1,63 @@
+import Conf from "conf";
+import path from "path";
+import os from "os";
+export class ConfigManager {
+    conf;
+    constructor() {
+        this.conf = new Conf({
+            projectName: "umbrella-context",
+            configName: "config",
+        });
+    }
+    get config() {
+        return this.conf.get("serverUrl")
+            ? {
+                umbrellaUrl: this.conf.get("umbrellaUrl"),
+                serverUrl: this.conf.get("serverUrl"),
+                apiKey: this.conf.get("apiKey"),
+                companyId: this.conf.get("companyId"),
+                companyName: this.conf.get("companyName"),
+                projectId: this.conf.get("projectId"),
+                projectName: this.conf.get("projectName"),
+                workspaceId: this.conf.get("workspaceId"),
+                workspaceName: this.conf.get("workspaceName"),
+            }
+            : null;
+    }
+    set(config) {
+        if (config.umbrellaUrl)
+            this.conf.set("umbrellaUrl", config.umbrellaUrl);
+        if (config.serverUrl)
+            this.conf.set("serverUrl", config.serverUrl);
+        if (config.apiKey)
+            this.conf.set("apiKey", config.apiKey);
+        if (config.companyId)
+            this.conf.set("companyId", config.companyId);
+        if (config.companyName)
+            this.conf.set("companyName", config.companyName);
+        if (config.projectId)
+            this.conf.set("projectId", config.projectId);
+        if (config.projectName)
+            this.conf.set("projectName", config.projectName);
+        if (config.workspaceId)
+            this.conf.set("workspaceId", config.workspaceId);
+        if (config.workspaceName)
+            this.conf.set("workspaceName", config.workspaceName);
+    }
+    clear() {
+        this.conf.clear();
+    }
+    get locations() {
+        return this.conf.get("locations") ?? [];
+    }
+    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)));
+    }
+    get configPath() {
+        return this.conf.path
+            ?? path.join(os.homedir(), ".config", "umbrella-context", "config.json");
+    }
+}
+export const configManager = new ConfigManager();

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,42 @@
+import { cac } from "cac";
+import { setupCommand } from "./commands/setup.js";
+import { loginCommand } from "./commands/login.js";
+import { connectCommand } from "./commands/connect.js";
+import { pushCommand } from "./commands/push.js";
+import { pullCommand } from "./commands/pull.js";
+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";
+const cli = cac("umbrella-context");
+cli.option("--config <path>", "Path to config file");
+import { seedCommand } from "./commands/seed.js";
+setupCommand(cli);
+loginCommand(cli);
+connectCommand(cli);
+pushCommand(cli);
+pullCommand(cli);
+searchCommand(cli);
+fixCommand(cli);
+recordCommand(cli);
+mcpCommand(cli);
+seedCommand(cli);
+curateCommand(cli);
+statusCommand(cli);
+locationsCommand(cli);
+spaceCommand(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.parse();

package/dist/repo-state.d.ts

@@ -0,0 +1,53 @@
+import type { AgentMemoryConfig } from "./config.js";
+export type LocalMemoryEntry = {
+    id: string;
+    content: string;
+    tags: string[];
+    systemType: string;
+    source: string;
+    createdAt: string;
+};
+export type LocalFixEntry = {
+    id: string;
+    errorSignal: string;
+    solution: string;
+    confidence: number;
+    timesApplied: number;
+    timesSucceeded: number;
+    createdAt: string;
+    lastApplied: string | null;
+};
+export type RepoContextState = {
+    version: 1;
+    repoRoot: string;
+    umDir: string;
+    companyId: string;
+    companyName: string;
+    workspaceId: string;
+    workspaceName: string;
+    projectId: string;
+    projectName: string;
+    umbrellaUrl: string | null;
+    serverUrl: string;
+    initializedAt: string;
+    updatedAt: string;
+    lastPushAt: null | string;
+    lastPullAt: null | string;
+};
+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<{
+    repoRoot: string;
+    state: RepoContextState | null;
+    umDir: string;
+}>;
+export declare function updateRepoContext(updater: (current: RepoContextState) => RepoContextState | Promise<RepoContextState>, cwd?: string): Promise<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 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 summarizeLocalMemoryMatches(entries: LocalMemoryEntry[], query: string): LocalMemoryEntry[];