nolo-cli 0.1.38 → 0.1.40

package/agent-runtime/taskWorkspace.ts

@@ -1,193 +0,0 @@
-import {
-  lstat,
-  mkdir,
-  readdir,
-  readFile,
-  readlink,
-  rm,
-  symlink,
-  unlink,
-} from "node:fs/promises";
-import { dirname, join, resolve, sep } from "node:path";
-
-type EnvLike = Record<string, string | undefined>;
-
-export type PreparedGitTaskWorkspace = {
-  path: string;
-  branchName?: string;
-};
-
-export type WorkspacePackageLink = {
-  name: string;
-  target: string;
-  linkPath: string;
-};
-
-function safeTaskWorkspacePathSegment(input: string) {
-  return input.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "agent";
-}
-
-function createTaskWorkspaceId() {
-  return Date.now().toString(36).toUpperCase();
-}
-
-async function runGitForTaskWorkspace(args: string[], cwd: string) {
-  const proc = Bun.spawn(["git", ...args], {
-    cwd,
-    stdout: "pipe",
-    stderr: "pipe",
-    stdin: "ignore",
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
-  if (exitCode !== 0) {
-    throw new Error(stderr.trim() || stdout.trim() || `git ${args.join(" ")} failed`);
-  }
-  return stdout.trim();
-}
-
-function packageLinkPath(nodeModulesPath: string, packageName: string) {
-  if (!packageName.startsWith("@")) {
-    return join(nodeModulesPath, packageName);
-  }
-  const [scope, name] = packageName.split("/");
-  if (!scope || !name) {
-    throw new Error(`Invalid scoped package name: ${packageName}`);
-  }
-  return join(nodeModulesPath, scope, name);
-}
-
-async function readPackageName(packageJsonPath: string) {
-  const text = await readFile(packageJsonPath, "utf8");
-  const parsed = JSON.parse(text) as { name?: unknown };
-  return typeof parsed.name === "string" && parsed.name.trim()
-    ? parsed.name.trim()
-    : null;
-}
-
-export async function collectWorkspacePackageLinks(workspacePath: string) {
-  const packagesRoot = join(workspacePath, "packages");
-  const packageDirs = await readdir(packagesRoot, { withFileTypes: true }).catch(
-    () => []
-  );
-  const nodeModulesPath = join(workspacePath, "node_modules");
-
-  const linksPromises = packageDirs
-    .filter((entry) => entry.isDirectory())
-    .map(async (entry) => {
-      const target = join(packagesRoot, entry.name);
-      const name = await readPackageName(join(target, "package.json")).catch(
-        () => null
-      );
-      if (!name) return null;
-      return {
-        name,
-        target,
-        linkPath: packageLinkPath(nodeModulesPath, name),
-      };
-    });
-
-  const links = (await Promise.all(linksPromises)).filter(Boolean) as WorkspacePackageLink[];
-  return links;
-}
-
-async function ensureWorkspacePackageLink(link: WorkspacePackageLink) {
-  await mkdir(dirname(link.linkPath), { recursive: true });
-  const existing = await Bun.file(link.linkPath).stat().catch(() => null);
-  if (existing) {
-    const existingTarget = await readlinkIfSymlink(link.linkPath);
-    if (
-      existingTarget &&
-      resolve(dirname(link.linkPath), existingTarget) === resolve(link.target)
-    ) {
-      return false;
-    }
-    if (!existingTarget) {
-      throw new Error(`Cannot replace non-symlink workspace package path: ${link.linkPath}`);
-    }
-    await unlink(link.linkPath);
-  }
-  await symlink(link.target, link.linkPath, "dir");
-  return true;
-}
-
-async function readlinkIfSymlink(path: string) {
-  const stat = await lstat(path).catch(() => null);
-  if (!stat?.isSymbolicLink()) return null;
-  return readlink(path);
-}
-
-function isInsideWorkspace(workspacePath: string, path: string) {
-  const workspaceRoot = resolve(workspacePath);
-  const resolvedPath = resolve(path);
-  return resolvedPath === workspaceRoot || resolvedPath.startsWith(`${workspaceRoot}${sep}`);
-}
-
-function isFormalTaskWorkspacePath(path: string) {
-  return resolve(path).split(/[\\/]+/).includes(".worktrees");
-}
-
-async function ensureWorkspaceNodeModulesDirectory(workspacePath: string) {
-  const nodeModulesPath = join(workspacePath, "node_modules");
-  const symlinkTarget = await readlinkIfSymlink(nodeModulesPath);
-  if (symlinkTarget) {
-    const resolvedTarget = resolve(dirname(nodeModulesPath), symlinkTarget);
-    if (!isInsideWorkspace(workspacePath, resolvedTarget)) {
-      await unlink(nodeModulesPath);
-    }
-  }
-  await mkdir(nodeModulesPath, { recursive: true });
-}
-
-export async function ensureWorkspacePackageLinks(workspacePath: string) {
-  const links = await collectWorkspacePackageLinks(workspacePath);
-  if (links.length === 0) {
-    return {
-      workspacePath,
-      links,
-      createdOrUpdated: 0,
-    };
-  }
-  await ensureWorkspaceNodeModulesDirectory(workspacePath);
-  const results = await Promise.all(
-    links.map((link) => ensureWorkspacePackageLink(link))
-  );
-  const createdOrUpdated = results.filter(Boolean).length;
-  return {
-    workspacePath,
-    links,
-    createdOrUpdated,
-  };
-}
-
-export async function prepareGitTaskWorkspace(args: {
-  agentKey: string;
-  cwd?: string;
-  env?: EnvLike;
-}): Promise<PreparedGitTaskWorkspace> {
-  if (args.env?.NOLO_LOCAL_WORKTREE) {
-    await ensureWorkspacePackageLinks(args.env.NOLO_LOCAL_WORKTREE);
-    return { path: args.env.NOLO_LOCAL_WORKTREE };
-  }
-  const cwd = args.cwd ?? process.cwd();
-  const root = resolve(await runGitForTaskWorkspace(["rev-parse", "--show-toplevel"], cwd));
-  if (isFormalTaskWorkspacePath(root)) {
-    await ensureWorkspacePackageLinks(root);
-    return { path: root };
-  }
-  const parent = join(root, ".worktrees");
-  const safeAgent = safeTaskWorkspacePathSegment(args.agentKey);
-  const taskId = createTaskWorkspaceId();
-  const workspacePath = join(parent, `nolo-agent-${safeAgent}-${taskId}`);
-  const branchName = `nolo-agent-${safeAgent}-${taskId}`;
-  await runGitForTaskWorkspace(["worktree", "add", workspacePath, "-b", branchName, "HEAD"], root);
-  await ensureWorkspacePackageLinks(workspacePath);
-  return { path: workspacePath, branchName };
-}
-
-export function formatPreparedGitTaskWorkspace(workspace: PreparedGitTaskWorkspace) {
-  return `[nolo] task worktree: ${workspace.path}${workspace.branchName ? ` (branch ${workspace.branchName})` : ""}\n`;
-}

package/agent-runtime/workspaceSession.ts

@@ -1,76 +0,0 @@
-// Runtime workspace sessions describe where code tools execute.
-// They are intentionally separate from product Spaces (`spaceId`, shared content, membership).
-export type WorkspaceSessionMode = "current" | "task-worktree";
-
-export type PreparedTaskWorkspace = {
-  path: string;
-  branchName?: string;
-};
-
-export type PrepareTaskWorkspace = (args: {
-  agentKey: string;
-  env?: Record<string, string | undefined>;
-}) => Promise<PreparedTaskWorkspace>;
-
-export type WorkspaceSession =
-  | {
-      kind: "current";
-      workspaceRoot: string;
-      explicitCwd: boolean;
-    }
-  | {
-      kind: "task-worktree";
-      workspaceRoot: string;
-      explicitCwd: false;
-      branchName?: string;
-    };
-
-export function createWorkspaceSession(args: {
-  cwd?: string;
-  defaultCwd?: string;
-}): WorkspaceSession {
-  return {
-    kind: "current",
-    workspaceRoot: args.cwd ?? args.defaultCwd ?? process.cwd(),
-    explicitCwd: Boolean(args.cwd),
-  };
-}
-
-export async function activateWorkspaceSession(
-  session: WorkspaceSession,
-  args: {
-    agentKey: string;
-    mode: WorkspaceSessionMode;
-    env?: Record<string, string | undefined>;
-    prepareTaskWorkspace?: PrepareTaskWorkspace;
-  }
-): Promise<WorkspaceSession> {
-  if (args.mode !== "task-worktree") return session;
-  if (session.kind === "task-worktree" || session.explicitCwd) return session;
-  if (!args.prepareTaskWorkspace) {
-    throw new Error("task-worktree workspace sessions require a prepareTaskWorkspace implementation.");
-  }
-  const prepared = await args.prepareTaskWorkspace({
-    agentKey: args.agentKey,
-    env: args.env,
-  });
-  return workspaceSessionFromTaskWorkspace(prepared);
-}
-
-function workspaceSessionFromTaskWorkspace(
-  workspace: PreparedTaskWorkspace
-): WorkspaceSession {
-  return {
-    kind: "task-worktree",
-    workspaceRoot: workspace.path,
-    explicitCwd: false,
-    ...(workspace.branchName ? { branchName: workspace.branchName } : {}),
-  };
-}
-
-export function formatWorkspaceSessionActivation(session: WorkspaceSession) {
-  if (session.kind !== "task-worktree") return "";
-  return `[nolo] workspace session: task-worktree ${session.workspaceRoot}${
-    session.branchName ? ` (branch ${session.branchName})` : ""
-  }\n`;
-}

package/cli/client/taskWorktree.ts

@@ -1,8 +0,0 @@
-export {
-  ensureWorkspacePackageLinks,
-  formatPreparedGitTaskWorkspace as formatPreparedTaskWorktree,
-  prepareGitTaskWorkspace as prepareTaskWorktree,
-} from "../../agent-runtime/taskWorkspace";
-export type {
-  PreparedGitTaskWorkspace as PreparedTaskWorktree,
-} from "../../agent-runtime/taskWorkspace";

package/cli/client/workspaceSession.ts

@@ -1,11 +0,0 @@
-export {
-  activateWorkspaceSession,
-  createWorkspaceSession,
-  formatWorkspaceSessionActivation,
-} from "../../agent-runtime/workspaceSession";
-export type {
-  PrepareTaskWorkspace,
-  PreparedTaskWorkspace,
-  WorkspaceSession,
-  WorkspaceSessionMode,
-} from "../../agent-runtime/workspaceSession";

package/client/taskWorktree.ts

@@ -1,8 +0,0 @@
-export {
-  ensureWorkspacePackageLinks,
-  formatPreparedGitTaskWorkspace as formatPreparedTaskWorktree,
-  prepareGitTaskWorkspace as prepareTaskWorktree,
-} from "../agent-runtime/taskWorkspace";
-export type {
-  PreparedGitTaskWorkspace as PreparedTaskWorktree,
-} from "../agent-runtime/taskWorkspace";

package/client/workspaceSession.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  activateWorkspaceSession,
-  createWorkspaceSession,
-  formatWorkspaceSessionActivation,
-} from "./workspaceSession";
-
-describe("CLI workspace session", () => {
-  test("starts from an explicit workspace root without preparing a task worktree", async () => {
-    const session = createWorkspaceSession({ cwd: "/repo/current" });
-
-    const result = await activateWorkspaceSession(session, {
-      agentKey: "frontend",
-      mode: "task-worktree",
-      prepareTaskWorkspace: async () => {
-        throw new Error("should not prepare a task worktree for explicit cwd");
-      },
-    });
-
-    expect(result.workspaceRoot).toBe("/repo/current");
-    expect(result.kind).toBe("current");
-  });
-
-  test("activates a task worktree once when requested by agent policy", async () => {
-    const calls: string[] = [];
-    let session = createWorkspaceSession({ cwd: undefined });
-
-    session = await activateWorkspaceSession(session, {
-      agentKey: "agent-user-1-frontend",
-      mode: "task-worktree",
-      prepareTaskWorkspace: async ({ agentKey }) => {
-        calls.push(agentKey);
-        return {
-          path: "/repo/.worktrees/nolo-agent-frontend",
-          branchName: "nolo-agent-frontend",
-        };
-      },
-    });
-    session = await activateWorkspaceSession(session, {
-      agentKey: "agent-user-1-frontend",
-      mode: "task-worktree",
-      prepareTaskWorkspace: async () => {
-        throw new Error("task worktree should only be prepared once");
-      },
-    });
-
-    expect(calls).toEqual(["agent-user-1-frontend"]);
-    expect(session).toMatchObject({
-      kind: "task-worktree",
-      workspaceRoot: "/repo/.worktrees/nolo-agent-frontend",
-      branchName: "nolo-agent-frontend",
-    });
-    expect(formatWorkspaceSessionActivation(session)).toContain("workspace session: task-worktree");
-    expect(formatWorkspaceSessionActivation(session)).toContain("/repo/.worktrees/nolo-agent-frontend");
-  });
-});

package/client/workspaceSession.ts

@@ -1,11 +0,0 @@
-export {
-  activateWorkspaceSession,
-  createWorkspaceSession,
-  formatWorkspaceSessionActivation,
-} from "../agent-runtime/workspaceSession";
-export type {
-  PrepareTaskWorkspace,
-  PreparedTaskWorkspace,
-  WorkspaceSession,
-  WorkspaceSessionMode,
-} from "../agent-runtime/workspaceSession";