umbrella-context 0.1.39 → 0.1.41

package/dist/commands/worktree.js

@@ -0,0 +1,141 @@
+import chalk from "chalk";
+import { addRegisteredWorktree, getRepoResolution, listRegisteredWorktrees, removeRegisteredWorktree, setSessionPanel, recordSessionEvent, } from "../repo-state.js";
+function asOutputFormat(value) {
+    return value === "json" ? "json" : "text";
+}
+function normalizeCliPathInput(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+export async function worktreeAddCommandAction(targetPath, opts = {}) {
+    const format = asOutputFormat(opts.format);
+    try {
+        await setSessionPanel("session", "worktree-add");
+        const result = await addRegisteredWorktree(normalizeCliPathInput(targetPath ?? process.cwd()), {
+            force: Boolean(opts.force),
+            name: opts.name,
+        });
+        await recordSessionEvent({
+            kind: "session",
+            title: "Registered a worktree",
+            detail: result.message,
+            panel: "session",
+            focus: "worktree-add",
+            status: "success",
+        });
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "worktree.add", ...result }, null, 2));
+            return;
+        }
+        console.log(chalk.green(`\n ${result.message}`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "worktree.add", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export async function worktreeListCommandAction(opts = {}) {
+    const format = asOutputFormat(opts.format);
+    try {
+        await setSessionPanel("session", "worktree-list");
+        const resolution = await getRepoResolution();
+        const worktrees = await listRegisteredWorktrees();
+        const payload = {
+            mode: resolution.mode,
+            projectRoot: resolution.projectRoot,
+            worktreeRoot: resolution.worktreeRoot,
+            worktrees,
+        };
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "worktree.list", ...payload }, null, 2));
+            return;
+        }
+        console.log(chalk.bold("\n Worktrees\n"));
+        if (resolution.mode === "linked") {
+            console.log(`Current folder is linked to: ${resolution.projectRoot}`);
+            console.log(`Linked worktree folder: ${resolution.worktreeRoot}`);
+        }
+        else {
+            console.log(`Project root: ${resolution.projectRoot}`);
+        }
+        console.log("");
+        if (worktrees.length === 0) {
+            console.log(chalk.yellow("No extra worktrees are registered yet."));
+            return;
+        }
+        worktrees.forEach((entry) => {
+            console.log(`- ${entry.name} -> ${entry.worktreePath}`);
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "worktree.list", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export async function worktreeRemoveCommandAction(targetPath, opts = {}) {
+    const format = asOutputFormat(opts.format);
+    try {
+        await setSessionPanel("session", "worktree-remove");
+        const result = await removeRegisteredWorktree(normalizeCliPathInput(targetPath ?? process.cwd()));
+        await recordSessionEvent({
+            kind: "session",
+            title: "Removed a worktree",
+            detail: result.message,
+            panel: "session",
+            focus: "worktree-remove",
+            status: "success",
+        });
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: true, action: "worktree.remove", ...result }, null, 2));
+            return;
+        }
+        console.log(chalk.green(`\n ${result.message}`));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (format === "json") {
+            console.log(JSON.stringify({ ok: false, action: "worktree.remove", error: message }, null, 2));
+            return;
+        }
+        console.log(chalk.red(`\n ${message}`));
+    }
+}
+export function worktreeCommand(cli) {
+    cli
+        .command("worktree <action> [...pathParts]", "Register subfolders or sibling checkouts as worktrees of this Umbrella repo")
+        .example('worktree add "C:\\Dev\\Shared Repo"')
+        .example("worktree list")
+        .example("worktree remove ../other-checkout")
+        .option("--force", "Replace an existing .um folder in the target with a worktree link")
+        .option("--name <name>", "Friendly name for the worktree")
+        .option("--format <format>", "Output format (text or json)")
+        .action(async (action, pathParts = [], opts) => {
+        const normalized = action.trim().toLowerCase();
+        const targetPath = pathParts.join(" ").trim();
+        if (normalized === "add") {
+            await worktreeAddCommandAction(targetPath, opts);
+            return;
+        }
+        if (normalized === "list") {
+            await worktreeListCommandAction(opts);
+            return;
+        }
+        if (normalized === "remove") {
+            await worktreeRemoveCommandAction(targetPath, opts);
+            return;
+        }
+        console.log(chalk.red("Use one of: worktree add [path], worktree list, worktree remove [path]"));
+    });
+}

package/dist/index.js

@@ -29,6 +29,10 @@ import { tasksCommand } from "./commands/tasks.js";
 import { treeCommand } from "./commands/tree.js";
 import { transportCommand } from "./commands/transport.js";
 import { bridgeCommand } from "./commands/bridge.js";
+import { swarmCommand } from "./commands/swarm.js";
+import { worktreeCommand } from "./commands/worktree.js";
+import { sourceCommand } from "./commands/source.js";
+import { adaptiveCommand } from "./commands/adaptive.js";
 import { curateViewCommandAction } from "./commands/curate.js";
 function readCliVersion() {
     try {
@@ -72,6 +76,10 @@ tasksCommand(cli);
 treeCommand(cli);
 transportCommand(cli);
 bridgeCommand(cli);
+swarmCommand(cli);
+worktreeCommand(cli);
+sourceCommand(cli);
+adaptiveCommand(cli);
 cli
     .command("query [...args]", `Alias for search
 

package/dist/repo-state.d.ts

@@ -98,6 +98,24 @@ export type LocalConnectorRun = {
     summary: string;
     ranAt: string;
 };
+export type LocalWorktreeLink = {
+    version: 1;
+    projectRoot: string;
+    linkedAt: string;
+    source: "umbrella-worktree";
+};
+export type LocalWorktreeEntry = {
+    id: string;
+    name: string;
+    registeredAt: string;
+    worktreePath: string;
+};
+export type LocalKnowledgeSourceEntry = {
+    addedAt: string;
+    alias: string;
+    id: string;
+    projectRoot: string;
+};
 export type RepoSessionState = {
     version: 1;
     id: string;
@@ -248,6 +266,12 @@ export type RepoContextTreeState = {
     };
     nodes: ContextTreeNode[];
 };
+export type RepoRootResolution = {
+    mode: "direct" | "linked";
+    projectRoot: string;
+    worktreeRoot: string | null;
+};
+export declare function resolveRepoRoot(startDir?: string): Promise<RepoRootResolution>;
 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<{
@@ -255,6 +279,53 @@ export declare function getRepoContext(cwd?: string): Promise<{
     state: RepoContextState | null;
     umDir: string;
 }>;
+export declare function getRepoResolution(cwd?: string): Promise<RepoRootResolution>;
+export declare function getWorktreeLink(cwd?: string): Promise<{
+    projectRoot: string;
+    version: 1;
+    linkedAt: string;
+    source: "umbrella-worktree";
+} | null>;
+export declare function listRegisteredWorktrees(cwd?: string): Promise<{
+    worktreePath: string;
+    id: string;
+    name: string;
+    registeredAt: string;
+}[]>;
+export declare function addRegisteredWorktree(worktreePath: string, opts?: {
+    force?: boolean;
+    name?: string;
+}, cwd?: string): Promise<{
+    changed: boolean;
+    message: string;
+    projectRoot: string;
+    worktreePath: string;
+}>;
+export declare function removeRegisteredWorktree(worktreePath: string, cwd?: string): Promise<{
+    changed: boolean;
+    message: string;
+    projectRoot: string;
+    worktreePath: string;
+}>;
+export declare function listKnowledgeSources(cwd?: string): Promise<{
+    valid: boolean;
+    projectRoot: string;
+    addedAt: string;
+    alias: string;
+    id: string;
+}[]>;
+export declare function addKnowledgeSource(targetPath: string, opts?: {
+    alias?: string;
+}, cwd?: string): Promise<{
+    added: boolean;
+    alias: string;
+    message: string;
+    projectRoot: string;
+}>;
+export declare function removeKnowledgeSource(aliasOrPath: string, cwd?: string): Promise<{
+    message: string;
+    removed: boolean;
+}>;
 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[]>;

package/dist/repo-state.js

@@ -16,6 +16,9 @@ const TASKS_FILE = "tasks.json";
 const TRANSPORT_FILE = "transport.json";
 const CONTEXT_TREE_STATE_FILE = "context-tree.json";
 const QUERY_CACHE_FILE = "query-cache.json";
+const WORKTREE_LINK_FILE = "worktree-link.json";
+const WORKTREES_FILE = "worktrees.json";
+const SOURCES_FILE = "sources.json";
 const HUB_ASSETS_DIR = "hub";
 const CONNECTOR_ASSETS_DIR = "connectors";
 const CONNECTOR_RUN_REPORTS_DIR = "connector-runs";
@@ -139,15 +142,52 @@ async function findNearestPackageRoot(startDir = process.cwd()) {
         current = parent;
     }
 }
-export async function findRepoRoot(startDir = process.cwd()) {
+async function readWorktreeLink(candidateDir) {
+    const linkPath = path.join(candidateDir, UM_DIR, WORKTREE_LINK_FILE);
+    if (!(await pathExists(linkPath)))
+        return null;
+    const link = await readJsonFile(linkPath, null);
+    if (!link?.projectRoot)
+        return null;
+    return {
+        link,
+        linkPath,
+    };
+}
+async function resolveRepoRootFromWorktreeLink(startDir = process.cwd()) {
+    let current = path.resolve(startDir);
+    while (true) {
+        const linked = await readWorktreeLink(current);
+        if (linked) {
+            return {
+                mode: "linked",
+                projectRoot: path.resolve(linked.link.projectRoot),
+                worktreeRoot: current,
+            };
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export async function resolveRepoRoot(startDir = process.cwd()) {
+    const linked = await resolveRepoRootFromWorktreeLink(startDir);
+    if (linked)
+        return linked;
     try {
         const gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
             cwd: startDir,
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
-        if (gitRoot)
-            return path.resolve(gitRoot);
+        if (gitRoot) {
+            return {
+                mode: "direct",
+                projectRoot: path.resolve(gitRoot),
+                worktreeRoot: null,
+            };
+        }
     }
     catch {
         // Fall back to local heuristics when git is unavailable or the cwd is not inside a git repo.
@@ -155,17 +195,30 @@ export async function findRepoRoot(startDir = process.cwd()) {
     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, ".git"))) {
+            return {
+                mode: "direct",
+                projectRoot: current,
+                worktreeRoot: null,
+            };
+        }
         if (!nearestPackageJsonDir && await pathExists(path.join(current, "package.json"))) {
             nearestPackageJsonDir = current;
         }
         const parent = path.dirname(current);
-        if (parent === current)
-            return nearestPackageJsonDir ?? path.resolve(startDir);
+        if (parent === current) {
+            return {
+                mode: "direct",
+                projectRoot: nearestPackageJsonDir ?? path.resolve(startDir),
+                worktreeRoot: null,
+            };
+        }
         current = parent;
     }
 }
+export async function findRepoRoot(startDir = process.cwd()) {
+    return (await resolveRepoRoot(startDir)).projectRoot;
+}
 async function copyMissingFiles(sourceDir, targetDir) {
     if (!(await pathExists(sourceDir)))
         return;
@@ -232,6 +285,15 @@ function getContextTreeStateFile(repoRoot) {
 function getQueryCacheFile(repoRoot) {
     return path.join(getUmDir(repoRoot), QUERY_CACHE_FILE);
 }
+function getWorktreeLinkFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), WORKTREE_LINK_FILE);
+}
+function getWorktreesFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), WORKTREES_FILE);
+}
+function getSourcesFile(repoRoot) {
+    return path.join(getUmDir(repoRoot), SOURCES_FILE);
+}
 async function ensureUmDir(repoRoot) {
     await fs.mkdir(getUmDir(repoRoot), { recursive: true });
 }
@@ -328,6 +390,197 @@ export async function getRepoContext(cwd = process.cwd()) {
     const state = await readJsonFile(getContextFile(repoRoot), null);
     return { repoRoot, state, umDir: getUmDir(repoRoot) };
 }
+export async function getRepoResolution(cwd = process.cwd()) {
+    const resolution = await resolveRepoRoot(cwd);
+    await migrateLegacyUmDir(cwd, resolution.projectRoot);
+    return resolution;
+}
+export async function getWorktreeLink(cwd = process.cwd()) {
+    const resolution = await resolveRepoRoot(cwd);
+    if (resolution.mode !== "linked" || !resolution.worktreeRoot)
+        return null;
+    const raw = await readJsonFile(getWorktreeLinkFile(resolution.worktreeRoot), null);
+    return raw && raw.projectRoot
+        ? {
+            ...raw,
+            projectRoot: path.resolve(raw.projectRoot),
+        }
+        : null;
+}
+export async function listRegisteredWorktrees(cwd = process.cwd()) {
+    const repoRoot = await findRepoRoot(cwd);
+    const entries = await readJsonFile(getWorktreesFile(repoRoot), []);
+    return uniqueBy(entries.map((entry) => ({
+        ...entry,
+        worktreePath: path.resolve(entry.worktreePath),
+    })), (entry) => entry.worktreePath.toLowerCase());
+}
+export async function addRegisteredWorktree(worktreePath, opts = {}, cwd = process.cwd()) {
+    const repoRoot = await findRepoRoot(cwd);
+    const targetPath = path.resolve(worktreePath);
+    if (targetPath === repoRoot) {
+        throw new Error("The current repo root is already the main project, so it does not need a worktree link.");
+    }
+    const targetUmDir = getUmDir(targetPath);
+    const existingLink = await readJsonFile(getWorktreeLinkFile(targetPath), null);
+    if (existingLink?.projectRoot && path.resolve(existingLink.projectRoot) === repoRoot) {
+        return {
+            changed: false,
+            message: `${targetPath} is already linked to ${repoRoot}.`,
+            projectRoot: repoRoot,
+            worktreePath: targetPath,
+        };
+    }
+    const backupPath = path.join(targetPath, ".um-backup");
+    if ((await pathExists(targetUmDir)) && !existingLink) {
+        if (!opts.force) {
+            throw new Error(`"${targetPath}" already has its own .um folder. Re-run with --force to back it up and link it as a worktree.`);
+        }
+        if (await pathExists(backupPath)) {
+            throw new Error(`"${targetPath}" already has a .um-backup folder. Please clean that up before forcing a new worktree link.`);
+        }
+        await fs.rename(targetUmDir, backupPath);
+    }
+    await ensureUmDir(targetPath);
+    const link = {
+        version: 1,
+        projectRoot: repoRoot,
+        linkedAt: new Date().toISOString(),
+        source: "umbrella-worktree",
+    };
+    await writeJsonFile(getWorktreeLinkFile(targetPath), link);
+    const entries = await listRegisteredWorktrees(cwd);
+    const nextEntry = {
+        id: existingLink?.projectRoot ? existingLink.projectRoot : randomUUID(),
+        name: opts.name?.trim() || path.basename(targetPath),
+        registeredAt: new Date().toISOString(),
+        worktreePath: targetPath,
+    };
+    const nextEntries = uniqueBy([nextEntry, ...entries.filter((entry) => entry.worktreePath.toLowerCase() !== targetPath.toLowerCase())], (entry) => entry.worktreePath.toLowerCase());
+    await writeJsonFile(getWorktreesFile(repoRoot), nextEntries);
+    return {
+        changed: true,
+        message: `Linked ${targetPath} to ${repoRoot} as a worktree.`,
+        projectRoot: repoRoot,
+        worktreePath: targetPath,
+    };
+}
+export async function removeRegisteredWorktree(worktreePath, cwd = process.cwd()) {
+    const targetPath = path.resolve(worktreePath);
+    const linked = await readJsonFile(getWorktreeLinkFile(targetPath), null);
+    if (!linked?.projectRoot) {
+        const repoRoot = await findRepoRoot(cwd);
+        const entries = await readJsonFile(getWorktreesFile(repoRoot), []);
+        const normalizedInput = worktreePath.trim().toLowerCase();
+        const matchingEntry = entries.find((entry) => path.resolve(entry.worktreePath).toLowerCase() === targetPath.toLowerCase() ||
+            entry.name.toLowerCase() === normalizedInput);
+        if (!matchingEntry) {
+            throw new Error(`"${targetPath}" is not linked as an Umbrella worktree.`);
+        }
+        const nextEntries = entries.filter((entry) => entry.id !== matchingEntry.id);
+        await writeJsonFile(getWorktreesFile(repoRoot), nextEntries);
+        return {
+            changed: true,
+            message: await pathExists(targetPath)
+                ? `Removed the stale worktree registration for ${targetPath}. The folder is still there, but its link file is missing.`
+                : `Removed the stale worktree registration for missing folder ${targetPath}.`,
+            projectRoot: repoRoot,
+            worktreePath: targetPath,
+        };
+    }
+    const repoRoot = path.resolve(linked.projectRoot);
+    const entries = await readJsonFile(getWorktreesFile(repoRoot), []);
+    const nextEntries = entries.filter((entry) => path.resolve(entry.worktreePath).toLowerCase() !== targetPath.toLowerCase());
+    await writeJsonFile(getWorktreesFile(repoRoot), nextEntries);
+    const linkFile = getWorktreeLinkFile(targetPath);
+    if (await pathExists(linkFile)) {
+        await fs.rm(linkFile, { force: true });
+    }
+    const targetUmDir = getUmDir(targetPath);
+    const backupPath = path.join(targetPath, ".um-backup");
+    if (await pathExists(backupPath)) {
+        try {
+            const remaining = await fs.readdir(targetUmDir);
+            if (remaining.length === 0) {
+                await fs.rm(targetUmDir, { recursive: true, force: true });
+            }
+        }
+        catch {
+            // Ignore cleanup issues before restore.
+        }
+        if (!(await pathExists(targetUmDir))) {
+            await fs.rename(backupPath, targetUmDir);
+        }
+    }
+    return {
+        changed: true,
+        message: `Removed the worktree link for ${targetPath}.`,
+        projectRoot: repoRoot,
+        worktreePath: targetPath,
+    };
+}
+export async function listKnowledgeSources(cwd = process.cwd()) {
+    const repoRoot = await findRepoRoot(cwd);
+    const entries = await readJsonFile(getSourcesFile(repoRoot), []);
+    const withStatus = await Promise.all(uniqueBy(entries.map((entry) => ({
+        ...entry,
+        projectRoot: path.resolve(entry.projectRoot),
+    })), (entry) => entry.projectRoot.toLowerCase()).map(async (entry) => ({
+        ...entry,
+        valid: await pathExists(getContextFile(entry.projectRoot)),
+    })));
+    return withStatus;
+}
+export async function addKnowledgeSource(targetPath, opts = {}, cwd = process.cwd()) {
+    const repoRoot = await findRepoRoot(cwd);
+    const sourceRoot = await findRepoRoot(path.resolve(targetPath));
+    if (sourceRoot.toLowerCase() === repoRoot.toLowerCase()) {
+        throw new Error("A repo cannot add itself as a knowledge source.");
+    }
+    if (!(await pathExists(getContextFile(sourceRoot)))) {
+        throw new Error(`"${sourceRoot}" does not look like a configured Umbrella repo yet. Run setup there first.`);
+    }
+    const alias = (opts.alias?.trim() || path.basename(sourceRoot)).replace(/\s+/g, "-");
+    const entries = await readJsonFile(getSourcesFile(repoRoot), []);
+    const existing = entries.find((entry) => entry.alias.toLowerCase() === alias.toLowerCase() ||
+        path.resolve(entry.projectRoot).toLowerCase() === sourceRoot.toLowerCase());
+    if (existing) {
+        return {
+            added: false,
+            alias: existing.alias,
+            message: `${existing.alias} is already linked as a knowledge source.`,
+            projectRoot: sourceRoot,
+        };
+    }
+    const nextEntry = {
+        addedAt: new Date().toISOString(),
+        alias,
+        id: randomUUID(),
+        projectRoot: sourceRoot,
+    };
+    await writeJsonFile(getSourcesFile(repoRoot), [...entries, nextEntry]);
+    return {
+        added: true,
+        alias,
+        message: `Added ${alias} as a read-only knowledge source from ${sourceRoot}.`,
+        projectRoot: sourceRoot,
+    };
+}
+export async function removeKnowledgeSource(aliasOrPath, cwd = process.cwd()) {
+    const repoRoot = await findRepoRoot(cwd);
+    const entries = await readJsonFile(getSourcesFile(repoRoot), []);
+    const normalizedInput = path.resolve(aliasOrPath).toLowerCase();
+    const nextEntries = entries.filter((entry) => entry.alias.toLowerCase() !== aliasOrPath.trim().toLowerCase() &&
+        path.resolve(entry.projectRoot).toLowerCase() !== normalizedInput);
+    if (nextEntries.length === entries.length) {
+        throw new Error(`Could not find a knowledge source matching "${aliasOrPath}".`);
+    }
+    await writeJsonFile(getSourcesFile(repoRoot), nextEntries);
+    return {
+        message: `Removed knowledge source "${aliasOrPath}".`,
+        removed: true,
+    };
+}
 export async function updateRepoContext(updater, cwd = process.cwd()) {
     const { repoRoot, state } = await getRepoContext(cwd);
     if (!state)