@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/workflow/session.d.ts

@@ -1,34 +0,0 @@
-import { type TreeseedWorkflowBranchRole } from './policy.js';
-import { type TreeseedManagedRepositoryKind } from '../operations/services/managed-repositories.js';
-export type TreeseedWorkflowMode = 'root-only' | 'recursive-workspace';
-export type TreeseedWorkflowSessionRepo = {
-    name: string;
-    path: string;
-    relativePath: string;
-    kind: TreeseedManagedRepositoryKind | 'package';
-    branchName: string | null;
-    branchRole: TreeseedWorkflowBranchRole;
-    dirty: boolean;
-    detached: boolean;
-    hasOriginRemote: boolean;
-};
-export type TreeseedWorkflowPackageSelection = {
-    changed: string[];
-    dependents: string[];
-    selected: string[];
-};
-export type TreeseedWorkflowSession = {
-    root: string;
-    gitRoot: string;
-    mode: TreeseedWorkflowMode;
-    branchName: string | null;
-    branchRole: TreeseedWorkflowBranchRole;
-    rootRepo: TreeseedWorkflowSessionRepo;
-    managedRepos: TreeseedWorkflowSessionRepo[];
-    packageRepos: TreeseedWorkflowSessionRepo[];
-    packageSelection: TreeseedWorkflowPackageSelection;
-};
-export declare function checkedOutWorkspacePackageRepos(root: string): any[];
-export declare function workflowModeForRoot(root: string): TreeseedWorkflowMode;
-export declare function collectReleasePackageSelection(root: string): TreeseedWorkflowPackageSelection;
-export declare function resolveTreeseedWorkflowSession(cwd: string): TreeseedWorkflowSession;

package/dist/workflow/session.js

@@ -1,160 +0,0 @@
-import { existsSync } from "node:fs";
-import { relative, resolve } from "node:path";
-import {
-  currentBranch,
-  gitStatusPorcelain,
-  originRemoteUrl,
-  repoRoot
-} from "../operations/services/workspace-save.js";
-import {
-  hasCompleteTreeseedPackageCheckout,
-  publishableWorkspacePackages,
-  sortWorkspacePackages,
-  workspacePackages,
-  workspaceRoot
-} from "../operations/services/workspace-tools.js";
-import { discoverTreeseedPackageAdapters } from "../operations/services/package-adapters.js";
-import { runTreeseedGit } from "../operations/services/git-runner.js";
-import {
-  classifyTreeseedBranchRole,
-  resolveTreeseedWorkflowPaths
-} from "./policy.js";
-import {
-  checkedOutManagedWorkflowRepos
-} from "../operations/services/managed-repositories.js";
-function hasOriginRemote(repoDir) {
-  try {
-    originRemoteUrl(repoDir);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function repoState(root, name, repoDir, kind = "package") {
-  const branchName = currentBranch(repoDir) || null;
-  return {
-    name,
-    path: repoDir,
-    relativePath: relative(root, repoDir).replaceAll("\\", "/") || ".",
-    kind,
-    branchName,
-    branchRole: classifyTreeseedBranchRole(branchName, repoDir),
-    dirty: gitStatusPorcelain(repoDir).length > 0,
-    detached: branchName == null,
-    hasOriginRemote: hasOriginRemote(repoDir)
-  };
-}
-function checkedOutWorkspacePackageRepos(root) {
-  let packages = [];
-  try {
-    packages = workspacePackages(root);
-  } catch {
-    packages = [];
-  }
-  if (!hasCompleteTreeseedPackageCheckout(root) && packages.length === 0) {
-    return [];
-  }
-  const repos = /* @__PURE__ */ new Map();
-  for (const pkg of packages.filter((pkg2) => pkg2.name?.startsWith("@treeseed/"))) {
-    if (!existsSync(resolve(pkg.dir, ".git"))) continue;
-    repos.set(pkg.name, pkg);
-  }
-  for (const adapter of discoverTreeseedPackageAdapters(root)) {
-    if (!adapter.publishTarget && adapter.artifacts.length === 0) continue;
-    if (repos.has(adapter.id)) continue;
-    if (!existsSync(resolve(adapter.dir, ".git"))) continue;
-    repos.set(adapter.id, {
-      dir: adapter.dir,
-      name: adapter.id,
-      packageJson: {},
-      relativeDir: adapter.relativeDir
-    });
-  }
-  return sortWorkspacePackages([...repos.values()]);
-}
-function workflowModeForRoot(root) {
-  return hasCompleteTreeseedPackageCheckout(root) ? "recursive-workspace" : "root-only";
-}
-function collectReleasePackageSelection(root) {
-  const publishableByName = /* @__PURE__ */ new Map();
-  for (const pkg of publishableWorkspacePackages(root).filter((pkg2) => pkg2.name?.startsWith("@treeseed/"))) {
-    publishableByName.set(pkg.name, pkg);
-  }
-  for (const adapter of discoverTreeseedPackageAdapters(root)) {
-    if (!adapter.publishTarget && adapter.artifacts.length === 0) continue;
-    if (publishableByName.has(adapter.id)) continue;
-    publishableByName.set(adapter.id, {
-      dir: adapter.dir,
-      name: adapter.id,
-      packageJson: {},
-      relativeDir: adapter.relativeDir
-    });
-  }
-  const publishable = sortWorkspacePackages([...publishableByName.values()]);
-  const changedNames = publishable.filter((pkg) => {
-    const remoteMain = runTreeseedGit(["rev-parse", "--verify", "origin/main"], {
-      cwd: pkg.dir,
-      mode: "read",
-      allowFailure: true
-    });
-    const baseRef = remoteMain.status === 0 ? "origin/main" : "main";
-    const diff = runTreeseedGit(["diff", "--quiet", baseRef, "HEAD"], {
-      cwd: pkg.dir,
-      mode: "read",
-      allowFailure: true
-    });
-    return diff.status !== 0 || gitStatusPorcelain(pkg.dir).length > 0;
-  }).map((pkg) => pkg.name);
-  const selectedNames = new Set(changedNames);
-  const reverseDependencies = new Map(publishable.map((pkg) => [pkg.name, /* @__PURE__ */ new Set()]));
-  const packageNames = new Set(publishable.map((pkg) => pkg.name));
-  for (const pkg of publishable) {
-    for (const field of ["dependencies", "optionalDependencies", "peerDependencies", "devDependencies"]) {
-      const dependencies = pkg.packageJson?.[field];
-      if (!dependencies || typeof dependencies !== "object" || Array.isArray(dependencies)) continue;
-      for (const dependency of Object.keys(dependencies)) {
-        if (packageNames.has(dependency)) reverseDependencies.get(dependency)?.add(pkg.name);
-      }
-    }
-  }
-  const queue = [...changedNames];
-  while (queue.length > 0) {
-    const dependency = queue.shift();
-    for (const dependent of reverseDependencies.get(dependency) ?? []) {
-      if (selectedNames.has(dependent)) continue;
-      selectedNames.add(dependent);
-      queue.push(dependent);
-    }
-  }
-  const selected = publishable.filter((pkg) => selectedNames.has(pkg.name));
-  return {
-    changed: changedNames,
-    dependents: selected.filter((pkg) => !changedNames.includes(pkg.name)).map((pkg) => pkg.name),
-    selected: selected.map((pkg) => pkg.name)
-  };
-}
-function resolveTreeseedWorkflowSession(cwd) {
-  const resolved = resolveTreeseedWorkflowPaths(cwd);
-  const root = workspaceRoot(resolved.cwd);
-  const gitRoot = repoRoot(root);
-  const mode = workflowModeForRoot(root);
-  const packageRepos = checkedOutWorkspacePackageRepos(root).map((pkg) => repoState(root, pkg.name, pkg.dir));
-  const managedRepos = checkedOutManagedWorkflowRepos(root).map((repo) => repoState(root, repo.name, repo.dir, repo.kind));
-  return {
-    root,
-    gitRoot,
-    mode,
-    branchName: currentBranch(gitRoot) || null,
-    branchRole: classifyTreeseedBranchRole(currentBranch(gitRoot) || null, gitRoot),
-    rootRepo: repoState(root, "@treeseed/market", gitRoot, "root"),
-    managedRepos,
-    packageRepos,
-    packageSelection: collectReleasePackageSelection(root)
-  };
-}
-export {
-  checkedOutWorkspacePackageRepos,
-  collectReleasePackageSelection,
-  resolveTreeseedWorkflowSession,
-  workflowModeForRoot
-};

package/dist/workflow/worktrees.d.ts

@@ -1,43 +0,0 @@
-import type { TreeseedWorkflowWorktreeMode } from '../workflow.js';
-export type ManagedWorkflowWorktreeMetadata = {
-    schemaVersion: 1;
-    kind: 'treeseed.workflow.worktree';
-    branch: string;
-    worktreePath: string;
-    primaryRoot: string;
-    ownerMode: 'agent' | 'human' | 'explicit';
-    createdAt: string;
-    lastUsedAt: string;
-};
-export type ManagedWorkflowWorktreeResult = ManagedWorkflowWorktreeMetadata & {
-    created: boolean;
-    resumed: boolean;
-};
-export declare function effectiveWorkflowWorktreeMode(mode: TreeseedWorkflowWorktreeMode | undefined, env?: NodeJS.ProcessEnv | Record<string, string | undefined>): "off" | "on";
-export declare function isManagedWorkflowWorktree(root: string): boolean;
-export declare function managedWorkflowWorktreeMetadata(root: string): ManagedWorkflowWorktreeMetadata | null;
-export declare function plannedManagedWorkflowWorktreePath(root: string, branchName: string): string;
-export declare function primaryWorkspaceRoot(root: string): any;
-export declare function ensureManagedWorkflowWorktree({ root, branchName, mode, env, }: {
-    root: string;
-    branchName: string;
-    mode?: TreeseedWorkflowWorktreeMode;
-    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
-}): ManagedWorkflowWorktreeResult;
-export declare function removeManagedWorkflowWorktree(root: string, options?: {
-    deleteBranch?: boolean;
-}): {
-    removed: boolean;
-    reason: string;
-    worktreePath?: undefined;
-    primaryRoot?: undefined;
-    branch?: undefined;
-    deletedLocalBranch?: undefined;
-} | {
-    removed: boolean;
-    worktreePath: string;
-    primaryRoot: string;
-    branch: string;
-    deletedLocalBranch: boolean;
-    reason?: undefined;
-};

package/dist/workflow/worktrees.js

@@ -1,307 +0,0 @@
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { runTreeseedGit } from "../operations/services/git-runner.js";
-import { sortWorkspacePackages, workspacePackages, workspaceRoot } from "../operations/services/workspace-tools.js";
-import { repoRoot } from "../operations/services/workspace-save.js";
-import { discoverTreeseedPackageAdapters } from "../operations/services/package-adapters.js";
-const WORKTREE_METADATA_PATH = ".treeseed/worktree.json";
-const WORKTREE_ROOT = ".treeseed/worktrees";
-const MACHINE_CONFIG_PATH = ".treeseed/config/machine.yaml";
-function nowIso() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function runGit(args, { cwd, capture = true, allowFailure = false }) {
-  const mutating = /^(add|commit|checkout|switch|merge|tag|push|fetch|worktree|submodule|reset|clean|restore|branch)$/u.test(args[0] ?? "");
-  const result = runTreeseedGit(args, {
-    cwd,
-    mode: mutating ? "mutate" : "read",
-    allowFailure
-  });
-  if (!capture && result.stdout.trim()) process.stdout.write(result.stdout);
-  if (!capture && result.stderr.trim()) process.stderr.write(result.stderr);
-  return result;
-}
-function slugifyBranch(branchName) {
-  return branchName.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "branch";
-}
-function worktreeDirectoryName(branchName) {
-  const hash = createHash("sha256").update(branchName).digest("hex").slice(0, 10);
-  return `${slugifyBranch(branchName)}-${hash}`;
-}
-function parseWorktreeList(output) {
-  const entries = [];
-  let current = null;
-  for (const line of output.split(/\r?\n/u)) {
-    if (line.startsWith("worktree ")) {
-      if (current) entries.push(current);
-      current = { worktree: line.slice("worktree ".length).trim(), branch: null };
-      continue;
-    }
-    if (current && line.startsWith("branch ")) {
-      current.branch = line.slice("branch ".length).trim().replace(/^refs\/heads\//u, "");
-    }
-  }
-  if (current) entries.push(current);
-  return entries;
-}
-function worktreeList(repoDir) {
-  return parseWorktreeList(runGit(["worktree", "list", "--porcelain"], { cwd: repoDir }).stdout ?? "");
-}
-function currentBranchName(repoDir) {
-  return runGit(["branch", "--show-current"], { cwd: repoDir, allowFailure: true }).stdout?.trim() || null;
-}
-function localBranchExists(repoDir, branchName) {
-  return runGit(["show-ref", "--verify", "--quiet", `refs/heads/${branchName}`], { cwd: repoDir, allowFailure: true }).status === 0;
-}
-function remoteBranchExists(repoDir, branchName) {
-  return Boolean(runGit(["ls-remote", "--heads", "origin", branchName], { cwd: repoDir, allowFailure: true }).stdout?.trim());
-}
-function checkoutManagedPackageBranch(repoDir, branchName) {
-  runGit(["fetch", "origin"], { cwd: repoDir, allowFailure: true });
-  const baseBranch = remoteBranchExists(repoDir, "staging") ? "staging" : remoteBranchExists(repoDir, "main") ? "main" : null;
-  if (localBranchExists(repoDir, branchName)) {
-    runGit(["checkout", branchName], { cwd: repoDir });
-  } else if (remoteBranchExists(repoDir, branchName)) {
-    runGit(["checkout", "-b", branchName, `origin/${branchName}`], { cwd: repoDir });
-  } else if (baseBranch) {
-    runGit(["checkout", "-b", branchName, `origin/${baseBranch}`], { cwd: repoDir });
-  } else {
-    return;
-  }
-  if (remoteBranchExists(repoDir, branchName)) {
-    runGit(["merge", "--ff-only", `origin/${branchName}`], { cwd: repoDir, allowFailure: true });
-  }
-}
-function checkoutManagedPackageBranches(worktreePath, branchName) {
-  const packages = /* @__PURE__ */ new Map();
-  for (const pkg of workspacePackages(worktreePath)) {
-    if (pkg.name?.startsWith("@treeseed/")) {
-      packages.set(pkg.name, pkg);
-    }
-  }
-  for (const adapter of discoverTreeseedPackageAdapters(worktreePath)) {
-    if (!adapter.publishTarget && adapter.artifacts.length === 0) continue;
-    if (packages.has(adapter.id)) continue;
-    packages.set(adapter.id, {
-      dir: adapter.dir,
-      name: adapter.id,
-      packageJson: {},
-      relativeDir: adapter.relativeDir
-    });
-  }
-  for (const pkg of sortWorkspacePackages([...packages.values()])) {
-    if (!existsSync(resolve(pkg.dir, ".git"))) continue;
-    checkoutManagedPackageBranch(pkg.dir, branchName);
-  }
-}
-function metadataPath(root) {
-  return resolve(root, WORKTREE_METADATA_PATH);
-}
-function readMetadata(root) {
-  const filePath = metadataPath(root);
-  if (!existsSync(filePath)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
-    return parsed?.kind === "treeseed.workflow.worktree" ? parsed : null;
-  } catch {
-    return null;
-  }
-}
-function writeMetadata(root, metadata) {
-  const filePath = metadataPath(root);
-  mkdirSync(dirname(filePath), { recursive: true });
-  writeFileSync(filePath, `${JSON.stringify(metadata, null, 2)}
-`, "utf8");
-}
-function ensureManagedWorktreeExclude(root) {
-  const commonGitDir = runGit(["rev-parse", "--git-common-dir"], { cwd: root }).stdout?.trim();
-  if (!commonGitDir) return;
-  const absolutePath = resolve(root, commonGitDir, "info", "exclude");
-  const current = existsSync(absolutePath) ? readFileSync(absolutePath, "utf8") : "";
-  const patterns = ["/.treeseed/worktree.json", "/.treeseed/config/", "/.treeseed/workflow/", "/.treeseed/worktrees/"];
-  const missing = patterns.filter((pattern) => !current.includes(pattern));
-  if (missing.length === 0) return;
-  mkdirSync(dirname(absolutePath), { recursive: true });
-  writeFileSync(
-    absolutePath,
-    `${current}${current.endsWith("\n") || current.length === 0 ? "" : "\n"}${missing.join("\n")}
-`,
-    "utf8"
-  );
-}
-function ensureManagedWorktreeMachineConfig(primaryRoot, worktreePath) {
-  const sourcePath = resolve(primaryRoot, MACHINE_CONFIG_PATH);
-  const targetPath = resolve(worktreePath, MACHINE_CONFIG_PATH);
-  if (!existsSync(sourcePath) || existsSync(targetPath)) return;
-  mkdirSync(dirname(targetPath), { recursive: true });
-  copyFileSync(sourcePath, targetPath);
-}
-function effectiveWorkflowWorktreeMode(mode, env = process.env) {
-  const envMode = String(env.TREESEED_WORKTREE_MODE ?? "").trim().toLowerCase();
-  if (mode === "on" || envMode === "on" || envMode === "true" || envMode === "1") return "on";
-  if (mode === "off" || envMode === "off" || envMode === "false" || envMode === "0") return "off";
-  const agentMarkers = [
-    env.TREESEED_WORKFLOW_ACTOR === "agent",
-    env.TREESEED_AGENT_ID,
-    env.TREESEED_AGENT_RUN_ID,
-    env.CODEX_AGENT_ID,
-    env.CODEX_TASK_ID
-  ].some(Boolean);
-  return agentMarkers ? "on" : "off";
-}
-function isManagedWorkflowWorktree(root) {
-  return readMetadata(root) != null;
-}
-function managedWorkflowWorktreeMetadata(root) {
-  return readMetadata(root);
-}
-function plannedManagedWorkflowWorktreePath(root, branchName) {
-  const primaryRoot = primaryWorkspaceRoot(root);
-  return resolve(primaryRoot, WORKTREE_ROOT, worktreeDirectoryName(branchName));
-}
-function primaryWorkspaceRoot(root) {
-  const gitRoot = repoRoot(workspaceRoot(root));
-  const entries = worktreeList(gitRoot);
-  const first = entries[0]?.worktree;
-  return first ? workspaceRoot(first) : workspaceRoot(root);
-}
-function ensureManagedWorkflowWorktree({
-  root,
-  branchName,
-  mode = "auto",
-  env = process.env
-}) {
-  const effectiveMode = effectiveWorkflowWorktreeMode(mode, env);
-  if (effectiveMode !== "on") {
-    throw new Error("Managed workflow worktree mode is disabled.");
-  }
-  const primaryRoot = primaryWorkspaceRoot(root);
-  const primaryGitRoot = repoRoot(primaryRoot);
-  const worktreePath = plannedManagedWorkflowWorktreePath(primaryRoot, branchName);
-  const entries = worktreeList(primaryGitRoot);
-  const existingEntry = entries.find((entry) => entry.worktree === worktreePath);
-  const duplicate = entries.find((entry) => entry.branch === branchName && entry.worktree !== worktreePath);
-  if (duplicate) {
-    throw new Error(`Branch ${branchName} is already checked out in ${duplicate.worktree}.`);
-  }
-  const created = !existingEntry && !existsSync(worktreePath);
-  runGit(["fetch", "origin"], { cwd: primaryGitRoot });
-  const branchExists = remoteBranchExists(primaryGitRoot, branchName);
-  const baseRef = branchExists ? `origin/${branchName}` : "origin/staging";
-  if (created) {
-    mkdirSync(dirname(worktreePath), { recursive: true });
-    runGit(["worktree", "add", "--detach", worktreePath, baseRef], { cwd: primaryGitRoot });
-  } else if (!existingEntry) {
-    runGit(["worktree", "prune"], { cwd: primaryGitRoot, allowFailure: true });
-    if (existsSync(worktreePath)) {
-      throw new Error(`Managed worktree path ${worktreePath} exists but is not registered as a Git worktree.`);
-    }
-  } else if (!currentBranchName(worktreePath)) {
-    runGit(["fetch", "origin"], { cwd: worktreePath, allowFailure: true });
-    runGit(["reset", "--hard", baseRef], { cwd: worktreePath });
-  }
-  runGit(["submodule", "update", "--init", "--recursive"], { cwd: worktreePath });
-  checkoutManagedPackageBranches(worktreePath, branchName);
-  ensureManagedWorktreeMachineConfig(primaryRoot, worktreePath);
-  ensureManagedWorktreeExclude(worktreePath);
-  const timestamp = nowIso();
-  const previous = readMetadata(worktreePath);
-  const metadata = {
-    schemaVersion: 1,
-    kind: "treeseed.workflow.worktree",
-    branch: branchName,
-    worktreePath,
-    primaryRoot,
-    ownerMode: mode === "on" ? "explicit" : "agent",
-    createdAt: previous?.createdAt ?? timestamp,
-    lastUsedAt: timestamp
-  };
-  writeMetadata(worktreePath, metadata);
-  return {
-    ...metadata,
-    created,
-    resumed: !created
-  };
-}
-function removeManagedWorkflowWorktree(root, options = {}) {
-  const metadata = readMetadata(root);
-  if (!metadata) {
-    return { removed: false, reason: "not-managed" };
-  }
-  const primaryRoot = metadata.primaryRoot;
-  const primaryGitRoot = repoRoot(primaryRoot);
-  process.chdir(primaryRoot);
-  const gitRemove = runGit(["worktree", "remove", "--force", metadata.worktreePath], { cwd: primaryGitRoot, allowFailure: true });
-  removeWorkflowWorktreeDirectory(metadata.worktreePath);
-  if (gitRemove.status !== 0) {
-    runGit(["worktree", "prune"], { cwd: primaryGitRoot, allowFailure: true });
-  }
-  let deletedLocalBranch = false;
-  if (options.deleteBranch === true && metadata.branch) {
-    const deleted = runGit(["branch", "-D", metadata.branch], { cwd: primaryGitRoot, allowFailure: true });
-    deletedLocalBranch = deleted.status === 0;
-  }
-  return {
-    removed: true,
-    worktreePath: metadata.worktreePath,
-    primaryRoot,
-    branch: metadata.branch,
-    deletedLocalBranch
-  };
-}
-function removeWorkflowWorktreeDirectory(worktreePath) {
-  try {
-    rmSync(worktreePath, { recursive: true, force: true });
-    return;
-  } catch (error) {
-    const repair = repairDockerOwnedWorktreeArtifacts(worktreePath);
-    if (!repair.repaired) {
-      throw error;
-    }
-    try {
-      rmSync(worktreePath, { recursive: true, force: true });
-      return;
-    } catch (retryError) {
-      const detail = repair.stderr ? ` Docker ownership repair stderr: ${repair.stderr}` : "";
-      const message = retryError instanceof Error ? retryError.message : String(retryError);
-      throw new Error(`${message}.${detail}`);
-    }
-  }
-}
-function repairDockerOwnedWorktreeArtifacts(worktreePath) {
-  if (!existsSync(worktreePath) || typeof process.getuid !== "function" || typeof process.getgid !== "function") {
-    return { repaired: false, stderr: "" };
-  }
-  const uid = String(process.getuid());
-  const gid = String(process.getgid());
-  const result = spawnSync("docker", [
-    "run",
-    "--rm",
-    "-v",
-    `${worktreePath}:/target`,
-    "debian:bookworm-slim",
-    "chown",
-    "-R",
-    `${uid}:${gid}`,
-    "/target"
-  ], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 3e5
-  });
-  return {
-    repaired: result.status === 0,
-    stderr: String(result.stderr ?? "").trim()
-  };
-}
-export {
-  effectiveWorkflowWorktreeMode,
-  ensureManagedWorkflowWorktree,
-  isManagedWorkflowWorktree,
-  managedWorkflowWorktreeMetadata,
-  plannedManagedWorkflowWorktreePath,
-  primaryWorkspaceRoot,
-  removeManagedWorkflowWorktree
-};