umbrella-context 0.1.2

package/dist/repo-state.js

@@ -0,0 +1,171 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { randomUUID } from "crypto";
+const UM_DIR = ".um";
+const CONTEXT_FILE = "context.json";
+const PENDING_MEMORIES_FILE = "pending-memories.json";
+const PULLED_MEMORIES_FILE = "pulled-memories.json";
+const PULLED_FIXES_FILE = "pulled-fixes.json";
+async function pathExists(targetPath) {
+    try {
+        await fs.access(targetPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function findRepoRoot(startDir = process.cwd()) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (await pathExists(path.join(current, ".git")))
+            return current;
+        if (await pathExists(path.join(current, "package.json")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return path.resolve(startDir);
+        current = parent;
+    }
+}
+function getUmDir(repoRoot) {
+    return path.join(repoRoot, UM_DIR);
+}
+function getContextFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), CONTEXT_FILE);
+}
+function getPendingMemoriesFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), PENDING_MEMORIES_FILE);
+}
+function getPulledMemoriesFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), PULLED_MEMORIES_FILE);
+}
+function getPulledFixesFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), PULLED_FIXES_FILE);
+}
+async function ensureUmDir(repoRoot) {
+    await fs.mkdir(getUmDir(repoRoot), { recursive: true });
+}
+async function readJsonFile(filePath, fallback) {
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+async function writeJsonFile(filePath, data) {
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
+}
+export async function ensureRepoContext(config, cwd = process.cwd()) {
+    const repoRoot = await findRepoRoot(cwd);
+    await ensureUmDir(repoRoot);
+    const now = new Date().toISOString();
+    const nextState = {
+        version: 1,
+        repoRoot,
+        umDir: getUmDir(repoRoot),
+        companyId: config.companyId,
+        companyName: config.companyName,
+        workspaceId: config.workspaceId,
+        workspaceName: config.workspaceName,
+        projectId: config.projectId,
+        projectName: config.projectName,
+        umbrellaUrl: config.umbrellaUrl ?? null,
+        serverUrl: config.serverUrl,
+        initializedAt: now,
+        updatedAt: now,
+        lastPushAt: null,
+        lastPullAt: null,
+    };
+    const existing = await readJsonFile(getContextFile(repoRoot), null);
+    await writeJsonFile(getContextFile(repoRoot), {
+        ...(existing ?? {}),
+        ...nextState,
+        initializedAt: existing?.initializedAt ?? now,
+    });
+    return repoRoot;
+}
+export async function getRepoContext(cwd = process.cwd()) {
+    const repoRoot = await findRepoRoot(cwd);
+    const state = await readJsonFile(getContextFile(repoRoot), null);
+    return { repoRoot, state, umDir: getUmDir(repoRoot) };
+}
+export async function updateRepoContext(updater, cwd = process.cwd()) {
+    const { repoRoot, state } = await getRepoContext(cwd);
+    if (!state)
+        throw new Error("Context is not initialized for this repo. Run umbrella-context setup first.");
+    const next = await updater(state);
+    await writeJsonFile(getContextFile(repoRoot), next);
+    return next;
+}
+export async function addPendingMemory(input, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    const current = await readJsonFile(getPendingMemoriesFile(repoRoot), []);
+    const entry = {
+        id: randomUUID(),
+        createdAt: new Date().toISOString(),
+        ...input,
+    };
+    current.push(entry);
+    await writeJsonFile(getPendingMemoriesFile(repoRoot), current);
+    await updateRepoContext((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+    }), cwd);
+    return entry;
+}
+export async function getPendingMemories(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    return readJsonFile(getPendingMemoriesFile(repoRoot), []);
+}
+export async function clearPendingMemories(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await writeJsonFile(getPendingMemoriesFile(repoRoot), []);
+}
+export async function setPulledMemories(memories, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    await writeJsonFile(getPulledMemoriesFile(repoRoot), memories);
+    await updateRepoContext((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        lastPullAt: new Date().toISOString(),
+    }), cwd);
+}
+export async function getPulledMemories(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    return readJsonFile(getPulledMemoriesFile(repoRoot), []);
+}
+export async function setPulledFixes(fixes, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    await writeJsonFile(getPulledFixesFile(repoRoot), fixes);
+    await updateRepoContext((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        lastPullAt: new Date().toISOString(),
+    }), cwd);
+}
+export async function getPulledFixes(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    return readJsonFile(getPulledFixesFile(repoRoot), []);
+}
+export async function markPushCompleted(cwd = process.cwd()) {
+    return updateRepoContext((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        lastPushAt: new Date().toISOString(),
+    }), cwd);
+}
+export function summarizeLocalMemoryMatches(entries, query) {
+    const needle = query.trim().toLowerCase();
+    if (!needle)
+        return [];
+    return entries.filter((entry) => {
+        const haystack = [entry.content, ...entry.tags].join(" ").toLowerCase();
+        return haystack.includes(needle);
+    });
+}

package/dist/umbrella.d.ts

@@ -0,0 +1,45 @@
+type DeploymentHealth = {
+    deploymentMode?: "local_trusted" | "authenticated";
+};
+export type UmbrellaCompany = {
+    id: string;
+    name: string;
+    issuePrefix: string;
+};
+export type UmbrellaContextSpace = {
+    id: string;
+    name: string;
+    isPrimary: boolean;
+};
+export type UmbrellaCliSetup = {
+    companyId: string;
+    companyName: string;
+    workspaceId: string;
+    workspaceName: string;
+    activeSpaceId: string;
+    activeSpaceName: string;
+    baseUrl: string;
+    apiKey: string;
+};
+export declare function getUmbrellaHealth(serverUrl: string): Promise<DeploymentHealth>;
+export declare function signInToUmbrella(serverUrl: string, email: string, password: string): Promise<{
+    cookie: string | null;
+}>;
+export declare function listUmbrellaCompanies(serverUrl: string, cookie?: string | null): Promise<UmbrellaCompany[]>;
+export declare function createUmbrellaCompany(serverUrl: string, name: string, cookie?: string | null): Promise<UmbrellaCompany>;
+type LearningSummary = {
+    workspaceId: string | null;
+    workspaceName: string | null;
+    activeProjectId: string | null;
+    projectName: string | null;
+    projects: Array<{
+        id: string;
+        name: string;
+        isPrimary: boolean;
+    }>;
+};
+export declare function getCompanyContextSummary(serverUrl: string, companyId: string, cookie?: string | null): Promise<LearningSummary>;
+export declare function createContextSpace(serverUrl: string, companyId: string, name: string, cookie?: string | null): Promise<LearningSummary>;
+export declare function getCliSetup(serverUrl: string, companyId: string, spaceId?: string | null, cookie?: string | null): Promise<UmbrellaCliSetup>;
+export declare function toContextSpaces(summary: LearningSummary): UmbrellaContextSpace[];
+export {};

package/dist/umbrella.js

@@ -0,0 +1,108 @@
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}
+async function requestJson(url, options) {
+    const headers = {
+        Accept: "application/json",
+    };
+    if (options?.body !== undefined) {
+        headers["Content-Type"] = "application/json";
+    }
+    if (options?.cookie) {
+        headers.Cookie = options.cookie;
+    }
+    const response = await fetch(url, {
+        method: options?.method ?? (options?.body === undefined ? "GET" : "POST"),
+        headers,
+        body: options?.body === undefined ? undefined : JSON.stringify(options.body),
+    });
+    const setCookieHeader = response.headers.getSetCookie?.() ?? [];
+    const nextCookie = setCookieHeader
+        .map((entry) => entry.split(";")[0]?.trim())
+        .filter((entry) => Boolean(entry))
+        .join("; ") || null;
+    const payload = await response.json().catch(() => null);
+    if (!response.ok) {
+        const message = payload && typeof payload === "object"
+            ? (() => {
+                const record = payload;
+                const errorValue = record.error;
+                if (typeof errorValue === "string")
+                    return errorValue;
+                if (errorValue && typeof errorValue === "object") {
+                    const messageValue = errorValue.message;
+                    if (typeof messageValue === "string")
+                        return messageValue;
+                }
+                return `Request failed (${response.status})`;
+            })()
+            : `Request failed (${response.status})`;
+        throw new Error(message);
+    }
+    return {
+        data: payload,
+        cookie: nextCookie,
+    };
+}
+export async function getUmbrellaHealth(serverUrl) {
+    const { data } = await requestJson(`${trimTrailingSlash(serverUrl)}/api/health`);
+    return data;
+}
+export async function signInToUmbrella(serverUrl, email, password) {
+    const normalized = trimTrailingSlash(serverUrl);
+    const { cookie } = await requestJson(`${normalized}/api/auth/sign-in/email`, {
+        method: "POST",
+        body: { email, password },
+    });
+    const session = await requestJson(`${normalized}/api/auth/get-session`, {
+        cookie,
+    });
+    return {
+        cookie: session.cookie ?? cookie,
+    };
+}
+export async function listUmbrellaCompanies(serverUrl, cookie) {
+    const normalized = trimTrailingSlash(serverUrl);
+    const { data } = await requestJson(`${normalized}/api/companies`, {
+        cookie,
+    });
+    return data;
+}
+export async function createUmbrellaCompany(serverUrl, name, cookie) {
+    const normalized = trimTrailingSlash(serverUrl);
+    const { data } = await requestJson(`${normalized}/api/companies`, {
+        method: "POST",
+        cookie,
+        body: { name },
+    });
+    return data;
+}
+export async function getCompanyContextSummary(serverUrl, companyId, cookie) {
+    const normalized = trimTrailingSlash(serverUrl);
+    const { data } = await requestJson(`${normalized}/api/companies/${companyId}/learning`, {
+        cookie,
+    });
+    return data;
+}
+export async function createContextSpace(serverUrl, companyId, name, cookie) {
+    const normalized = trimTrailingSlash(serverUrl);
+    const { data } = await requestJson(`${normalized}/api/companies/${companyId}/learning/projects`, {
+        method: "POST",
+        cookie,
+        body: { name },
+    });
+    return data;
+}
+export async function getCliSetup(serverUrl, companyId, spaceId, cookie) {
+    const normalized = trimTrailingSlash(serverUrl);
+    const suffix = spaceId ? `?projectId=${encodeURIComponent(spaceId)}` : "";
+    const { data } = await requestJson(`${normalized}/api/companies/${companyId}/learning/cli-setup${suffix}`, { cookie });
+    return data;
+}
+export function toContextSpaces(summary) {
+    return summary.projects.map((project) => ({
+        id: project.id,
+        name: project.name,
+        isPrimary: project.isPrimary,
+    }));
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "umbrella-context",
+  "version": "0.1.2",
+  "description": "Umbrella Context CLI for connecting a device to company context spaces, querying saved context, and syncing MCP access.",
+  "type": "module",
+  "bin": {
+    "umbrella-context": "./dist/index.js",
+    "agent-memory": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "license": "MIT",
+  "scripts": {
+    "dev": "tsx src/index.ts",
+    "build": "tsc",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "cac": "^6.7.14",
+    "chalk": "^5.4.1",
+    "conf": "^13.1.0",
+    "prompts": "^2.4.2",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.5",
+    "@types/prompts": "^2.4.9",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/buildingwithai/Umbrella.git",
+    "directory": "agent-memory/packages/cli"
+  },
+  "homepage": "https://github.com/buildingwithai/Umbrella/tree/main/agent-memory/packages/cli"
+}