@moretea-labs/forge 1.6.0 → 1.7.1

package/scripts/check-skill-version.ts

@@ -1,193 +1,5 @@
 #!/usr/bin/env bun
-/**
- * Skill Version Consistency Checker
- *
- * Validates that version numbers are consistent across:
- * - package.json
- * - assets/skill-version.json
- *
- * Also checks if a generated project needs migration.
- */
+export * from "../assets/templates/helpers/check-skill-version";
+import { runTrackedForgeHelper } from "./lib/run-forge-helper";
 
-import { readFileSync, existsSync } from "fs";
-import { join, dirname } from "path";
-import { fileURLToPath } from "url";
-import { resolveAgenticDevRoot } from "./workflow-contract.ts";
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-const REPO_ROOT = __dirname.endsWith("/.ai/harness/scripts")
-  ? join(__dirname, "../../..")
-  : __dirname.endsWith("/assets/templates/helpers")
-    ? join(__dirname, "../../..")
-    : join(__dirname, "..");
-
-export interface ConsistencyResult {
-  consistent: boolean;
-  packageJsonVersion: string | null;
-  skillVersionJsonVersion: string;
-  templateVersionJsonVersion: string;
-  skillVersionSource: string;
-  warnings: string[];
-  errors: string[];
-}
-
-export interface MigrationCheckResult {
-  needsMigration: boolean;
-  currentSkillVersion: string;
-  projectSkillVersion: string | null;
-  projectTemplatVersion: string | null;
-}
-
-/**
- * Check version consistency across the version sources this repo owns.
- */
-export function checkConsistency(repoRoot: string = REPO_ROOT): ConsistencyResult {
-  const errors: string[] = [];
-  const warnings: string[] = [];
-
-  // Read package.json
-  const pkgPath = join(repoRoot, "package.json");
-  if (!existsSync(pkgPath)) {
-    throw new Error(`package.json not found at ${pkgPath}`);
-  }
-  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-  const packageJsonVersion =
-    typeof pkg.version === "string" && pkg.version.length > 0
-      ? (pkg.version as string)
-      : null;
-
-  // Read the local source manifest when this script runs inside forge;
-  // generated projects resolve the upstream skill root instead.
-  const localSvPath = join(repoRoot, "assets", "skill-version.json");
-  const svPath = existsSync(localSvPath)
-    ? localSvPath
-    : join(resolveAgenticDevRoot(repoRoot), "assets", "skill-version.json");
-  if (!existsSync(svPath)) {
-    throw new Error(`skill-version.json not found at ${svPath}`);
-  }
-  const sv = JSON.parse(readFileSync(svPath, "utf-8"));
-  const skillVersionJsonVersion = sv.version as string;
-  const templateVersionJsonVersion = sv.templateVersion as string;
-  const usingLocalSkillManifest = svPath === localSvPath;
-
-  const packageCoreVersion = packageJsonVersion?.split("-", 1)[0] ?? null;
-  const isForgePackage =
-    pkg.name === "forge" ||
-    pkg.name === "@moretea-labs/forge-controller" ||
-    pkg.name === "@moretea-labs/forge";
-
-  if (
-    usingLocalSkillManifest &&
-    isForgePackage &&
-    packageCoreVersion !== null &&
-    packageCoreVersion !== skillVersionJsonVersion
-  ) {
-    errors.push(
-      `package.json core version (${packageCoreVersion}) must match assets/skill-version.json version (${skillVersionJsonVersion})`
-    );
-  }
-
-  if (usingLocalSkillManifest && templateVersionJsonVersion !== skillVersionJsonVersion) {
-    errors.push(
-      `assets/skill-version.json templateVersion (${templateVersionJsonVersion}) must match version (${skillVersionJsonVersion})`
-    );
-  }
-
-  if (!usingLocalSkillManifest && packageJsonVersion !== null) {
-    warnings.push(
-      `package.json.version (${packageJsonVersion}) belongs to the target repo; workflow stamp uses upstream forge skill-version.json`
-    );
-  }
-
-  return {
-    consistent: errors.length === 0,
-    packageJsonVersion,
-    skillVersionJsonVersion,
-    templateVersionJsonVersion,
-    skillVersionSource: svPath,
-    warnings,
-    errors,
-  };
-}
-
-/**
- * Check if a generated project needs migration.
- */
-export function checkProjectNeedsMigration(
-  projectPath: string,
-  repoRoot: string = REPO_ROOT
-): MigrationCheckResult {
-  const localSvPath = join(repoRoot, "assets", "skill-version.json");
-  const svPath = existsSync(localSvPath)
-    ? localSvPath
-    : join(resolveAgenticDevRoot(repoRoot), "assets", "skill-version.json");
-  const sv = JSON.parse(readFileSync(svPath, "utf-8"));
-  const currentSkillVersion = sv.version as string;
-
-  const stampPath = join(projectPath, ".claude", ".skill-version");
-  if (!existsSync(stampPath)) {
-    return {
-      needsMigration: true,
-      currentSkillVersion,
-      projectSkillVersion: null,
-      projectTemplatVersion: null,
-    };
-  }
-
-  const stampContent = readFileSync(stampPath, "utf-8");
-  const skillVersionMatch = stampContent.match(/^skill_version=(.+)$/m);
-  const templateVersionMatch = stampContent.match(/^template_version=(.+)$/m);
-
-  const projectSkillVersion = skillVersionMatch?.[1] ?? null;
-  const projectTemplatVersion = templateVersionMatch?.[1] ?? null;
-
-  return {
-    needsMigration: projectSkillVersion !== currentSkillVersion,
-    currentSkillVersion,
-    projectSkillVersion,
-    projectTemplatVersion,
-  };
-}
-
-// CLI entry point
-if (import.meta.main) {
-  const args = process.argv.slice(2);
-  const projectIdx = args.indexOf("--project");
-  const projectPath = projectIdx !== -1 ? args[projectIdx + 1] : null;
-
-  try {
-    const result = checkConsistency();
-
-    if (result.consistent) {
-      console.log(
-        `Workflow version check passed: forge=${result.skillVersionJsonVersion}, template=${result.templateVersionJsonVersion}`
-      );
-      console.log(`Workflow version source: ${result.skillVersionSource}`);
-      for (const warning of result.warnings) {
-        console.log(`Warning: ${warning}`);
-      }
-    } else {
-      console.error("Version consistency check FAILED:");
-      for (const error of result.errors) {
-        console.error(`  - ${error}`);
-      }
-      process.exit(1);
-    }
-
-    if (projectPath) {
-      const migration = checkProjectNeedsMigration(projectPath);
-      if (migration.needsMigration) {
-        console.log(
-          `Project at ${projectPath} needs migration: ` +
-          `${migration.projectSkillVersion ?? "(no stamp)"} → ${migration.currentSkillVersion}`
-        );
-      } else {
-        console.log(`Project at ${projectPath} is up to date (${migration.currentSkillVersion})`);
-      }
-    }
-  } catch (error) {
-    console.error("Error:", error instanceof Error ? error.message : error);
-    process.exit(1);
-  }
-}
+if (import.meta.main) runTrackedForgeHelper("check-skill-version.ts");

package/scripts/check-source-duplication.mjs

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto';
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { basename } from 'node:path';
+
+const files = execFileSync('git', ['ls-files', '-z'], { encoding: 'utf8' }).split('\0').filter(Boolean);
+const byHash = new Map();
+
+for (const path of files) {
+  let content;
+  try { content = readFileSync(path); }
+  catch { continue; }
+  if (content.includes(0)) continue;
+  const hash = createHash('sha256').update(content).digest('hex');
+  const group = byHash.get(hash) ?? [];
+  group.push({ path, lines: content.toString('utf8').split(/\r?\n/).length - 1 });
+  byHash.set(hash, group);
+}
+
+function isGeneratedTemplateProjection(paths) {
+  if (paths.length !== 2) return false;
+  const claude = paths.find((path) => path.startsWith('.claude/templates/'));
+  const asset = paths.find((path) => path.startsWith('assets/templates/'));
+  return Boolean(claude && asset && basename(claude) === basename(asset) && claude.endsWith('.template.md'));
+}
+
+function isGuidanceAlias(paths) {
+  return paths.every((path) => ['AGENTS.md', 'CLAUDE.md'].includes(basename(path)));
+}
+
+function isPlaceholder(paths, lines) {
+  return lines <= 1 && paths.every((path) => path.endsWith('/.gitkeep'));
+}
+
+const duplicateGroups = [...byHash.values()].filter((group) => group.length > 1);
+const failures = [];
+let classifiedGroups = 0;
+let classifiedRedundantLines = 0;
+for (const group of duplicateGroups) {
+  const paths = group.map(({ path }) => path).sort();
+  const lines = group[0].lines;
+  const redundantLines = lines * (group.length - 1);
+  if (isGeneratedTemplateProjection(paths) || isGuidanceAlias(paths) || isPlaceholder(paths, lines)) {
+    classifiedGroups += 1;
+    classifiedRedundantLines += redundantLines;
+    continue;
+  }
+  failures.push({ paths, lines, redundantLines });
+}
+
+if (failures.length) {
+  console.error('[source-duplication] FAILED');
+  for (const failure of failures) {
+    console.error(`- unclassified exact duplicate (${failure.lines} lines each, ${failure.redundantLines} redundant):`);
+    for (const path of failure.paths) console.error(`  - ${path}`);
+  }
+  process.exit(1);
+}
+
+console.log(`[source-duplication] OK (${classifiedGroups} intentional groups, ${classifiedRedundantLines} classified redundant lines, 0 unclassified groups)`);

package/scripts/check-stable-baseline.ts

@@ -0,0 +1,92 @@
+#!/usr/bin/env bun
+import { createHash } from 'crypto';
+import { mkdirSync, renameSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { resolveControllerHome } from '../src/cli/repositories/controller-home';
+import { recoveryConnectorDescriptor, verifyRecoveryConnector } from '../src/cli/commands/recovery';
+import { loadRecoveryConfig, verifyStableRuntime } from '../src/runtime/standalone-recovery/core';
+import { observeRuntimeStatus } from '../src/runtime/root/status';
+
+interface BaselineReceipt {
+  schemaVersion: 1;
+  status: 'passed' | 'failed';
+  controllerHome: string;
+  observedAt: string;
+  runtime: ReturnType<typeof observeRuntimeStatus>;
+  recovery: {
+    connector: ReturnType<typeof recoveryConnectorDescriptor>;
+    runtimeVerify: Awaited<ReturnType<typeof verifyStableRuntime>>;
+    connectorVerify: Awaited<ReturnType<typeof verifyRecoveryConnector>>;
+  };
+  blockers: string[];
+  receiptId: string;
+}
+
+function argValue(name: string): string | undefined {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : undefined;
+}
+
+function atomicJson(path: string, value: unknown): void {
+  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync(temporary, `${JSON.stringify(value, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+  renameSync(temporary, path);
+}
+
+export async function checkStableBaseline(controllerHomeInput?: string): Promise<BaselineReceipt> {
+  const controllerHome = resolveControllerHome(controllerHomeInput);
+  const config = loadRecoveryConfig(controllerHome);
+  const runtime = observeRuntimeStatus(controllerHome);
+  const connector = recoveryConnectorDescriptor(controllerHome);
+  const runtimeVerify = await verifyStableRuntime(config);
+  const connectorVerify = await verifyRecoveryConnector(controllerHome);
+  const blockers: string[] = [];
+
+  if (!runtime.running || !runtime.ready) blockers.push(`runtime_not_ready:${runtime.reasonCodes.join(',') || 'unknown'}`);
+  if (!runtimeVerify.ok) blockers.push('recovery_runtime_verify_failed');
+  if (!runtimeVerify.releases.coherent) blockers.push('runtime_release_not_coherent');
+  if (!connector.readyForChatGPT) blockers.push(...connector.warnings.map((warning) => `recovery_connector:${warning}`));
+  if (!connectorVerify.ok) blockers.push(...connectorVerify.failures.map((failure) => `recovery_connector_verify:${failure}`));
+  if (!connector.currentRelease) blockers.push('recovery_release_missing');
+
+  const observedAt = new Date().toISOString();
+  const identity = {
+    schemaVersion: 1,
+    controllerHome,
+    runtimeInstanceId: runtime.snapshot?.runtimeInstanceId,
+    runtimeRelease: runtimeVerify.releases.active?.revision,
+    runtimeManifest: runtimeVerify.releases.active?.manifestSha256,
+    runtimeToolSurfaceFingerprint: runtime.snapshot?.toolSurfaceFingerprint,
+    runtimeEndpoint: runtime.snapshot?.endpoint,
+    recoveryRelease: connector.currentRelease,
+    recoveryUrl: connector.url,
+    runtimeReady: runtime.ready,
+    runtimeVerifyOk: runtimeVerify.ok,
+    connectorVerifyOk: connectorVerify.ok,
+  };
+  const receiptId = createHash('sha256').update(JSON.stringify(identity)).digest('hex');
+  const receipt: BaselineReceipt = {
+    schemaVersion: 1,
+    status: blockers.length === 0 ? 'passed' : 'failed',
+    controllerHome,
+    observedAt,
+    runtime,
+    recovery: { connector, runtimeVerify, connectorVerify },
+    blockers,
+    receiptId,
+  };
+
+  const root = join(controllerHome, 'recovery', 'stable-baseline');
+  atomicJson(join(root, `${receiptId}.json`), receipt);
+  atomicJson(join(root, 'latest.json'), receipt);
+  return receipt;
+}
+
+if (import.meta.main) {
+  const explicit = argValue('--controller-home');
+  if (process.argv.includes('--controller-home') && !explicit) throw new Error('STABLE_BASELINE_CONTROLLER_HOME_REQUIRED');
+  const receipt = await checkStableBaseline(explicit);
+  process.stdout.write(`${JSON.stringify(receipt, null, 2)}\n`);
+  if (receipt.status !== 'passed') process.exitCode = 1;
+}

package/scripts/check-task-sync.sh

@@ -1,65 +1,4 @@
 #!/bin/bash
 set -euo pipefail
-
-if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
-  echo "[task-sync] Not a git repository; skipping task-sync check."
-  exit 0
-fi
-
-get_changed_files() {
-  if ! git diff --cached --quiet --ignore-submodules --; then
-    git diff --cached --name-only --diff-filter=ACMR
-    return
-  fi
-
-  git diff --name-only --diff-filter=ACMR
-  git ls-files --others --exclude-standard
-}
-
-changed_files=()
-while IFS= read -r line; do
-  [[ -n "$line" ]] && changed_files+=("$line")
-done < <(get_changed_files)
-
-if [[ "${#changed_files[@]}" -eq 0 ]]; then
-  echo "[task-sync] No changes detected."
-  exit 0
-fi
-
-has_non_task_change=0
-has_task_sync_change=0
-
-for file in "${changed_files[@]}"; do
-  case "$file" in
-    tasks/archive/*)
-      has_non_task_change=1
-      ;;
-    tasks/*)
-      has_task_sync_change=1
-      ;;
-    docs/researches/*)
-      has_task_sync_change=1
-      ;;
-    *)
-      has_non_task_change=1
-      ;;
-  esac
-done
-
-if [[ "$has_non_task_change" -eq 0 ]]; then
-  if [[ "$has_task_sync_change" -eq 1 ]]; then
-    echo "[task-sync] Only task/research sync files changed."
-  else
-    echo "[task-sync] No substantive repo changes detected."
-  fi
-  exit 0
-fi
-
-if [[ "$has_task_sync_change" -eq 1 ]]; then
-  echo "[task-sync] Repo changes include synchronized tasks/ updates."
-  exit 0
-fi
-
-echo "[task-sync] Substantive repo changes detected without tasks/ synchronization."
-echo "[task-sync] Update tasks/current.md, tasks/todos.md, tasks/lessons.md, docs/researches/*.md, tasks/notes/*.md, or an active tasks/contracts/*.md file."
-exit 1
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/lib/run-forge-helper.sh" "check-task-sync.sh" "$@"