@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/operations/services/deployment-readiness.d.ts

@@ -1,30 +0,0 @@
-import { type TreeseedHostingEnvironment } from '../../hosting/index.js';
-export type TreeseedDeploymentReadinessStatus = 'passed' | 'failed' | 'warning' | 'skipped';
-export interface TreeseedDeploymentReadinessCheck {
-    id: string;
-    status: TreeseedDeploymentReadinessStatus;
-    expected?: Record<string, unknown>;
-    observed?: Record<string, unknown>;
-    message: string;
-    remediation?: string;
-}
-export interface TreeseedDeploymentReadinessReport {
-    environment: TreeseedHostingEnvironment;
-    ok: boolean;
-    generatedAt: string;
-    checks: TreeseedDeploymentReadinessCheck[];
-    summary: {
-        passed: number;
-        failed: number;
-        warning: number;
-        skipped: number;
-    };
-}
-export interface TreeseedDeploymentReadinessOptions {
-    tenantRoot: string;
-    environment: TreeseedHostingEnvironment;
-    appId?: string;
-    now?: Date;
-}
-export declare function collectTreeseedDeploymentReadiness(options: TreeseedDeploymentReadinessOptions): TreeseedDeploymentReadinessReport;
-export declare function formatTreeseedReadinessReport(report: TreeseedDeploymentReadinessReport): string;

package/dist/operations/services/deployment-readiness.js

@@ -1,217 +0,0 @@
-import { relative, resolve } from "node:path";
-import { compileTreeseedHostingGraph, serializeHostingUnit } from "../../hosting/index.js";
-import { discoverTreeseedPackageAdapters } from "./package-adapters.js";
-import { configuredRailwayServices } from "./railway-deploy.js";
-import { railwayEnvironmentQualifiedServiceName } from "./railway-source-policy.js";
-function relRoot(tenantRoot, path) {
-  const value = relative(tenantRoot, path).split("\\").join("/");
-  return value || ".";
-}
-function summary(checks) {
-  return {
-    passed: checks.filter((check2) => check2.status === "passed").length,
-    failed: checks.filter((check2) => check2.status === "failed").length,
-    warning: checks.filter((check2) => check2.status === "warning").length,
-    skipped: checks.filter((check2) => check2.status === "skipped").length
-  };
-}
-function check(id, actual, expected, message, remediation, key = id.split(":").at(-1) ?? "value") {
-  const passed = actual === expected;
-  return {
-    id,
-    status: passed ? "passed" : "failed",
-    expected: { [key]: expected },
-    observed: { [key]: actual ?? null },
-    message: passed ? message : `${message} Expected ${String(expected)}, observed ${String(actual ?? "(unset)")}.`,
-    remediation: passed ? void 0 : remediation
-  };
-}
-function checkIncludes(id, values, required, message, remediation) {
-  const observed = Array.isArray(values) ? values.map(String) : [];
-  const missing = required.filter((value) => !observed.includes(value));
-  return {
-    id,
-    status: missing.length === 0 ? "passed" : "failed",
-    expected: { includes: required },
-    observed: { values: observed },
-    message: missing.length === 0 ? message : `${message} Missing: ${missing.join(", ")}.`,
-    remediation: missing.length === 0 ? void 0 : remediation
-  };
-}
-function unitById(units, id) {
-  return units.find((unit) => unit.id === id) ?? null;
-}
-function railwayServiceByKey(services, key) {
-  return services.find((service) => service.key === key) ?? null;
-}
-function recordValue(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
-}
-function hasLocalDevService(adapter, serviceId) {
-  const localDev = recordValue(adapter.metadata.localDev);
-  const services = recordValue(localDev.services);
-  return Object.keys(recordValue(services[serviceId])).length > 0;
-}
-function discoveredApiPackageRoot(tenantRoot) {
-  const adapters = discoverTreeseedPackageAdapters(tenantRoot);
-  const matches = adapters.filter((adapter) => hasLocalDevService(adapter, "api") || hasLocalDevService(adapter, "operationsRunner"));
-  return matches.find((adapter) => adapter.id === "@treeseed/api")?.relativeDir ?? matches.find((adapter) => hasLocalDevService(adapter, "api"))?.relativeDir ?? matches[0]?.relativeDir ?? null;
-}
-function collectTreeseedDeploymentReadiness(options) {
-  const tenantRoot = resolve(options.tenantRoot);
-  const environment = options.environment;
-  const graph = compileTreeseedHostingGraph({ tenantRoot, environment, appId: options.appId });
-  const units = graph.units.map((unit) => serializeHostingUnit(unit));
-  const railwayServices = configuredRailwayServices(tenantRoot, environment).filter((service) => !options.appId || service.application?.id === options.appId);
-  const checks = [];
-  const web = unitById(units, "web");
-  const api = unitById(units, "api");
-  const runner = unitById(units, "operationsRunner");
-  const database = unitById(units, "treeseedDatabase");
-  const hasApiPlane = Boolean(api || runner || database);
-  const hasWorkspaceMarketControlPlane = graph.applications?.some((app) => app.config.hosting?.kind === "treeseed_control_plane") === true || graph.deployConfig.hosting?.kind === "treeseed_control_plane";
-  const railwayApi = railwayServiceByKey(railwayServices, "api");
-  const railwayRunner = railwayServiceByKey(railwayServices, "operationsRunner");
-  if (!web) {
-    if (!hasApiPlane) {
-      checks.push({
-        id: "hosting:web:present",
-        status: "failed",
-        message: "Web hosting unit is missing from the effective hosting graph.",
-        remediation: "Restore surfaces.web in treeseed.site.yaml."
-      });
-    }
-  } else {
-    checks.push(check("hosting:web:host", web.hostId, environment === "local" ? "local-process" : "cloudflare", "Web host matches the expected environment host.", "Set surfaces.web.provider to cloudflare for hosted environments.", "hostId"));
-    checks.push(check("hosting:web:rootDir", web.config?.rootDir, ".", "Web rootDir is the top-level UI application.", 'Set surfaces.web.rootDir to ".".', "rootDir"));
-    const apiConnection = graph.deployConfig.connections?.api;
-    const configuredBaseUrl = environment === "local" ? apiConnection?.localBaseUrl : apiConnection?.environments?.[environment]?.baseUrl ?? apiConnection?.environments?.[environment]?.domain;
-    checks.push({
-      id: "connection:api",
-      status: hasApiPlane || configuredBaseUrl ? "passed" : "failed",
-      expected: { apiConnection: true },
-      observed: {
-        localApiAppPresent: hasApiPlane,
-        baseUrl: configuredBaseUrl ?? null,
-        proxyPrefix: apiConnection?.proxyPrefix ?? null
-      },
-      message: hasApiPlane || configuredBaseUrl ? "Web app has an API app or configured API connection." : "Web app requires an API connection when no local API app manifest is present.",
-      remediation: hasApiPlane || configuredBaseUrl ? void 0 : "Add connections.api to treeseed.site.yaml or include an API package with treeseed.package.yaml localDev metadata."
-    });
-  }
-  if (!hasApiPlane && !hasWorkspaceMarketControlPlane) {
-    const counts2 = summary(checks);
-    return {
-      environment,
-      ok: counts2.failed === 0,
-      generatedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
-      checks,
-      summary: counts2
-    };
-  }
-  const apiIsNestedApp = Boolean(api?.application?.relativeRoot && api.application.relativeRoot !== ".");
-  const runnerIsNestedApp = Boolean(runner?.application?.relativeRoot && runner.application.relativeRoot !== ".");
-  const apiPackageRoot = discoveredApiPackageRoot(tenantRoot) ?? "packages/api";
-  const expectedApiUnitRoot = apiIsNestedApp ? "." : apiPackageRoot;
-  const expectedRunnerUnitRoot = runnerIsNestedApp ? "." : apiPackageRoot;
-  const expectedApiRailwayRoot = api?.application?.relativeRoot && api.application.relativeRoot !== "." ? api.application.relativeRoot : expectedApiUnitRoot;
-  const expectedRunnerRailwayRoot = runner?.application?.relativeRoot && runner.application.relativeRoot !== "." ? runner.application.relativeRoot : expectedRunnerUnitRoot;
-  if (!api) {
-    checks.push({
-      id: "hosting:api:present",
-      status: "failed",
-      message: "API hosting unit is missing from the effective hosting graph.",
-      remediation: "Restore services.api in treeseed.site.yaml."
-    });
-  } else {
-    checks.push(check("hosting:api:host", api.hostId, environment === "local" ? "local-process" : "railway", "API host matches the expected environment host.", "Set services.api.provider to railway for hosted environments.", "hostId"));
-    checks.push(check("hosting:api:projectGroup", api.projectGroupId, "treeseed-control-plane", "API project group targets the Treeseed control plane.", "Bind services.api to the treeseed-control-plane project group.", "projectGroupId"));
-    checks.push(check("hosting:api:rootDir", api.config?.rootDir, expectedApiUnitRoot, "API effective rootDir points at the API package.", "Set services.api.rootDir and services.api.railway.rootDir relative to the owning API manifest.", "rootDir"));
-    if (environment === "local") {
-      if (api.config?.dockerfilePath) {
-        checks.push(check("hosting:api:dockerfilePath", api.config.dockerfilePath, "/Dockerfile.api", "API local deploy uses the same Dockerfile build contract as staging.", "Set services.api.railway.dockerfilePath to /Dockerfile.api.", "dockerfilePath"));
-      } else {
-        checks.push(check("hosting:api:buildCommand", api.config?.buildCommand, "npm run build", "API build command is package-local.", 'Set services.api.railway.buildCommand to "npm run build".', "buildCommand"));
-      }
-      checks.push(check("hosting:api:startCommand", api.config?.startCommand, "npm run start:api", "API start command is package-local.", 'Set services.api.railway.startCommand to "npm run start:api".', "startCommand"));
-    } else if (environment === "staging") {
-      checks.push(check("hosting:api:sourceMode", api.config?.sourceMode, "git", "API staging deploy uses Railway Git source builds.", "Set services.api.railway.sourceMode to git.", "sourceMode"));
-      checks.push(check("hosting:api:sourceRepo", Boolean(api.config?.sourceRepo), true, "API staging source repository is resolved.", "Set services.api.railway.sourceRepo or package repository metadata.", "sourceRepo"));
-      checks.push(check("hosting:api:dockerfilePath", api.config?.dockerfilePath, "/Dockerfile.api", "API staging deploy uses a Dockerfile build.", "Set services.api.railway.dockerfilePath to /Dockerfile.api.", "dockerfilePath"));
-    } else {
-      checks.push(check("hosting:api:imageRefEnv", api.config?.imageRefEnv, "TREESEED_API_IMAGE_REF", "API Railway deploy uses a Docker image reference.", "Set services.api.railway.imageRef or inject TREESEED_API_IMAGE_REF.", "imageRefEnv"));
-    }
-    checks.push(check("hosting:api:healthcheckPath", api.config?.healthcheckPath, "/healthz", "API healthcheck path is /healthz.", "Set services.api.railway.healthcheckPath to /healthz.", "healthcheckPath"));
-  }
-  if (railwayApi) {
-    const expectedServiceName = railwayEnvironmentQualifiedServiceName("treeseed-api", environment);
-    checks.push(check("railway-config:api:serviceName", railwayApi.serviceName, expectedServiceName, "Railway API service uses its environment-qualified identity.", `Set services.api.environments.${environment}.serviceName to ${expectedServiceName}.`, "serviceName"));
-    checks.push(check("railway-config:api:rootDirectory", relRoot(tenantRoot, railwayApi.rootDir), expectedApiRailwayRoot, "Railway API effective rootDirectory points at the API app.", "Set services.api.railway.rootDir relative to the owning API manifest.", "rootDirectory"));
-  }
-  if (!runner) {
-    checks.push({
-      id: "hosting:operationsRunner:present",
-      status: "failed",
-      message: "Treeseed operations runner hosting unit is missing from the effective hosting graph.",
-      remediation: "Restore services.operationsRunner in treeseed.site.yaml."
-    });
-  } else {
-    checks.push(check("hosting:operationsRunner:host", runner.hostId, environment === "local" ? "local-docker" : "railway", "Runner host matches the expected environment host.", "Set services.operationsRunner.provider to railway for hosted environments.", "hostId"));
-    checks.push(check("hosting:operationsRunner:projectGroup", runner.projectGroupId, "treeseed-control-plane", "Runner project group targets the Treeseed control plane.", "Bind services.operationsRunner to the treeseed-control-plane project group.", "projectGroupId"));
-    checks.push(check("hosting:operationsRunner:rootDir", runner.config?.rootDir, expectedRunnerUnitRoot, "Runner effective rootDir points at the API package.", "Set services.operationsRunner.rootDir and services.operationsRunner.railway.rootDir relative to the owning API manifest.", "rootDir"));
-    if (environment === "local") {
-      if (runner.config?.dockerfilePath) {
-        checks.push(check("hosting:operationsRunner:dockerfilePath", runner.config.dockerfilePath, "/Dockerfile.operations-runner", "Runner local deploy uses the same Dockerfile build contract as staging.", "Set services.operationsRunner.railway.dockerfilePath to /Dockerfile.operations-runner.", "dockerfilePath"));
-      } else {
-        checks.push(check("hosting:operationsRunner:buildCommand", runner.config?.buildCommand, "npm run build", "Runner build command is package-local.", 'Set services.operationsRunner.railway.buildCommand to "npm run build".', "buildCommand"));
-      }
-      checks.push(check("hosting:operationsRunner:startCommand", runner.config?.startCommand, "npm run start:runner", "Runner start command is package-local.", 'Set services.operationsRunner.railway.startCommand to "npm run start:runner".', "startCommand"));
-    } else if (environment === "staging") {
-      checks.push(check("hosting:operationsRunner:sourceMode", runner.config?.sourceMode, "git", "Runner staging deploy uses Railway Git source builds.", "Set services.operationsRunner.railway.sourceMode to git.", "sourceMode"));
-      checks.push(check("hosting:operationsRunner:sourceRepo", Boolean(runner.config?.sourceRepo), true, "Runner staging source repository is resolved.", "Set services.operationsRunner.railway.sourceRepo or package repository metadata.", "sourceRepo"));
-      checks.push(check("hosting:operationsRunner:dockerfilePath", runner.config?.dockerfilePath, "/Dockerfile.operations-runner", "Runner staging deploy uses a Dockerfile build.", "Set services.operationsRunner.railway.dockerfilePath to /Dockerfile.operations-runner.", "dockerfilePath"));
-    } else {
-      checks.push(check("hosting:operationsRunner:imageRefEnv", runner.config?.imageRefEnv, "TREESEED_OPERATIONS_RUNNER_IMAGE_REF", "Runner Railway deploy uses a Docker image reference.", "Set services.operationsRunner.railway.imageRef or inject TREESEED_OPERATIONS_RUNNER_IMAGE_REF.", "imageRefEnv"));
-    }
-    checks.push(check("hosting:operationsRunner:healthcheckPath", runner.config?.healthcheckPath, "/healthz", "Runner healthcheck path is /healthz.", "Set services.operationsRunner.railway.healthcheckPath to /healthz.", "healthcheckPath"));
-    checks.push(check("hosting:operationsRunner:runtimeMode", runner.config?.runtimeMode, "service", "Runner runtime mode is a long-running service.", "Set services.operationsRunner.railway.runtimeMode to service.", "runtimeMode"));
-    checks.push(check("hosting:operationsRunner:volumeMountPath", runner.config?.volumeMountPath, "/data", "Runner volume mount path is stable.", "Set services.operationsRunner.railway.volumeMountPath to /data.", "volumeMountPath"));
-  }
-  if (railwayRunner) {
-    const expectedServiceName = railwayEnvironmentQualifiedServiceName("treeseed-ops-01", environment);
-    checks.push(check("railway-config:operationsRunner:serviceName", railwayRunner.serviceName, expectedServiceName, "Railway runner uses its environment-qualified identity.", `Set services.operationsRunner.environments.${environment}.serviceName to ${expectedServiceName}.`, "serviceName"));
-    checks.push(check("railway-config:operationsRunner:rootDirectory", relRoot(tenantRoot, railwayRunner.rootDir), expectedRunnerRailwayRoot, "Railway runner effective rootDirectory points at the API app.", "Set services.operationsRunner.railway.rootDir relative to the owning API manifest.", "rootDirectory"));
-  }
-  if (!database) {
-    checks.push({
-      id: "hosting:treeseedDatabase:present",
-      status: "failed",
-      message: "Treeseed database hosting unit is missing from the effective hosting graph.",
-      remediation: "Restore services.treeseedDatabase in treeseed.site.yaml."
-    });
-  } else {
-    checks.push(checkIncludes("hosting:treeseedDatabase:serviceTargets", database.config?.serviceTargets, ["api", "operationsRunner"], "Treeseed database targets API and runner services.", "Set services.treeseedDatabase.railway.serviceTargets to include api and operationsRunner."));
-  }
-  const counts = summary(checks);
-  return {
-    environment,
-    ok: counts.failed === 0,
-    generatedAt: (options.now ?? /* @__PURE__ */ new Date()).toISOString(),
-    checks,
-    summary: counts
-  };
-}
-function formatTreeseedReadinessReport(report) {
-  const lines = [
-    `Deployment readiness for ${report.environment}: ${report.ok ? "passed" : "failed"}`,
-    `passed=${report.summary.passed} failed=${report.summary.failed} warning=${report.summary.warning} skipped=${report.summary.skipped}`
-  ];
-  for (const check2 of report.checks.filter((entry) => entry.status !== "passed")) {
-    lines.push(`${check2.status.toUpperCase()} ${check2.id}: ${check2.message}${check2.remediation ? ` Remediation: ${check2.remediation}` : ""}`);
-  }
-  return lines.join("\n");
-}
-export {
-  collectTreeseedDeploymentReadiness,
-  formatTreeseedReadinessReport
-};

package/dist/operations/services/export-runtime.d.ts

@@ -1,18 +0,0 @@
-export type TreeseedExportResult = {
-    directory: string;
-    tenantRoot: string;
-    outputPath: string;
-    branch: string;
-    timestamp: string;
-    includedBundlePaths: string[];
-    ignorePatterns: string[];
-    summary: {
-        totalFiles: number;
-        totalCharacters: number;
-        totalTokens: number;
-        outputFiles: string[];
-    };
-};
-export declare function exportTreeseedCodebase({ directory, }?: {
-    directory?: string;
-}): Promise<TreeseedExportResult>;

package/dist/operations/services/export-runtime.js

@@ -1,140 +0,0 @@
-import { existsSync, mkdirSync, statSync } from "node:fs";
-import { resolve, relative } from "node:path";
-import { runDefaultAction, setLogLevel } from "repomix";
-import { loadTreeseedDeployConfigFromPath, resolveTreeseedDeployConfigPathFromRoot } from "../../platform/deploy-config.js";
-import { findNearestTreeseedRoot } from "./workspace-tools.js";
-import { currentBranch, repoRoot } from "./workspace-save.js";
-function ensureDirectory(directory) {
-  if (!existsSync(directory)) {
-    throw new Error(`Treeseed export directory does not exist: ${directory}`);
-  }
-  const stats = statSync(directory);
-  if (!stats.isDirectory()) {
-    throw new Error(`Treeseed export directory must be a directory: ${directory}`);
-  }
-}
-function formatExportTimestamp(date = /* @__PURE__ */ new Date()) {
-  const year = date.getFullYear();
-  const month = `${date.getMonth() + 1}`.padStart(2, "0");
-  const day = `${date.getDate()}`.padStart(2, "0");
-  const hours = `${date.getHours()}`.padStart(2, "0");
-  const minutes = `${date.getMinutes()}`.padStart(2, "0");
-  const seconds = `${date.getSeconds()}`.padStart(2, "0");
-  return `${year}-${month}-${day}-${hours}-${minutes}-${seconds}`;
-}
-function sanitizeBranchSegment(branch) {
-  const sanitized = String(branch ?? "").trim().replaceAll(/[\\/]+/g, "-").replaceAll(/[^a-zA-Z0-9._-]+/g, "-").replaceAll(/-+/g, "-").replaceAll(/^-|-$/g, "");
-  return sanitized || "detached";
-}
-function resolveGitBranch(directory) {
-  try {
-    const gitRoot = repoRoot(directory);
-    const branch = currentBranch(gitRoot);
-    return sanitizeBranchSegment(branch);
-  } catch {
-    return "detached";
-  }
-}
-function resolveExportOutputPath(directory, branch, timestamp) {
-  const exportsRoot = resolve(directory, ".treeseed", "exports");
-  mkdirSync(exportsRoot, { recursive: true });
-  return resolve(exportsRoot, `${branch}-${timestamp}.md`);
-}
-function resolveConfiguredBundlePaths(directory, tenantRoot, config) {
-  const includedBundlePaths = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const configuredPath of config.export?.bundledPaths ?? []) {
-    const absolutePath = resolve(tenantRoot, configuredPath);
-    if (!existsSync(absolutePath)) {
-      continue;
-    }
-    const relativeToDirectory = relative(directory, absolutePath);
-    if (!relativeToDirectory || !relativeToDirectory.startsWith("..") && relativeToDirectory !== ".") {
-      continue;
-    }
-    if (seen.has(absolutePath)) {
-      continue;
-    }
-    seen.add(absolutePath);
-    includedBundlePaths.push(absolutePath);
-  }
-  return includedBundlePaths.sort((left, right) => left.localeCompare(right));
-}
-function resolveIgnorePatterns(config) {
-  return [
-    ".treeseed/exports",
-    ".treeseed/exports/**",
-    "**/.treeseed/exports",
-    "**/.treeseed/exports/**",
-    ".treeseed/worktrees",
-    ".treeseed/worktrees/**",
-    "**/.treeseed/worktrees",
-    "**/.treeseed/worktrees/**",
-    ...config.export?.ignore ?? []
-  ];
-}
-function toRepomixDirectories(directory, includedBundlePaths) {
-  return [".", ...includedBundlePaths.map((bundlePath) => relative(directory, bundlePath) || ".")];
-}
-function normalizePackResultOutputFiles(packResult, outputPath) {
-  return packResult.outputFiles && packResult.outputFiles.length > 0 ? packResult.outputFiles : [outputPath];
-}
-async function withCleanNodeExecArgv(action) {
-  const previousExecArgv = [...process.execArgv];
-  process.execArgv = previousExecArgv.filter(
-    (arg) => !arg.startsWith("--test") && !arg.startsWith("--input-type") && !arg.startsWith("--experimental-test") && !arg.startsWith("--watch")
-  );
-  try {
-    return await action();
-  } finally {
-    process.execArgv = previousExecArgv;
-  }
-}
-async function exportTreeseedCodebase({
-  directory = process.cwd()
-} = {}) {
-  const resolvedDirectory = resolve(directory);
-  ensureDirectory(resolvedDirectory);
-  const tenantRoot = findNearestTreeseedRoot(resolvedDirectory);
-  if (!tenantRoot) {
-    throw new Error(`Treeseed export requires a Treeseed project. No ancestor containing treeseed.site.yaml was found from ${resolvedDirectory}.`);
-  }
-  const deployConfig = loadTreeseedDeployConfigFromPath(resolveTreeseedDeployConfigPathFromRoot(tenantRoot));
-  const includedBundlePaths = resolveConfiguredBundlePaths(resolvedDirectory, tenantRoot, deployConfig);
-  const ignorePatterns = resolveIgnorePatterns(deployConfig);
-  const branch = resolveGitBranch(resolvedDirectory);
-  const timestamp = formatExportTimestamp();
-  const outputPath = resolveExportOutputPath(resolvedDirectory, branch, timestamp);
-  const options = {
-    output: outputPath,
-    style: "markdown",
-    ignore: ignorePatterns.join(","),
-    quiet: true,
-    skipLocalConfig: true,
-    copy: false,
-    stdout: false
-  };
-  setLogLevel(0);
-  const result = await withCleanNodeExecArgv(
-    () => runDefaultAction(toRepomixDirectories(resolvedDirectory, includedBundlePaths), resolvedDirectory, options)
-  );
-  const outputFiles = normalizePackResultOutputFiles(result.packResult, outputPath);
-  return {
-    directory: resolvedDirectory,
-    tenantRoot,
-    outputPath,
-    branch,
-    timestamp,
-    includedBundlePaths,
-    ignorePatterns,
-    summary: {
-      totalFiles: result.packResult.totalFiles,
-      totalCharacters: result.packResult.totalCharacters,
-      totalTokens: result.packResult.totalTokens,
-      outputFiles
-    }
-  };
-}
-export {
-  exportTreeseedCodebase
-};

package/dist/operations/services/git-remote-policy.d.ts

@@ -1,9 +0,0 @@
-export type GitRemoteWriteMode = 'ssh-pushurl' | 'off';
-export declare function sshPushUrlForRemote(remoteUrl: string | null | undefined): string | null;
-export declare function configuredPushUrl(repoDir: string, remoteName?: string): string | null;
-export declare function remoteWriteUrl(repoDir: string, remoteName?: string): string | null;
-export declare function ensureSshPushUrlForOrigin(repoDir: string, remoteUrl: string | null | undefined, mode?: GitRemoteWriteMode): {
-    changed: boolean;
-    pushUrl: string | null;
-    reason: string;
-};

package/dist/operations/services/git-remote-policy.js

@@ -1,63 +0,0 @@
-import { classifyTreeseedGitMode, runTreeseedGitText } from "./git-runner.js";
-function runGit(args, options) {
-  return runTreeseedGitText(args, {
-    cwd: options.cwd,
-    mode: classifyTreeseedGitMode(args),
-    timeoutMs: options.timeoutMs,
-    maxBuffer: options.maxBuffer
-  });
-}
-function normalizeRemote(remoteUrl) {
-  return String(remoteUrl ?? "").trim();
-}
-function sshPushUrlForRemote(remoteUrl) {
-  const remote = normalizeRemote(remoteUrl).replace(/^git\+/u, "");
-  if (!remote || remote.startsWith("/") || remote.startsWith("./") || remote.startsWith("../")) {
-    return null;
-  }
-  if (/^(?:file|ssh):\/\//u.test(remote) || /^git@[^:]+:.+/u.test(remote)) {
-    return null;
-  }
-  const httpsMatch = remote.match(/^https:\/\/([^/]+)\/(.+?)(?:\.git)?$/u);
-  if (!httpsMatch) {
-    return null;
-  }
-  return `git@${httpsMatch[1]}:${httpsMatch[2]}.git`;
-}
-function configuredPushUrl(repoDir, remoteName = "origin") {
-  try {
-    return runGit(["config", "--get", `remote.${remoteName}.pushurl`], { cwd: repoDir, capture: true }).trim() || null;
-  } catch {
-    return null;
-  }
-}
-function remoteWriteUrl(repoDir, remoteName = "origin") {
-  const pushUrl = configuredPushUrl(repoDir, remoteName);
-  if (pushUrl) return pushUrl;
-  try {
-    return runGit(["remote", "get-url", remoteName], { cwd: repoDir, capture: true }).trim() || null;
-  } catch {
-    return null;
-  }
-}
-function ensureSshPushUrlForOrigin(repoDir, remoteUrl, mode = "ssh-pushurl") {
-  if (mode === "off") {
-    return { changed: false, pushUrl: configuredPushUrl(repoDir), reason: "disabled" };
-  }
-  const nextPushUrl = sshPushUrlForRemote(remoteUrl);
-  if (!nextPushUrl) {
-    return { changed: false, pushUrl: configuredPushUrl(repoDir), reason: "not-https" };
-  }
-  const currentPushUrl = configuredPushUrl(repoDir);
-  if (currentPushUrl === nextPushUrl) {
-    return { changed: false, pushUrl: currentPushUrl, reason: "already-configured" };
-  }
-  runGit(["remote", "set-url", "--push", "origin", nextPushUrl], { cwd: repoDir });
-  return { changed: true, pushUrl: nextPushUrl, reason: currentPushUrl ? "updated" : "configured" };
-}
-export {
-  configuredPushUrl,
-  ensureSshPushUrlForOrigin,
-  remoteWriteUrl,
-  sshPushUrlForRemote
-};

package/dist/operations/services/git-runner.d.ts

@@ -1,68 +0,0 @@
-export type TreeseedGitRunnerMode = 'read' | 'mutate';
-export type TreeseedGitRunnerResult = {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-};
-export type TreeseedGitLockKind = 'index' | 'ref' | 'packed-refs' | 'head' | 'treeseed-mutation' | 'unknown';
-export type TreeseedGitLockProcessHint = {
-    pid: number;
-    command: string;
-};
-export type TreeseedGitLockDiagnostic = {
-    repoRoot: string;
-    commonGitDir: string | null;
-    lockPath: string | null;
-    relativeLockPath: string | null;
-    kind: TreeseedGitLockKind;
-    exists: boolean;
-    indexLockPath: string | null;
-    indexLockExists: boolean;
-    safeToRepair: boolean;
-    reason: string;
-    removed: boolean;
-    ageMs: number | null;
-    activeGitProcessHints: TreeseedGitLockProcessHint[];
-};
-export type TreeseedGitWorkspaceLockDiagnostics = {
-    root: TreeseedGitLockDiagnostic | TreeseedGitLockDiagnostic[];
-    repositories: Array<TreeseedGitLockDiagnostic | {
-        repoRoot: string;
-        locks: TreeseedGitLockDiagnostic[];
-    }>;
-    summary?: {
-        repositoriesChecked: number;
-        locksPresent: number;
-        safeToRepair: number;
-        unsafe: number;
-        removed: number;
-    };
-};
-type RunOptions = {
-    cwd: string;
-    mode?: TreeseedGitRunnerMode;
-    allowFailure?: boolean;
-    timeoutMs?: number;
-    maxBuffer?: number;
-    env?: NodeJS.ProcessEnv | Record<string, string | undefined>;
-};
-export type TreeseedGitBatchOperation = RunOptions & {
-    args: string[];
-};
-export declare function treeseedGitCommandUsesRemote(args: string[]): boolean;
-export declare function resolveTreeseedGitCommandTimeoutMs(args: string[], timeoutMs?: number): number | undefined;
-export declare function classifyTreeseedGitMode(args: string[]): TreeseedGitRunnerMode;
-export declare function inspectTreeseedGitLocks(cwd: string): TreeseedGitLockDiagnostic;
-export declare function inspectTreeseedGitLockSet(cwd: string): TreeseedGitLockDiagnostic[];
-export declare function inspectTreeseedWorkspaceGitLocks(cwd: string): TreeseedGitWorkspaceLockDiagnostics;
-export declare function recoverTreeseedGitLocks(cwd: string, { execute, all }?: {
-    execute?: boolean;
-    all?: boolean;
-}): TreeseedGitLockDiagnostic | TreeseedGitWorkspaceLockDiagnostics;
-export declare function runTreeseedGit(args: string[], options: RunOptions): TreeseedGitRunnerResult;
-export declare function runTreeseedGitText(args: string[], options: RunOptions): string;
-export declare function runTreeseedGitOk(args: string[], options: Omit<RunOptions, 'allowFailure'>): boolean;
-export declare function runTreeseedGitBatch(operations: TreeseedGitBatchOperation[], _options?: {
-    repoSerialization?: boolean;
-}): Promise<TreeseedGitRunnerResult[]>;
-export {};