forgeos 0.1.0-alpha.30 → 0.1.0-alpha.32

package/src/forge/cli/last-run.ts

@@ -0,0 +1,84 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface LastRunRecord {
+  schemaVersion: "0.1.0";
+  command: string;
+  ok: boolean;
+  startedAt: string;
+  finishedAt: string;
+  durationMs: number;
+  code?: string;
+  failureKind?: string;
+  message?: string;
+  nextActions: string[];
+  details?: Record<string, unknown>;
+}
+
+export interface LastRunCommandResult {
+  ok: boolean;
+  record: LastRunRecord | null;
+  path: string;
+  exitCode: 0 | 1;
+}
+
+function lastRunPath(workspaceRoot: string): string {
+  return join(workspaceRoot, ".forge", "last-run.json");
+}
+
+export function writeLastRunRecord(workspaceRoot: string, record: LastRunRecord): void {
+  const file = lastRunPath(workspaceRoot);
+  mkdirSync(join(workspaceRoot, ".forge"), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+}
+
+export function readLastRunRecord(workspaceRoot: string): LastRunRecord | null {
+  const file = lastRunPath(workspaceRoot);
+  if (!existsSync(file)) {
+    return null;
+  }
+  return JSON.parse(readFileSync(file, "utf8")) as LastRunRecord;
+}
+
+export function runLastCommand(options: { workspaceRoot: string }): LastRunCommandResult {
+  const path = lastRunPath(options.workspaceRoot);
+  const record = readLastRunRecord(options.workspaceRoot);
+  return {
+    ok: record !== null,
+    record,
+    path,
+    exitCode: record ? 0 : 1,
+  };
+}
+
+export function formatLastJson(result: LastRunCommandResult): string {
+  return `${JSON.stringify(result, null, 2)}\n`;
+}
+
+export function formatLastHuman(result: LastRunCommandResult): string {
+  if (!result.record) {
+    return `No last run record found at ${result.path}\n`;
+  }
+  const lines = [
+    `Last Forge run: ${result.record.command}`,
+    `OK: ${result.record.ok}`,
+    `Finished: ${result.record.finishedAt}`,
+    `Duration: ${result.record.durationMs}ms`,
+  ];
+  if (result.record.code) {
+    lines.push(`Code: ${result.record.code}`);
+  }
+  if (result.record.failureKind) {
+    lines.push(`Failure: ${result.record.failureKind}`);
+  }
+  if (result.record.message) {
+    lines.push(`Message: ${result.record.message}`);
+  }
+  if (result.record.nextActions.length > 0) {
+    lines.push("Next actions:");
+    for (const action of result.record.nextActions) {
+      lines.push(`  ${action}`);
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}

package/src/forge/cli/main.ts

@@ -14,6 +14,8 @@ function formatHelp(): string {
     "  forge status --json       Compact project health, handoff state, and next actions",
     "  forge changed --json      Group changed files into human, generated, and risk buckets",
     "  forge changed --authored --json  Show only authored changed files, excluding generated artifacts",
+    "  forge changed --review --json  Show review-focused app/config/docs changes, excluding local agent/browser artifacts",
+    "  forge new my-app --template minimal-web --field-test  Create an installed WorkOS/auth.md field-test app",
     "  forge diff authored       Run the authored-only git diff pathspec",
     "  forge handoff --json      Compact work handoff for the next external code agent",
     "  forge agent onboard --target codex --json  Prepare adapter, hooks, memory, and dev snapshot",
@@ -28,7 +30,7 @@ function formatHelp(): string {
     "  forge workos install --yes --json  Delegate AuthKit setup to npx --yes workos@latest install",
     "  forge workos doctor --json  Check WorkOS AuthKit/FGA files, claims, seed, webhook, and tenant guards",
     "  forge workos doctor --yes --json  Run local checks, then delegate to npx --yes workos@latest doctor",
-    "  forge workos seed --file src/forge/_generated/integrations/workos/workos-seed.yml --json  Plan WorkOS CLI seed",
+    "  forge workos seed --file workos-seed.yml --json  Plan WorkOS CLI seed",
     "  forge release check --allow-missing-local-release --json  Gate release readiness without failing on unprepared local artifacts",
     "  forge self-host check --prepared-only --json  Report compose readiness without creating deploy files",
     "  forge delta status --verbose --json  Include Delta schema, lock, and aggregate count details",

package/src/forge/cli/new.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { cpSync, statSync } from "node:fs";
-import { dirname, join, parse, relative, resolve } from "node:path";
+import { basename, dirname, join, parse, relative, resolve } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { pathToFileURL } from "node:url";
 import { nodeFileSystem } from "../compiler/fs/index.ts";
@@ -17,6 +17,7 @@ export interface NewCommandOptions {
   packageManager: NewPackageManager;
   install: boolean;
   git: boolean;
+  fieldTest?: boolean;
   forgePackageSpec?: string;
   localForge?: boolean;
   workspaceRoot: string;
@@ -29,6 +30,11 @@ export interface NewCommandResult {
   packageManager: NewPackageManager;
   installed: boolean;
   gitInitialized: boolean;
+  fieldTest: {
+    requested: boolean;
+    ok: boolean;
+    steps: Array<{ name: string; ok: boolean; command: string }>;
+  };
   generated: boolean;
   gitHygiene: {
     ok: boolean;
@@ -195,12 +201,49 @@ function ensureProjectName(name: string): string | null {
   if (!name.trim()) {
     return "forge new requires a project name";
   }
-  if (name.includes("/") || name.includes("\\") || name === "." || name === "..") {
+  if (name === ".") {
+    return null;
+  }
+  if (name.includes("/") || name.includes("\\") || name === "..") {
     return "project name must be a directory name, not a path";
   }
   return null;
 }
 
+function isCurrentDirectoryTarget(name: string): boolean {
+  return name === ".";
+}
+
+function targetDirectoryFor(options: NewCommandOptions): string {
+  return isCurrentDirectoryTarget(options.name)
+    ? resolve(options.workspaceRoot)
+    : resolve(options.workspaceRoot, options.name);
+}
+
+function sanitizePackageName(name: string): string {
+  return name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^[._-]+|[._-]+$/g, "") || "forge-app";
+}
+
+function projectNameForTarget(options: NewCommandOptions, targetDir: string): string {
+  return isCurrentDirectoryTarget(options.name)
+    ? sanitizePackageName(basename(targetDir))
+    : options.name;
+}
+
+function blockingExistingEntries(targetDir: string): string[] {
+  const allowed = new Set([".git", ".DS_Store", "Thumbs.db"]);
+  return nodeFileSystem
+    .readDir(targetDir)
+    .map((entry) => entry.name)
+    .filter((name) => !allowed.has(name))
+    .sort();
+}
+
 function analyzeGitHygiene(targetDir: string): NewCommandResult["gitHygiene"] {
   const gitignorePath = join(targetDir, ".gitignore");
   const gitignore = nodeFileSystem.exists(gitignorePath)
@@ -380,6 +423,7 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
       packageManager: options.packageManager,
       installed: false,
       gitInitialized: false,
+      fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
       generated: false,
       gitHygiene: { ok: false, ignoredPaths: [], missingPaths: [] },
       exitCode: 1,
@@ -397,6 +441,7 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
       packageManager: options.packageManager,
       installed: false,
       gitInitialized: false,
+      fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
       generated: false,
       gitHygiene: { ok: false, ignoredPaths: [], missingPaths: [] },
       exitCode: 1,
@@ -405,15 +450,18 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
     };
   }
 
-  const targetDir = resolve(options.workspaceRoot, options.name);
-  if (nodeFileSystem.exists(targetDir)) {
+  const targetDir = targetDirectoryFor(options);
+  const appName = projectNameForTarget(options, targetDir);
+  const currentDirectoryTarget = isCurrentDirectoryTarget(options.name);
+  if (nodeFileSystem.exists(targetDir) && !currentDirectoryTarget) {
     return {
-      name: options.name,
+      name: appName,
       template: options.template,
       targetDir,
       packageManager: options.packageManager,
       installed: false,
       gitInitialized: false,
+      fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
       generated: false,
       gitHygiene: { ok: false, ignoredPaths: [], missingPaths: [] },
       exitCode: 1,
@@ -421,13 +469,32 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
       nextSteps: [],
     };
   }
+  if (nodeFileSystem.exists(targetDir) && currentDirectoryTarget) {
+    const blocking = blockingExistingEntries(targetDir);
+    if (blocking.length > 0) {
+      return {
+        name: appName,
+        template: options.template,
+        targetDir,
+        packageManager: options.packageManager,
+        installed: false,
+        gitInitialized: false,
+        fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
+        generated: false,
+        gitHygiene: { ok: false, ignoredPaths: [], missingPaths: [] },
+        exitCode: 1,
+        message: `current directory is not empty: ${blocking.slice(0, 6).join(", ")}${blocking.length > 6 ? ` (+${blocking.length - 6})` : ""}`,
+        nextSteps: [],
+      };
+    }
+  }
 
   nodeFileSystem.mkdirp(targetDir);
   cpSync(source, targetDir, { recursive: true, force: true });
   ensureGitignore(targetDir);
   replaceTokens(
     targetDir,
-    options.name,
+    appName,
     options.packageManager,
     forgePackageSpec(targetDir, options),
   );
@@ -438,12 +505,13 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
     installed = installCode === 0;
     if (!installed) {
       return {
-        name: options.name,
+        name: appName,
         template: options.template,
         targetDir,
         packageManager: options.packageManager,
         installed,
         gitInitialized: false,
+        fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
         generated: false,
         gitHygiene: analyzeGitHygiene(targetDir),
         exitCode: 1,
@@ -472,12 +540,13 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
     }
     if (!generated) {
       return {
-        name: options.name,
+        name: appName,
         template: options.template,
         targetDir,
         packageManager: options.packageManager,
         installed,
         gitInitialized: false,
+        fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
         generated,
         gitHygiene: analyzeGitHygiene(targetDir),
         exitCode: 1,
@@ -493,26 +562,68 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
     gitInitialized = gitCode === 0;
   }
 
+  const fieldTestSteps: NewCommandResult["fieldTest"]["steps"] = [];
+  if (options.fieldTest && installed) {
+    const steps: Array<{ name: string; command: string; args: string[] }> = [
+      { name: "workos", command: options.packageManager, args: ["run", "forge", "--", "add", "auth", "workos", "--json"] },
+      { name: "authmd", command: options.packageManager, args: ["run", "forge", "--", "authmd", "generate", "--json"] },
+      { name: "check", command: options.packageManager, args: ["run", "forge", "--", "check", "--json"] },
+    ];
+    for (const step of steps) {
+      const code = await spawnCommand(step.command, step.args, targetDir);
+      fieldTestSteps.push({ name: step.name, ok: code === 0, command: [step.command, ...step.args].join(" ") });
+      if (code !== 0) {
+        break;
+      }
+    }
+    if (gitInitialized && fieldTestSteps.every((step) => step.ok)) {
+      const addCode = await spawnCommand("git", ["add", "-A"], targetDir);
+      const commitCode = addCode === 0
+        ? await spawnCommand("git", [
+          "-c",
+          "user.name=ForgeOS",
+          "-c",
+          "user.email=forgeos@example.invalid",
+          "commit",
+          "-m",
+          "Initial ForgeOS field-test scaffold",
+        ], targetDir)
+        : 1;
+      fieldTestSteps.push({
+        name: "baseline-commit",
+        ok: addCode === 0 && commitCode === 0,
+        command: 'git add -A && git commit -m "Initial ForgeOS field-test scaffold"',
+      });
+    }
+  }
+  const fieldTest = {
+    requested: Boolean(options.fieldTest),
+    ok: !options.fieldTest || (installed && fieldTestSteps.length > 0 && fieldTestSteps.every((step) => step.ok)),
+    steps: fieldTestSteps,
+  };
+
   const nextSteps = [
-    `cd ${options.name}`,
+    ...(currentDirectoryTarget ? [] : [`cd ${options.name}`]),
     ...(installed ? [] : [`${options.packageManager} install`]),
     ...(generated ? [] : [`${options.packageManager} run generate`]),
+    ...(options.fieldTest ? [`${options.packageManager} run forge -- agent onboard --target codex --json`] : []),
     `${options.packageManager} run dev -- --open`,
     `${options.packageManager} run verify`,
   ];
   const gitHygiene = analyzeGitHygiene(targetDir);
 
   return {
-    name: options.name,
+    name: appName,
     template: options.template,
     targetDir,
     packageManager: options.packageManager,
     installed,
     gitInitialized,
+    fieldTest,
     generated,
     gitHygiene,
-    exitCode: 0,
-    message: `Created ${options.name} from template ${options.template}.`,
+    exitCode: fieldTest.ok ? 0 : 1,
+    message: `Created ${appName} from template ${options.template}.`,
     nextSteps,
   };
 }
@@ -524,6 +635,13 @@ export function formatNewHuman(result: NewCommandResult): string {
 
   return [
     result.message,
+    ...(result.fieldTest.requested
+      ? [
+          result.fieldTest.ok
+            ? "Field-test setup completed: WorkOS, auth.md, check, and baseline commit are ready."
+            : `warning: field-test setup did not complete: ${result.fieldTest.steps.find((step) => !step.ok)?.name ?? "not-run"}`,
+        ]
+      : []),
     ...(result.gitHygiene.ok
       ? ["Generated and operational Forge files are ignored by git."]
       : [

package/src/forge/cli/output.ts

@@ -5,6 +5,7 @@ import type {
   InspectResult,
   VerifyResult,
 } from "../compiler/types/cli.ts";
+import { forgeCliCommandsForWorkspace } from "../workspace/forge-cli.ts";
 import { uniqueNextActions } from "./next-actions.ts";
 
 function failureKindFromDiagnostics(errors: Diagnostic[]): string | undefined {
@@ -55,7 +56,32 @@ function summarizeGeneratedArtifacts(paths: string[]): Record<string, number> {
   return groups;
 }
 
+function compactList(items: string[], sampleSize = 12): { count: number; sample: string[]; hidden: number } {
+  return {
+    count: items.length,
+    sample: items.slice(0, sampleSize),
+    hidden: Math.max(0, items.length - sampleSize),
+  };
+}
+
+function summarizeDiagnostics(diagnostics: Diagnostic[]): Record<string, number> {
+  const summary: Record<string, number> = {};
+  for (const diagnostic of diagnostics) {
+    summary[diagnostic.code] = (summary[diagnostic.code] ?? 0) + 1;
+  }
+  return summary;
+}
+
 function buildGenerateNextActions(result: GenerateResult): string[] {
+  if (result.exitCode !== 0 && result.errors.length === 0 && result.changed.length > 0) {
+    return [
+      "forge generate --json",
+      "forge generate --check --json",
+      "forge changed --review --json",
+      "forge check --json",
+    ];
+  }
+
   const suggested = new Set<string>();
   for (const diagnostic of [...result.errors, ...result.warnings]) {
     for (const command of diagnostic.suggestedCommands ?? []) {
@@ -80,8 +106,29 @@ function buildGenerateNextActions(result: GenerateResult): string[] {
   return [...suggested];
 }
 
-export function buildGenerateJson(result: GenerateResult): Record<string, unknown> {
+export function buildGenerateJson(
+  result: GenerateResult,
+  options: { workspaceRoot?: string } = {},
+): Record<string, unknown> {
   const diagnostics = [...result.errors, ...result.warnings];
+  const changed = compactList(result.changed);
+  const unchanged = compactList(result.unchanged);
+  const drift =
+    result.exitCode !== 0 && result.errors.length === 0 && result.changed.length > 0
+      ? {
+          kind: "generated-drift",
+          message: `${result.changed.length} generated artifact(s) would change; run forge generate before handoff or verification.`,
+          changedGroups: summarizeGeneratedArtifacts(result.changed),
+          sampleChanged: changed.sample,
+          hiddenChanged: changed.hidden,
+          repairCommand: options.workspaceRoot
+            ? forgeCliCommandsForWorkspace(options.workspaceRoot, ["forge generate"])[0]
+            : "forge generate",
+          checkCommand: options.workspaceRoot
+            ? forgeCliCommandsForWorkspace(options.workspaceRoot, ["forge generate --check --json"])[0]
+            : "forge generate --check --json",
+        }
+      : null;
   return {
     schemaVersion: "0.1.0",
     ok: result.exitCode === 0,
@@ -92,20 +139,32 @@ export function buildGenerateJson(result: GenerateResult): Record<string, unknow
       errors: result.errors.length,
       changedGroups: summarizeGeneratedArtifacts(result.changed),
       unchangedGroups: summarizeGeneratedArtifacts(result.unchanged),
+      changedSample: changed.sample,
+      hiddenChanged: changed.hidden,
+      unchangedSample: unchanged.sample,
+      hiddenUnchanged: unchanged.hidden,
+      diagnosticGroups: summarizeDiagnostics(diagnostics),
+      ...(drift ? { message: drift.message } : {}),
     },
+    ...(drift ? { drift } : {}),
     changed: result.changed,
     unchanged: result.unchanged,
     warnings: result.warnings,
     errors: result.errors,
     diagnostics,
-    nextActions: buildGenerateNextActions(result),
+    nextActions: options.workspaceRoot
+      ? forgeCliCommandsForWorkspace(options.workspaceRoot, buildGenerateNextActions(result))
+      : buildGenerateNextActions(result),
     durationMs: null,
     exitCode: result.exitCode,
     failureKind: result.failureKind ?? null,
   };
 }
 
-export function buildCheckJson(result: GenerateResult): Record<string, unknown> {
+export function buildCheckJson(
+  result: GenerateResult,
+  options: { workspaceRoot?: string } = {},
+): Record<string, unknown> {
   const diagnostics = [...result.errors, ...result.warnings];
   const suggested = new Set<string>();
   for (const diagnostic of diagnostics) {
@@ -135,15 +194,20 @@ export function buildCheckJson(result: GenerateResult): Record<string, unknown>
     warnings: result.warnings,
     errors: result.errors,
     diagnostics,
-    nextActions: uniqueNextActions([...suggested]),
+    nextActions: options.workspaceRoot
+      ? forgeCliCommandsForWorkspace(options.workspaceRoot, uniqueNextActions([...suggested]))
+      : uniqueNextActions([...suggested]),
     durationMs: null,
     exitCode: result.exitCode,
     failureKind: result.failureKind ?? null,
   };
 }
 
-export function buildAddJson(result: ForgeAddResult): Record<string, unknown> {
-  const base = buildGenerateJson(result);
+export function buildAddJson(
+  result: ForgeAddResult,
+  options: { workspaceRoot?: string } = {},
+): Record<string, unknown> {
+  const base = buildGenerateJson(result, options);
   const packageInspectName = result.packageName ?? result.alias;
   const packageNextActions =
     result.mode === "package" && packageInspectName
@@ -168,8 +232,8 @@ export function buildAddJson(result: ForgeAddResult): Record<string, unknown> {
                 "forge workos install --yes --json",
                 "forge workos doctor --json",
                 "forge workos doctor --yes --json",
-                "forge workos seed --file src/forge/_generated/integrations/workos/workos-seed.yml --json",
-                "forge workos seed --file src/forge/_generated/integrations/workos/workos-seed.yml --yes --json",
+                "forge workos seed --file workos-seed.yml --json",
+                "forge workos seed --file workos-seed.yml --yes --json",
                 "forge auth check --json",
                 "forge auth prove --json",
               ]
@@ -199,7 +263,9 @@ export function buildAddJson(result: ForgeAddResult): Record<string, unknown> {
     ...(result.installCwd ? { installCwd: result.installCwd } : {}),
     ...(result.installWorkspace ? { installWorkspace: result.installWorkspace } : {}),
     ...base,
-    nextActions: packageNextActions ?? integrationNextActions ?? base.nextActions,
+    nextActions: options.workspaceRoot
+      ? forgeCliCommandsForWorkspace(options.workspaceRoot, packageNextActions ?? integrationNextActions ?? (base.nextActions as string[]))
+      : packageNextActions ?? integrationNextActions ?? base.nextActions,
   };
 }
 
@@ -347,15 +413,31 @@ export function buildInspectJson(result: InspectResult): Record<string, unknown>
 }
 
 export function writeHumanGenerate(result: GenerateResult): void {
-  for (const path of result.changed) {
+  const changed = compactList(result.changed, 20);
+  const unchanged = compactList(result.unchanged, 20);
+  if (result.exitCode !== 0 && result.errors.length === 0 && result.changed.length > 0) {
+    console.error(`generated drift: ${result.changed.length} artifact(s) would change; run forge generate`);
+  }
+  for (const path of changed.sample) {
     console.log(`changed: ${path}`);
   }
-  for (const path of result.unchanged) {
+  if (changed.hidden > 0) {
+    console.log(`changed: ... ${changed.hidden} more`);
+  }
+  for (const path of unchanged.sample) {
     console.log(`unchanged: ${path}`);
   }
-  for (const diagnostic of [...result.warnings, ...result.errors]) {
+  if (unchanged.hidden > 0) {
+    console.log(`unchanged: ... ${unchanged.hidden} more`);
+  }
+  const diagnostics = [...result.warnings, ...result.errors];
+  const diagnosticSample = diagnostics.slice(0, 20);
+  for (const diagnostic of diagnosticSample) {
     console.error(`${diagnostic.severity} ${diagnostic.code}: ${diagnostic.message}`);
   }
+  if (diagnostics.length > diagnosticSample.length) {
+    console.error(`diagnostics: ... ${diagnostics.length - diagnosticSample.length} more`);
+  }
 }
 
 export function writeHumanAdd(result: ForgeAddResult): void {