forgeos 0.1.0-alpha.2 → 0.1.0-alpha.21

package/src/forge/brownfield-import/types.ts

@@ -0,0 +1,127 @@
+export type BrownfieldImportSubcommand = "analyze" | "inspect";
+
+export interface BrownfieldImportCommandOptions {
+  subcommand: BrownfieldImportSubcommand;
+  json: boolean;
+  dryRun: boolean;
+  workspaceRoot: string;
+  entry?: string;
+  target?: string;
+}
+
+export type ImportedAssurance = "static-scan";
+export type ImportedReviewStatus = "needs-review" | "approved" | "rejected";
+export type ImportedEntryKind = "command" | "command-candidate" | "query" | "unknown";
+export type ImportedRouteSource = "next-app-router" | "next-pages-api" | "express" | "nest" | "unknown";
+
+export interface ImportedDependencyInventory {
+  dependencies: string[];
+  devDependencies: string[];
+  scripts: string[];
+  frameworks: string[];
+  dataPackages: string[];
+  externalPackages: string[];
+}
+
+export interface ImportedInventory {
+  schemaVersion: "0.1.0";
+  origin: "imported";
+  assurance: ImportedAssurance;
+  workspaceRoot: string;
+  generatedAt: string;
+  packageName?: string;
+  dependencies: ImportedDependencyInventory;
+  filesScanned: number;
+  sourceFiles: string[];
+  env: {
+    processEnv: string[];
+    envFiles: string[];
+  };
+}
+
+export interface ImportedRoute {
+  id: string;
+  method: string;
+  path: string;
+  file: string;
+  source: ImportedRouteSource;
+  handler?: string;
+  confidence: number;
+}
+
+export interface ImportedFrontendCall {
+  id: string;
+  file: string;
+  client: "fetch" | "axios";
+  method: string;
+  url: string;
+  routeId?: string;
+  confidence: number;
+}
+
+export interface ImportedCandidateEntry {
+  id: string;
+  name: string;
+  kind: ImportedEntryKind;
+  method: string;
+  path: string;
+  routeId: string;
+  file: string;
+  origin: "imported";
+  assurance: ImportedAssurance;
+  reviewStatus: ImportedReviewStatus;
+  visibleToAgent: boolean;
+  needsApproval: boolean;
+  confidence: number;
+  risks: string[];
+  evidence: string[];
+}
+
+export interface ImportedRiskFinding {
+  code: string;
+  severity: "info" | "warning" | "error";
+  file?: string;
+  routeId?: string;
+  message: string;
+}
+
+export interface ImportedRiskReport {
+  schemaVersion: "0.1.0";
+  summary: {
+    routeCount: number;
+    frontendCallCount: number;
+    candidateCount: number;
+    commandCount: number;
+    queryCount: number;
+    hiddenFromAgents: number;
+    needsApproval: number;
+  };
+  findings: ImportedRiskFinding[];
+}
+
+export interface BrownfieldImportArtifacts {
+  inventory: string;
+  routes: string;
+  frontendCalls: string;
+  candidateEntries: string;
+  riskReport: string;
+  migrationPlan: string;
+  importedAgentContract: string;
+}
+
+export interface BrownfieldImportResult {
+  schemaVersion: "0.1.0";
+  feature: "H49";
+  subcommand: BrownfieldImportSubcommand;
+  workspaceRoot: string;
+  wroteArtifacts: boolean;
+  artifacts: BrownfieldImportArtifacts;
+  inventory: ImportedInventory | null;
+  routes: ImportedRoute[];
+  frontendCalls: ImportedFrontendCall[];
+  candidateEntries: ImportedCandidateEntry[];
+  riskReport: ImportedRiskReport | null;
+  migrationPlan: string | null;
+  exitCode: 0 | 1;
+  failureKind?: string;
+}

package/src/forge/cair/action-journal.ts

@@ -0,0 +1,61 @@
+import { createHash } from "node:crypto";
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import type { CairFileChange, CairParsedAction } from "./types.ts";
+
+function hashText(value: string): string {
+  return createHash("sha256").update(value).digest("hex");
+}
+
+function normalizeSlashes(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
+export function writeCairActionJournal(
+  workspaceRoot: string,
+  action: CairParsedAction,
+  changes: CairFileChange[],
+  dryRun: boolean,
+): string | undefined {
+  if (dryRun || changes.every((change) => change.operation === "noop")) {
+    return undefined;
+  }
+  const journalDir = join(workspaceRoot, ".forge", "cair", "journal");
+  mkdirSync(journalDir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const suffix = hashText(`${action.raw}\n${JSON.stringify(changes)}\n${stamp}`).slice(0, 10);
+  const journalPath = join(journalDir, `${stamp}-${suffix}.json`);
+  writeFileSync(
+    journalPath,
+    `${JSON.stringify({ schemaVersion: "0.5.0", action, changes, createdAt: new Date().toISOString() }, null, 2)}\n`,
+    "utf8",
+  );
+  return normalizeSlashes(relative(workspaceRoot, journalPath));
+}
+
+export interface CairActionPlanRef {
+  id: string;
+  path: string;
+}
+
+export function writeCairActionPlan(
+  workspaceRoot: string,
+  action: CairParsedAction,
+  changes: CairFileChange[],
+): CairActionPlanRef | undefined {
+  if (changes.length === 0 || changes.every((change) => change.operation === "noop")) {
+    return undefined;
+  }
+  const planDir = join(workspaceRoot, ".forge", "cair", "plans");
+  mkdirSync(planDir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const suffix = hashText(`${action.raw}\n${JSON.stringify(changes)}`).slice(0, 10);
+  const id = `P#${suffix}`;
+  const planPath = join(planDir, `${stamp}-${suffix}.json`);
+  writeFileSync(
+    planPath,
+    `${JSON.stringify({ schemaVersion: "0.5.0", id, action, changes, createdAt: new Date().toISOString() }, null, 2)}\n`,
+    "utf8",
+  );
+  return { id, path: normalizeSlashes(relative(workspaceRoot, planPath)) };
+}

package/src/forge/cair/action-parser.ts

@@ -0,0 +1,314 @@
+import { createDiagnostic } from "../compiler/diagnostics/create.ts";
+import type { Diagnostic } from "../compiler/types/diagnostic.ts";
+import type {
+  CairActionScriptHeader,
+  CairActionVerb,
+  CairParsedAction,
+} from "./types.ts";
+
+export interface CairParsedActionScript {
+  header?: CairActionScriptHeader;
+  blocks: string[];
+  diagnostics: Diagnostic[];
+}
+
+function actionError(message: string): Diagnostic {
+  return createDiagnostic({
+    severity: "error",
+    code: "FORGE_CAIR_ACTION",
+    message,
+  });
+}
+
+function tokenizeHead(input: string): string[] {
+  const tokens: string[] = [];
+  let current = "";
+  let quote: "'" | "\"" | null = null;
+  let escaped = false;
+
+  for (const char of input) {
+    if (escaped) {
+      if (char === "n") {
+        current += "\n";
+      } else if (char === "t") {
+        current += "\t";
+      } else {
+        current += char;
+      }
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === "\"") {
+      quote = char;
+      continue;
+    }
+    if (/\s/.test(char)) {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+
+  if (escaped) {
+    current += "\\";
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+
+function splitBody(raw: string): { head: string; body?: string } {
+  const normalized = raw.replace(/\r\n/g, "\n").trim();
+  const lines = normalized.split("\n");
+  const markerIndex = lines.findIndex((line) => line.trim().startsWith("<<"));
+  if (markerIndex === -1) {
+    return { head: normalized };
+  }
+
+  const marker = lines[markerIndex]?.trim().slice(2).trim() || "CODE";
+  const endIndex = lines.findIndex((line, index) =>
+    index > markerIndex && line.trim() === marker,
+  );
+  if (endIndex === -1) {
+    return { head: normalized };
+  }
+
+  return {
+    head: lines.slice(0, markerIndex).join(" ").trim(),
+    body: lines.slice(markerIndex + 1, endIndex).join("\n"),
+  };
+}
+
+function parseKeyValues(parts: string[]): Record<string, string> {
+  const args: Record<string, string> = {};
+  const keyAliases: Record<string, string> = {
+    f: "file",
+    h: "hash",
+    k: "kind",
+    n: "name",
+    nn: "newname",
+    p: "path",
+    s: "symbol",
+    t: "target",
+    to: "to",
+  };
+  for (const part of parts) {
+    const index = part.indexOf("=");
+    if (index <= 0) {
+      continue;
+    }
+    const rawKey = part.slice(0, index).toLowerCase();
+    args[keyAliases[rawKey] ?? rawKey] = part.slice(index + 1);
+  }
+  return args;
+}
+
+function normalizeVerb(phase: "A" | "V", value: string | undefined): CairActionVerb | null {
+  const raw = phase === "V" ? `VERIFY.${value ?? ""}` : value;
+  const upper = raw?.toUpperCase();
+  switch (upper) {
+    case "CF":
+    case "CREATE.FILE":
+    case "FILE.CREATE":
+    case "NEW.FILE":
+    case "F+":
+      return "CREATE.FILE";
+    case "CS":
+    case "CREATE.SYMBOL":
+    case "SYMBOL.CREATE":
+    case "SYM+":
+      return "CREATE.SYMBOL";
+    case "P":
+    case "PATCH":
+      return "PATCH";
+    case "ADD.EXPORT":
+    case "EXPORT.ADD":
+    case "EX+":
+      return "ADD.EXPORT";
+    case "ADD.IMPORT":
+    case "IMPORT.ADD":
+    case "IM+":
+      return "ADD.IMPORT";
+    case "APPLY":
+    case "AP":
+      return "APPLY";
+    case "ROLLBACK":
+    case "RB":
+      return "ROLLBACK";
+    case "RN":
+    case "RENAME.SYMBOL":
+    case "SYMBOL.RENAME":
+      return "RENAME.SYMBOL";
+    case "MV":
+    case "MOVE.SYMBOL":
+    case "SYMBOL.MOVE":
+      return "MOVE.SYMBOL";
+    case "SIG":
+    case "UPDATE.SIGNATURE":
+    case "SIGNATURE.UPDATE":
+      return "UPDATE.SIGNATURE";
+    case "PARAM":
+    case "ADD.PARAM":
+    case "PARAM.ADD":
+      return "ADD.PARAM";
+    case "CALLS":
+    case "UPDATE.CALLSITES":
+    case "CALLSITES.UPDATE":
+      return "UPDATE.CALLSITES";
+    case "OI":
+    case "ORGANIZE.IMPORTS":
+    case "IMPORTS.ORGANIZE":
+      return "ORGANIZE.IMPORTS";
+    case "FMT":
+    case "FORMAT":
+      return "FORMAT";
+    case "FP":
+    case "FIND.PATTERN":
+    case "PATTERN.FIND":
+      return "FIND.PATTERN";
+    case "RW":
+    case "REWRITE.PATTERN":
+    case "PATTERN.REWRITE":
+      return "REWRITE.PATTERN";
+    case "MC":
+    case "MAKE.COMMAND":
+      return "MAKE.COMMAND";
+    case "MQ":
+    case "MAKE.QUERY":
+      return "MAKE.QUERY";
+    case "MA":
+    case "MAKE.ACTION":
+      return "MAKE.ACTION";
+    case "MT":
+    case "MAKE.TABLE":
+      return "MAKE.TABLE";
+    case "AT":
+    case "ADD.TEST":
+    case "TEST.ADD":
+      return "ADD.TEST";
+    case "WX":
+    case "WIRE.EXPORT":
+    case "EXPORT.WIRE":
+      return "WIRE.EXPORT";
+    case "VERIFY":
+    case "VERIFY.TYPECHECK":
+    case "TYPECHECK":
+    case "VERIFY.TEST":
+    case "TEST":
+    case "VERIFY.IMPACT":
+    case "IMPACT":
+      return "VERIFY";
+    default:
+      return null;
+  }
+}
+
+function parseHeaderLine(line: string): CairActionScriptHeader | null {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("@cair")) {
+    return null;
+  }
+  const parts = tokenizeHead(trimmed);
+  const args = parseKeyValues(parts.slice(2));
+  return {
+    ...(parts[1] ? { schemaVersion: parts[1] } : {}),
+    ...(args.snapshot ? { snapshot: args.snapshot } : {}),
+  };
+}
+
+export function parseCairAction(raw: string): { action?: CairParsedAction; diagnostics: Diagnostic[] } {
+  const { head, body } = splitBody(raw);
+  const parts = tokenizeHead(head);
+  const phase = parts[0]?.toUpperCase();
+  if (phase !== "A" && phase !== "V") {
+    return { diagnostics: [actionError("CAIR action must start with A or V")] };
+  }
+  const verb = normalizeVerb(phase, parts[1]);
+  if (!verb) {
+    return { diagnostics: [actionError(`unknown CAIR action verb '${parts[1] ?? ""}'`)] };
+  }
+  return {
+    action: {
+      raw: raw.trim(),
+      phase,
+      verb,
+      args: parseKeyValues(parts.slice(2)),
+      ...(body !== undefined ? { body } : {}),
+    },
+    diagnostics: [],
+  };
+}
+
+export function parseCairActionScript(script: string): CairParsedActionScript {
+  const lines = script.replace(/\r\n/g, "\n").split("\n");
+  const blocks: string[] = [];
+  let current: string[] = [];
+  let hereDocMarker: string | null = null;
+  let header: CairActionScriptHeader | undefined;
+  const diagnostics: Diagnostic[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!hereDocMarker && current.length === 0 && !header) {
+      const parsedHeader = parseHeaderLine(trimmed);
+      if (parsedHeader) {
+        header = parsedHeader;
+        continue;
+      }
+    }
+
+    if (hereDocMarker) {
+      current.push(line);
+      if (trimmed === hereDocMarker) {
+        hereDocMarker = null;
+      }
+      continue;
+    }
+
+    if (trimmed.startsWith("<<")) {
+      current.push(line);
+      hereDocMarker = trimmed.slice(2).trim() || "CODE";
+      continue;
+    }
+
+    if (/^[AV]\s+/.test(trimmed)) {
+      if (current.join("\n").trim()) {
+        blocks.push(current.join("\n").trim());
+      }
+      current = [line];
+      continue;
+    }
+
+    if (current.length > 0 || trimmed) {
+      current.push(line);
+    }
+  }
+
+  if (hereDocMarker) {
+    diagnostics.push(actionError(`unterminated CAIR heredoc '${hereDocMarker}'`));
+  }
+  if (current.join("\n").trim()) {
+    blocks.push(current.join("\n").trim());
+  }
+  return { ...(header ? { header } : {}), blocks, diagnostics };
+}
+
+export function splitCairActionScript(script: string): string[] {
+  return parseCairActionScript(script).blocks;
+}

package/src/forge/cair/action-validator.ts

@@ -0,0 +1,40 @@
+import { createDiagnostic } from "../compiler/diagnostics/create.ts";
+import type { Diagnostic } from "../compiler/types/diagnostic.ts";
+import type { CairParsedAction, CairSymbolRef } from "./types.ts";
+
+function normalizeSlashes(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
+function actionError(message: string, file?: string): Diagnostic {
+  return createDiagnostic({
+    severity: "error",
+    code: "FORGE_CAIR_ACTION",
+    message,
+    ...(file ? { file } : {}),
+  });
+}
+
+export function validateSemanticExpectations(
+  action: CairParsedAction,
+  symbol: CairSymbolRef,
+): Diagnostic[] {
+  const diagnostics: Diagnostic[] = [];
+  const expectedFile = action.args["expect.file"];
+  const expectedKind = action.args["expect.kind"];
+  const expectedHash = action.args["expect.hash"];
+  if (!expectedFile || !expectedKind || !expectedHash) {
+    diagnostics.push(actionError(`${action.verb} requires expect.file, expect.kind, and expect.hash`, symbol.file));
+    return diagnostics;
+  }
+  if (normalizeSlashes(expectedFile) !== normalizeSlashes(symbol.file)) {
+    diagnostics.push(actionError(`expect.file mismatch: expected ${expectedFile}, got ${symbol.file}`, symbol.file));
+  }
+  if (expectedKind !== symbol.kind) {
+    diagnostics.push(actionError(`expect.kind mismatch: expected ${expectedKind}, got ${symbol.kind}`, symbol.file));
+  }
+  if (expectedHash !== symbol.hash) {
+    diagnostics.push(actionError(`expect.hash mismatch: expected ${expectedHash}, got ${symbol.hash}`, symbol.file));
+  }
+  return diagnostics;
+}