umbrella-context 0.1.2 → 0.1.20

package/dist/repo-state.js

@@ -1,11 +1,38 @@
 import { promises as fs } from "fs";
 import path from "path";
 import { randomUUID } from "crypto";
+import { execFileSync } from "child_process";
 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";
+const CONNECTORS_FILE = "connectors.json";
+const HUB_FILE = "hub.json";
+const CONNECTOR_RUNS_FILE = "connector-runs.json";
+const SESSION_FILE = "session.json";
+const HUB_ASSETS_DIR = "hub";
+const CONNECTOR_ASSETS_DIR = "connectors";
+const CONNECTOR_RUN_REPORTS_DIR = "connector-runs";
+function normalizeSessionState(state) {
+    if (!state)
+        return null;
+    return {
+        ...state,
+        commandHistory: state.commandHistory ?? [],
+        recentQueries: state.recentQueries ?? [],
+        recentCurations: state.recentCurations ?? [],
+        lastSummary: state.lastSummary ?? null,
+        currentPanel: state.currentPanel ?? null,
+        currentFocus: state.currentFocus ?? null,
+        panelHistory: state.panelHistory ?? [],
+        recentProviderIds: state.recentProviderIds ?? [],
+        recentModels: state.recentModels ?? [],
+        recentHubSlugs: state.recentHubSlugs ?? [],
+        recentConnectorSources: state.recentConnectorSources ?? [],
+        events: state.events ?? [],
+    };
+}
 async function pathExists(targetPath) {
     try {
         await fs.access(targetPath);
@@ -15,19 +42,71 @@ async function pathExists(targetPath) {
         return false;
     }
 }
+async function findNearestPackageRoot(startDir = process.cwd()) {
+    let current = path.resolve(startDir);
+    while (true) {
+        if (await pathExists(path.join(current, "package.json")))
+            return current;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
 export async function findRepoRoot(startDir = process.cwd()) {
+    try {
+        const gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            cwd: startDir,
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (gitRoot)
+            return path.resolve(gitRoot);
+    }
+    catch {
+        // Fall back to local heuristics when git is unavailable or the cwd is not inside a git repo.
+    }
     let current = path.resolve(startDir);
+    let nearestPackageJsonDir = null;
     while (true) {
         if (await pathExists(path.join(current, ".git")))
             return current;
-        if (await pathExists(path.join(current, "package.json")))
-            return current;
+        if (!nearestPackageJsonDir && await pathExists(path.join(current, "package.json"))) {
+            nearestPackageJsonDir = current;
+        }
         const parent = path.dirname(current);
         if (parent === current)
-            return path.resolve(startDir);
+            return nearestPackageJsonDir ?? path.resolve(startDir);
         current = parent;
     }
 }
+async function copyMissingFiles(sourceDir, targetDir) {
+    if (!(await pathExists(sourceDir)))
+        return;
+    await fs.mkdir(targetDir, { recursive: true });
+    const entries = await fs.readdir(sourceDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const source = path.join(sourceDir, entry.name);
+        const target = path.join(targetDir, entry.name);
+        if (await pathExists(target))
+            continue;
+        await fs.copyFile(source, target);
+    }
+}
+function uniqueBy(items, key) {
+    const seen = new Set();
+    const result = [];
+    for (const item of items) {
+        const nextKey = key(item);
+        if (seen.has(nextKey))
+            continue;
+        seen.add(nextKey);
+        result.push(item);
+    }
+    return result;
+}
 function getUmDir(repoRoot) {
     return path.join(repoRoot, UM_DIR);
 }
@@ -43,9 +122,26 @@ function getPulledMemoriesFile(repoRoot) {
 function getPulledFixesFile(repoRoot) {
     return path.join(getUmDir(repoRoot), PULLED_FIXES_FILE);
 }
+function getConnectorsFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), CONNECTORS_FILE);
+}
+function getHubFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), HUB_FILE);
+}
+function getConnectorRunsFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), CONNECTOR_RUNS_FILE);
+}
+function getSessionFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), SESSION_FILE);
+}
 async function ensureUmDir(repoRoot) {
     await fs.mkdir(getUmDir(repoRoot), { recursive: true });
 }
+async function ensureSubDir(repoRoot, name) {
+    const target = path.join(getUmDir(repoRoot), name);
+    await fs.mkdir(target, { recursive: true });
+    return target;
+}
 async function readJsonFile(filePath, fallback) {
     try {
         const raw = await fs.readFile(filePath, "utf8");
@@ -58,8 +154,47 @@ async function readJsonFile(filePath, fallback) {
 async function writeJsonFile(filePath, data) {
     await fs.writeFile(filePath, JSON.stringify(data, null, 2), "utf8");
 }
+async function migrateLegacyUmDir(startDir, repoRoot) {
+    const legacyRoot = await findNearestPackageRoot(startDir);
+    if (!legacyRoot || legacyRoot === repoRoot)
+        return;
+    const legacyUmDir = getUmDir(legacyRoot);
+    if (!(await pathExists(legacyUmDir)))
+        return;
+    await ensureUmDir(repoRoot);
+    const mergeArrayFile = async (fileName, fallback, key) => {
+        const legacyPath = path.join(legacyUmDir, fileName);
+        if (!(await pathExists(legacyPath)))
+            return;
+        const rootPath = path.join(getUmDir(repoRoot), fileName);
+        const legacyItems = await readJsonFile(legacyPath, fallback);
+        const rootItems = await readJsonFile(rootPath, fallback);
+        const merged = uniqueBy([...rootItems, ...legacyItems], key);
+        await writeJsonFile(rootPath, merged);
+    };
+    const rootContextPath = getContextFile(repoRoot);
+    const legacyContextPath = getContextFile(legacyRoot);
+    if (!(await pathExists(rootContextPath)) && await pathExists(legacyContextPath)) {
+        await fs.copyFile(legacyContextPath, rootContextPath);
+    }
+    await mergeArrayFile(PENDING_MEMORIES_FILE, [], (item) => item.id);
+    await mergeArrayFile(PULLED_MEMORIES_FILE, [], (item) => item.id);
+    await mergeArrayFile(PULLED_FIXES_FILE, [], (item) => item.id);
+    await mergeArrayFile(CONNECTORS_FILE, [], (item) => item.source);
+    await mergeArrayFile(HUB_FILE, [], (item) => item.slug);
+    await mergeArrayFile(CONNECTOR_RUNS_FILE, [], (item) => item.id);
+    await copyMissingFiles(path.join(legacyUmDir, HUB_ASSETS_DIR), path.join(getUmDir(repoRoot), HUB_ASSETS_DIR));
+    await copyMissingFiles(path.join(legacyUmDir, CONNECTOR_ASSETS_DIR), path.join(getUmDir(repoRoot), CONNECTOR_ASSETS_DIR));
+    await copyMissingFiles(path.join(legacyUmDir, CONNECTOR_RUN_REPORTS_DIR), path.join(getUmDir(repoRoot), CONNECTOR_RUN_REPORTS_DIR));
+    const legacySessionPath = getSessionFile(legacyRoot);
+    const rootSessionPath = getSessionFile(repoRoot);
+    if (!(await pathExists(rootSessionPath)) && await pathExists(legacySessionPath)) {
+        await fs.copyFile(legacySessionPath, rootSessionPath);
+    }
+}
 export async function ensureRepoContext(config, cwd = process.cwd()) {
     const repoRoot = await findRepoRoot(cwd);
+    await migrateLegacyUmDir(cwd, repoRoot);
     await ensureUmDir(repoRoot);
     const now = new Date().toISOString();
     const nextState = {
@@ -89,6 +224,7 @@ export async function ensureRepoContext(config, cwd = process.cwd()) {
 }
 export async function getRepoContext(cwd = process.cwd()) {
     const repoRoot = await findRepoRoot(cwd);
+    await migrateLegacyUmDir(cwd, repoRoot);
     const state = await readJsonFile(getContextFile(repoRoot), null);
     return { repoRoot, state, umDir: getUmDir(repoRoot) };
 }
@@ -160,6 +296,286 @@ export async function markPushCompleted(cwd = process.cwd()) {
         lastPushAt: new Date().toISOString(),
     }), cwd);
 }
+export async function getInstalledConnectors(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const connectors = await readJsonFile(getConnectorsFile(repoRoot), []);
+    const deduped = uniqueBy(connectors, (item) => item.source);
+    if (deduped.length !== connectors.length) {
+        await writeJsonFile(getConnectorsFile(repoRoot), deduped);
+    }
+    return deduped;
+}
+export async function setInstalledConnectors(connectors, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    await writeJsonFile(getConnectorsFile(repoRoot), uniqueBy(connectors, (item) => item.source));
+    await updateRepoContext((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+    }), cwd);
+}
+export async function getInstalledHubEntries(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const entries = await readJsonFile(getHubFile(repoRoot), []);
+    const deduped = uniqueBy(entries, (item) => item.slug);
+    if (deduped.length !== entries.length) {
+        await writeJsonFile(getHubFile(repoRoot), deduped);
+    }
+    return deduped;
+}
+export async function setInstalledHubEntries(entries, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    await writeJsonFile(getHubFile(repoRoot), uniqueBy(entries, (item) => item.slug));
+    await updateRepoContext((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+    }), cwd);
+}
+export async function writeHubAsset(slug, content, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const dir = await ensureSubDir(repoRoot, HUB_ASSETS_DIR);
+    const filePath = path.join(dir, `${slug}.md`);
+    await fs.writeFile(filePath, content, "utf8");
+    return filePath;
+}
+export async function writeHubAssetFiles(slug, files, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const rootDir = await ensureSubDir(repoRoot, HUB_ASSETS_DIR);
+    const dir = path.join(rootDir, slug);
+    await fs.mkdir(dir, { recursive: true });
+    const written = [];
+    for (const file of files) {
+        const filePath = path.join(dir, file.name);
+        await fs.writeFile(filePath, file.content, "utf8");
+        written.push(filePath);
+    }
+    return written;
+}
+export async function writeConnectorAsset(source, content, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const dir = await ensureSubDir(repoRoot, CONNECTOR_ASSETS_DIR);
+    const filePath = path.join(dir, `${source}.json`);
+    await writeJsonFile(filePath, content);
+    return filePath;
+}
+export async function writeConnectorAssetFiles(source, files, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const rootDir = await ensureSubDir(repoRoot, CONNECTOR_ASSETS_DIR);
+    const dir = path.join(rootDir, source);
+    await fs.mkdir(dir, { recursive: true });
+    const written = [];
+    for (const file of files) {
+        const filePath = path.join(dir, file.name);
+        await fs.writeFile(filePath, file.content, "utf8");
+        written.push(filePath);
+    }
+    return written;
+}
+export async function getConnectorRuns(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    return readJsonFile(getConnectorRunsFile(repoRoot), []);
+}
+export async function addConnectorRun(input, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    const runs = await readJsonFile(getConnectorRunsFile(repoRoot), []);
+    const entry = {
+        id: randomUUID(),
+        ranAt: new Date().toISOString(),
+        ...input,
+    };
+    runs.unshift(entry);
+    await writeJsonFile(getConnectorRunsFile(repoRoot), runs.slice(0, 25));
+    await updateRepoContext((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+    }), cwd);
+    return entry;
+}
+export async function writeConnectorRunReport(run, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const dir = await ensureSubDir(repoRoot, CONNECTOR_RUN_REPORTS_DIR);
+    const filePath = path.join(dir, `${run.id}.md`);
+    const markdown = [
+        `# ${run.connectorName}`,
+        "",
+        `- Status: ${run.status}`,
+        `- Ran At: ${run.ranAt}`,
+        `- Connector ID: ${run.connectorId}`,
+        "",
+        "## Summary",
+        "",
+        run.summary,
+        "",
+    ].join("\n");
+    await fs.writeFile(filePath, markdown, "utf8");
+    return filePath;
+}
+export async function getSessionState(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    return normalizeSessionState(await readJsonFile(getSessionFile(repoRoot), null));
+}
+export async function ensureSessionState(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    const existing = normalizeSessionState(await readJsonFile(getSessionFile(repoRoot), null));
+    if (existing) {
+        await writeJsonFile(getSessionFile(repoRoot), existing);
+        return existing;
+    }
+    const now = new Date().toISOString();
+    const next = {
+        version: 1,
+        id: randomUUID(),
+        startedAt: now,
+        updatedAt: now,
+        commandHistory: [],
+        recentQueries: [],
+        recentCurations: [],
+        lastSummary: null,
+        currentPanel: null,
+        currentFocus: null,
+        panelHistory: [],
+        recentProviderIds: [],
+        recentModels: [],
+        recentHubSlugs: [],
+        recentConnectorSources: [],
+        events: [],
+    };
+    await writeJsonFile(getSessionFile(repoRoot), next);
+    return next;
+}
+export async function resetSessionState(cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    await ensureUmDir(repoRoot);
+    const now = new Date().toISOString();
+    const next = {
+        version: 1,
+        id: randomUUID(),
+        startedAt: now,
+        updatedAt: now,
+        commandHistory: [],
+        recentQueries: [],
+        recentCurations: [],
+        lastSummary: "Started a fresh Context session.",
+        currentPanel: null,
+        currentFocus: null,
+        panelHistory: [],
+        recentProviderIds: [],
+        recentModels: [],
+        recentHubSlugs: [],
+        recentConnectorSources: [],
+        events: [
+            {
+                id: randomUUID(),
+                at: now,
+                kind: "session",
+                title: "Started a fresh Context session",
+                detail: "Local .um data stayed in place, but the live shell history was reset.",
+                panel: "session",
+                focus: null,
+                status: "info",
+            },
+        ],
+    };
+    await writeJsonFile(getSessionFile(repoRoot), next);
+    return next;
+}
+export async function updateSessionState(updater, cwd = process.cwd()) {
+    const { repoRoot } = await getRepoContext(cwd);
+    const current = normalizeSessionState(await ensureSessionState(cwd));
+    if (!current) {
+        throw new Error("Could not initialize repo session state.");
+    }
+    const next = normalizeSessionState(await updater(current));
+    if (!next) {
+        throw new Error("Could not update repo session state.");
+    }
+    await writeJsonFile(getSessionFile(repoRoot), next);
+    return next;
+}
+export async function recordSessionCommand(command, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        commandHistory: [...(state.commandHistory ?? []), command].slice(-50),
+    }), cwd);
+}
+export async function recordSessionQuery(query, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        recentQueries: [query, ...(state.recentQueries ?? []).filter((entry) => entry !== query)].slice(0, 10),
+    }), cwd);
+}
+export async function recordSessionCuration(content, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        recentCurations: [content, ...(state.recentCurations ?? []).filter((entry) => entry !== content)].slice(0, 10),
+    }), cwd);
+}
+export async function setSessionSummary(summary, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        lastSummary: summary,
+    }), cwd);
+}
+export async function setSessionPanel(panel, focus, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        currentPanel: panel,
+        currentFocus: focus ?? null,
+        panelHistory: panel
+            ? [panel, ...(state.panelHistory ?? []).filter((entry) => entry !== panel)].slice(0, 10)
+            : (state.panelHistory ?? []),
+    }), cwd);
+}
+export async function recordSessionProvider(providerId, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        recentProviderIds: [providerId, ...(state.recentProviderIds ?? []).filter((entry) => entry !== providerId)].slice(0, 5),
+    }), cwd);
+}
+export async function recordSessionModel(modelId, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        recentModels: [modelId, ...(state.recentModels ?? []).filter((entry) => entry !== modelId)].slice(0, 5),
+    }), cwd);
+}
+export async function recordSessionHubEntry(slug, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        recentHubSlugs: [slug, ...(state.recentHubSlugs ?? []).filter((entry) => entry !== slug)].slice(0, 5),
+    }), cwd);
+}
+export async function recordSessionConnector(source, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        recentConnectorSources: [source, ...(state.recentConnectorSources ?? []).filter((entry) => entry !== source)].slice(0, 5),
+    }), cwd);
+}
+export async function recordSessionEvent(event, cwd = process.cwd()) {
+    return updateSessionState((state) => ({
+        ...state,
+        updatedAt: new Date().toISOString(),
+        events: [
+            {
+                id: randomUUID(),
+                at: new Date().toISOString(),
+                ...event,
+            },
+            ...(state.events ?? []),
+        ].slice(0, 30),
+    }), cwd);
+}
 export function summarizeLocalMemoryMatches(entries, query) {
     const needle = query.trim().toLowerCase();
     if (!needle)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "umbrella-context",
-  "version": "0.1.2",
+  "version": "0.1.20",
   "description": "Umbrella Context CLI for connecting a device to company context spaces, querying saved context, and syncing MCP access.",
   "type": "module",
   "bin": {