@moretea-labs/forge 1.8.1 → 1.8.2

package/src/core/adoption/helper-wrapper-plan.ts

@@ -1,159 +0,0 @@
-import { existsSync, readFileSync } from "fs";
-import { basename, resolve } from "path";
-import type { AdoptionMode } from "./modes";
-import type { WriteFileOperation } from "./operations";
-import { makeOperationId } from "./operations";
-import { loadWorkflowContractAsset, WORKFLOW_CONTRACT_ASSET_PATH } from "./workflow-contract-asset";
-
-const EXECUTABLE_MODE = 0o755;
-
-interface WorkflowContractForHelperWrappers {
-  readonly helpers: {
-    readonly compatibilityDirectory?: string;
-    readonly scripts: readonly string[];
-  };
-}
-
-function repoPinsHelperSource(repoRoot: string): boolean {
-  if (process.env.FORGE_HELPER_SOURCE === "repo") return true;
-  const policyPath = resolve(repoRoot, ".ai/harness/policy.json");
-  if (!existsSync(policyPath)) return false;
-  try {
-    const policy = JSON.parse(readFileSync(policyPath, "utf-8")) as { harness?: { helper_source?: string } };
-    return policy.harness?.helper_source === "repo";
-  } catch {
-    return false;
-  }
-}
-
-function isSelfHostSourceRepo(repoRoot: string): boolean {
-  const targetHelpers = resolve(repoRoot, "assets/templates/helpers");
-  const assetHelpers = resolve(WORKFLOW_CONTRACT_ASSET_PATH, "..", "templates", "helpers");
-  return existsSync(targetHelpers) && targetHelpers === assetHelpers;
-}
-
-function assertHelperName(helperName: string): void {
-  if (helperName !== basename(helperName) || helperName.includes("..") || helperName.startsWith(".")) {
-    throw new Error(`unsafe helper wrapper name: ${helperName}`);
-  }
-}
-
-function helperId(helperName: string): string {
-  return helperName.replace(/\.[^.]+$/, "");
-}
-
-function shellWrapper(helperName: string): string {
-  const id = helperId(helperName);
-  return [
-    "#!/bin/bash",
-    "set -euo pipefail",
-    "",
-    'SOURCE_ROOT="${FORGE_SOURCE_ROOT:-${AGENTIC_DEV_ROOT:-${AGENTIC_DEV_SKILL_ROOT:-}}}"',
-    "",
-    'if [[ -n "$SOURCE_ROOT" && -f "$SOURCE_ROOT/src/cli/index.ts" ]]; then',
-    "  if command -v bun >/dev/null 2>&1; then",
-    `    exec bun "$SOURCE_ROOT/src/cli/index.ts" run ${id} "$@"`,
-    "  fi",
-    "fi",
-    "",
-    "if command -v forge >/dev/null 2>&1; then",
-    `  exec forge run ${id} "$@"`,
-    "fi",
-    "",
-    `echo "Missing forge CLI for helper ${id}" >&2`,
-    "exit 1",
-    "",
-  ].join("\n");
-}
-
-function typescriptWrapper(helperName: string): string {
-  const id = helperId(helperName);
-  return [
-    "#!/usr/bin/env bun",
-    'import { spawnSync } from "node:child_process";',
-    'import { existsSync } from "node:fs";',
-    'import { join } from "node:path";',
-    "",
-    `const helperId = "${id}";`,
-    "const DEFAULT_TIMEOUT_MS = 120_000;",
-    "const configuredTimeoutMs = Number.parseInt(",
-    '  process.env.FORGE_HELPER_TIMEOUT_MS ?? String(DEFAULT_TIMEOUT_MS),',
-    "  10,",
-    ");",
-    "const timeoutMs = Number.isFinite(configuredTimeoutMs) && configuredTimeoutMs > 0",
-    "  ? configuredTimeoutMs",
-    "  : DEFAULT_TIMEOUT_MS;",
-    "",
-    "const sourceRoot =",
-    "  process.env.FORGE_SOURCE_ROOT ||",
-    "  process.env.AGENTIC_DEV_ROOT ||",
-    "  process.env.AGENTIC_DEV_SKILL_ROOT;",
-    'const command = sourceRoot && existsSync(join(sourceRoot, "src", "cli", "index.ts"))',
-    `  ? ["bun", join(sourceRoot, "src", "cli", "index.ts"), "run", "${id}"]`,
-    `  : ["forge", "run", "${id}"];`,
-    "",
-    "const result = spawnSync(command[0], [...command.slice(1), ...process.argv.slice(2)], {",
-    "  cwd: process.cwd(),",
-    "  env: process.env,",
-    '  stdio: "inherit",',
-    "  timeout: timeoutMs,",
-    "});",
-    "",
-    "if (result.error) {",
-    '  const code = "code" in result.error ? String(result.error.code ?? "") : "";',
-    '  const prefix = code === "ETIMEDOUT"',
-    "    ? `forge helper ${helperId} timed out after ${timeoutMs}ms`",
-    "    : `Missing forge CLI for helper ${helperId}`;",
-    "  console.error(`${prefix}: ${result.error.message}`);",
-    "  process.exit(1);",
-    "}",
-    "",
-    "process.exit(result.status ?? 1);",
-    "",
-  ].join("\n");
-}
-
-export function helperWrapperContent(helperName: string): string {
-  assertHelperName(helperName);
-  return helperName.endsWith(".ts") ? typescriptWrapper(helperName) : shellWrapper(helperName);
-}
-
-function helperWrapperStatus(repoRoot: string, path: string): WriteFileOperation["status"] {
-  return existsSync(resolve(repoRoot, path)) ? "skipped" : "planned";
-}
-
-function shouldPlanHelperWrappers(repoRoot: string, mode: AdoptionMode): boolean {
-  return mode === "standard" && !isSelfHostSourceRepo(repoRoot) && !repoPinsHelperSource(repoRoot);
-}
-
-export function helperWrapperGitignoreContent(repoRoot: string, mode: AdoptionMode): string {
-  if (!shouldPlanHelperWrappers(repoRoot, mode)) return "";
-  const contract = loadWorkflowContractAsset<WorkflowContractForHelperWrappers>();
-  const directory = contract.helpers.compatibilityDirectory ?? "scripts";
-  const paths = contract.helpers.scripts.map((helperName) => {
-    assertHelperName(helperName);
-    return `${directory}/${helperName}`;
-  });
-  return ["# forge generated helper wrappers", ...paths, `${directory}/forge/`].join("\n");
-}
-
-export function helperWrapperOperations(repoRoot: string, mode: AdoptionMode): WriteFileOperation[] {
-  if (!shouldPlanHelperWrappers(repoRoot, mode)) return [];
-  const contract = loadWorkflowContractAsset<WorkflowContractForHelperWrappers>();
-  const directory = contract.helpers.compatibilityDirectory ?? "scripts";
-  return contract.helpers.scripts.map((helperName) => {
-    assertHelperName(helperName);
-    const path = `${directory}/${helperName}`;
-    return {
-      id: makeOperationId("writeFile", path, "helper-wrapper"),
-      kind: "writeFile",
-      path,
-      content: helperWrapperContent(helperName),
-      ifMissing: true,
-      mode: EXECUTABLE_MODE,
-      reason: "Install forge helper compatibility wrapper",
-      risk: "low",
-      status: helperWrapperStatus(repoRoot, path),
-    };
-  });
-}

package/src/runtime/context/codegraph-cache-boundary.ts

@@ -1,255 +0,0 @@
-import { randomBytes, createHash } from 'crypto';
-import {
-  cpSync,
-  existsSync,
-  lstatSync,
-  mkdirSync,
-  readdirSync,
-  readlinkSync,
-  rmSync,
-  symlinkSync,
-  utimesSync,
-} from 'fs';
-import { dirname, join, resolve } from 'path';
-import { withControllerLock } from '../../cli/repositories/locks';
-
-export const CODEGRAPH_LEGACY_CACHE_DIR = '.codegraph';
-export const CODEGRAPH_LOCATOR_PREFIX = '.codegraph-forge-';
-const CODEGRAPH_LOCATOR_SCAN_BUDGET = 128;
-
-/** Stable identity for Forge-owned CodeGraph cache placement. */
-export function codegraphCacheIdentity(repoRoot: string): string {
-  return createHash('sha256').update(resolve(repoRoot)).digest('hex').slice(0, 24);
-}
-
-export function codegraphCacheRoot(controllerHome: string): string {
-  return join(resolve(controllerHome), 'tool-cache', 'codegraph');
-}
-
-export function codegraphRepositoryCacheRoot(controllerHome: string, repoRoot: string): string {
-  return join(codegraphCacheRoot(controllerHome), codegraphCacheIdentity(repoRoot));
-}
-
-function absoluteLinkTarget(linkPath: string): string {
-  const target = readlinkSync(linkPath);
-  return resolve(dirname(linkPath), target);
-}
-
-function samePath(left: string, right: string): boolean {
-  return resolve(left) === resolve(right);
-}
-
-function processAlive(pid: number): boolean {
-  if (!Number.isInteger(pid) || pid <= 0) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (error) {
-    return (error as NodeJS.ErrnoException).code === 'EPERM';
-  }
-}
-
-function touchCacheRoot(path: string): void {
-  try {
-    const at = new Date();
-    utimesSync(path, at, at);
-  } catch {
-    // Cache recency is advisory. A failed touch must never make the index an authority.
-  }
-}
-
-/**
- * Explicit migration boundary for the retired repo-local `.codegraph` cache.
- * A legacy Forge compatibility symlink is simply retired. A real directory is
- * copied only when the Controller Home target is empty; conflicting dual cache
- * state fails closed instead of guessing which index is newer.
- */
-export function migrateLegacyCodegraphCache(repoRoot: string, controllerHome: string): string {
-  const canonicalRepo = resolve(repoRoot);
-  const targetRoot = codegraphRepositoryCacheRoot(controllerHome, canonicalRepo);
-  const legacyRoot = join(canonicalRepo, CODEGRAPH_LEGACY_CACHE_DIR);
-  return withControllerLock(
-    controllerHome,
-    { scope: 'global', resource: `codegraph-migration:${codegraphCacheIdentity(canonicalRepo)}` },
-    `codegraph-migration:${codegraphCacheIdentity(canonicalRepo)}`,
-    () => {
-      mkdirSync(targetRoot, { recursive: true });
-      if (!existsSync(legacyRoot)) return targetRoot;
-
-      const stat = lstatSync(legacyRoot);
-      if (stat.isSymbolicLink()) {
-        if (!samePath(absoluteLinkTarget(legacyRoot), targetRoot)) {
-          throw new Error(`CODEGRAPH_CACHE_LINK_MISMATCH: ${legacyRoot} -> ${readlinkSync(legacyRoot)}`);
-        }
-        rmSync(legacyRoot, { force: true });
-        touchCacheRoot(targetRoot);
-        return targetRoot;
-      }
-      if (!stat.isDirectory()) throw new Error(`CODEGRAPH_CACHE_PATH_INVALID: ${legacyRoot}`);
-      if (readdirSync(targetRoot).length > 0) {
-        throw new Error(`CODEGRAPH_CACHE_MIGRATION_CONFLICT: both ${legacyRoot} and ${targetRoot} contain cache state`);
-      }
-      cpSync(legacyRoot, targetRoot, {
-        recursive: true,
-        dereference: false,
-        preserveTimestamps: true,
-        force: false,
-        errorOnExist: true,
-      });
-      rmSync(legacyRoot, { recursive: true, force: true });
-      touchCacheRoot(targetRoot);
-      return targetRoot;
-    },
-  );
-}
-
-export interface CodegraphLocatorCleanupReport {
-  inspected: number;
-  eligible: number;
-  attempted: number;
-  removed: string[];
-  active: string[];
-  skippedByReason: Record<string, number>;
-  errors: string[];
-  budgetExhausted: boolean;
-}
-
-function increment(counts: Record<string, number>, reason: string): void {
-  counts[reason] = (counts[reason] ?? 0) + 1;
-}
-
-/**
- * Remove only dead-process locator symlinks that still point at this repo's
- * exact Forge cache. Live PIDs and unproven paths are preserved fail-closed.
- */
-export function cleanupStaleCodegraphLocators(
-  repoRoot: string,
-  controllerHome: string,
-  maxEntries = CODEGRAPH_LOCATOR_SCAN_BUDGET,
-  maxRemovals = 16,
-): CodegraphLocatorCleanupReport {
-  const canonicalRepo = resolve(repoRoot);
-  const targetRoot = codegraphRepositoryCacheRoot(controllerHome, canonicalRepo);
-  const removalLimit = Math.max(0, Math.floor(maxRemovals));
-  const report: CodegraphLocatorCleanupReport = {
-    inspected: 0,
-    eligible: 0,
-    attempted: 0,
-    removed: [],
-    active: [],
-    skippedByReason: {},
-    errors: [],
-    budgetExhausted: false,
-  };
-  let entries;
-  try {
-    entries = readdirSync(canonicalRepo, { withFileTypes: true })
-      .filter((entry) => String(entry.name).startsWith(CODEGRAPH_LOCATOR_PREFIX));
-  } catch (error) {
-    report.errors.push(error instanceof Error ? error.message : String(error));
-    return report;
-  }
-  if (entries.length > maxEntries) report.budgetExhausted = true;
-  for (const entry of entries.slice(0, Math.max(1, maxEntries))) {
-    report.inspected += 1;
-    const name = String(entry.name);
-    const path = join(canonicalRepo, name);
-    try {
-      const stat = lstatSync(path);
-      if (!stat.isSymbolicLink()) {
-        increment(report.skippedByReason, 'locator_not_symlink');
-        continue;
-      }
-      if (!samePath(absoluteLinkTarget(path), targetRoot)) {
-        increment(report.skippedByReason, 'locator_target_unproven');
-        continue;
-      }
-      const match = /^\.codegraph-forge-(\d+)-[a-f0-9]+$/.exec(name);
-      if (!match) {
-        increment(report.skippedByReason, 'locator_identity_unproven');
-        continue;
-      }
-      const pid = Number(match[1]);
-      if (processAlive(pid)) {
-        report.active.push(name);
-        increment(report.skippedByReason, 'active_locator');
-        continue;
-      }
-      report.eligible += 1;
-      if (report.attempted >= removalLimit) {
-        report.budgetExhausted = true;
-        increment(report.skippedByReason, 'cleanup_budget_exhausted');
-        continue;
-      }
-      report.attempted += 1;
-      rmSync(path, { force: true });
-      report.removed.push(name);
-    } catch (error) {
-      report.errors.push(`${name}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-  }
-  report.active.sort();
-  report.removed.sort();
-  report.errors.sort();
-  return report;
-}
-
-export interface CodegraphCacheLocator {
-  name: string;
-  path: string;
-  targetRoot: string;
-  release(): void;
-}
-
-export interface CodegraphCacheLocatorOptions {
-  migrateLegacy?: boolean;
-  createTarget?: boolean;
-}
-
-/**
- * Create a process-scoped CODEGRAPH_DIR locator. The source tree contains only
- * a short-lived symlink; durable cache bytes remain in Controller Home.
- */
-export function createCodegraphCacheLocator(
-  repoRoot: string,
-  controllerHome: string,
-  options: CodegraphCacheLocatorOptions = {},
-): CodegraphCacheLocator | null {
-  const canonicalRepo = resolve(repoRoot);
-  const targetRoot = codegraphRepositoryCacheRoot(controllerHome, canonicalRepo);
-  if (options.migrateLegacy === true) migrateLegacyCodegraphCache(canonicalRepo, controllerHome);
-  if (!existsSync(targetRoot)) {
-    if (options.createTarget === false) return null;
-    mkdirSync(targetRoot, { recursive: true });
-  }
-  cleanupStaleCodegraphLocators(canonicalRepo, controllerHome);
-
-  let name = '';
-  let path = '';
-  for (let attempt = 0; attempt < 16; attempt += 1) {
-    name = `${CODEGRAPH_LOCATOR_PREFIX}${process.pid}-${randomBytes(6).toString('hex')}`;
-    path = join(canonicalRepo, name);
-    if (!existsSync(path)) break;
-    name = '';
-  }
-  if (!name || !path) throw new Error('CODEGRAPH_LOCATOR_ID_EXHAUSTED');
-  symlinkSync(targetRoot, path, process.platform === 'win32' ? 'junction' : 'dir');
-  touchCacheRoot(targetRoot);
-  let released = false;
-  return {
-    name,
-    path,
-    targetRoot,
-    release(): void {
-      if (released) return;
-      released = true;
-      try {
-        if (existsSync(path) && lstatSync(path).isSymbolicLink() && samePath(absoluteLinkTarget(path), targetRoot)) {
-          rmSync(path, { force: true });
-        }
-      } finally {
-        touchCacheRoot(targetRoot);
-      }
-    },
-  };
-}