forgeos 0.1.0-alpha.7 → 0.1.0-alpha.70

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";
@@ -8,7 +8,7 @@ import { run as runGenerate } from "../compiler/orchestrator/run.ts";
 import { resolvePackageManagerArgv } from "../compiler/package-manager/executor.ts";
 import { moduleDir } from "../platform/module.ts";
 
-export type NewTemplateName = "b2b-support-web" | "minimal-web";
+export type NewTemplateName = "agent-workroom" | "b2b-support-web" | "minimal-web" | "nuxt-web" | "vendor-access";
 export type NewPackageManager = "bun" | "npm" | "pnpm" | "yarn";
 
 export interface NewCommandOptions {
@@ -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;
@@ -40,12 +46,30 @@ export interface NewCommandResult {
   nextSteps: string[];
 }
 
+export function installArgsFor(
+  packageManager: NewPackageManager,
+  platform: NodeJS.Platform = process.platform,
+): string[] {
+  if (packageManager === "yarn") return ["install", "--no-immutable"];
+  if (packageManager === "bun" && platform === "win32") {
+    return ["install", "--backend=copyfile"];
+  }
+  return ["install"];
+}
+
 const REQUIRED_GITIGNORE_PATHS = [
   "src/forge/_generated/",
   "forge.lock",
+  ".codex/",
   ".forge/cache/",
   ".forge/pglite/",
+  ".forge/delta/",
+  ".forge/agent/",
+  ".forge/agent/*.ndjson",
+  ".forge/agent/*.history",
+  ".forge/last-run.json",
   ".forge/local/",
+  ".forge/runtime-cache/",
   ".forge/test-cache/",
   ".forge/test-runs/",
   ".forge/ui-runs/",
@@ -55,6 +79,8 @@ const REQUIRED_GITIGNORE_PATHS = [
   ".forge/reviews/",
   ".forge/impact/",
   ".forge/agent-adapters/",
+  ".forge/studio/",
+  ".workos-seed-state.json",
 ] as const;
 
 const DEFAULT_FORGE_PACKAGE_SPEC = "npm:forgeos@alpha";
@@ -64,6 +90,7 @@ const TEXT_EXTENSIONS = new Set([
   ".css",
   ".env",
   ".example",
+  ".html",
   ".json",
   ".md",
   ".ts",
@@ -148,11 +175,11 @@ function packageManagerSpec(packageManager: string): string {
     case "bun":
       return "bun@1.3.14";
     case "npm":
-      return "npm@10.9.0";
+      return "npm@11.19.0";
     case "pnpm":
-      return "pnpm@9.15.4";
+      return "pnpm@10.34.5";
     case "yarn":
-      return "yarn@4.6.0";
+      return "yarn@4.18.0";
     default:
       return packageManager;
   }
@@ -191,12 +218,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)
@@ -376,6 +440,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,
@@ -393,6 +458,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,
@@ -401,15 +467,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,
@@ -417,29 +486,50 @@ 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),
   );
 
   let installed = false;
   if (options.install) {
-    const installCode = await spawnCommand(options.packageManager, ["install"], targetDir);
+    const installArgs = installArgsFor(options.packageManager);
+    const installCode = await spawnCommand(options.packageManager, installArgs, targetDir);
     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,
@@ -468,12 +558,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,
@@ -489,26 +580,72 @@ 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: "generate-workos", command: options.packageManager, args: ["run", "forge", "--", "generate"] },
+      { name: "authmd", command: options.packageManager, args: ["run", "forge", "--", "authmd", "generate", "--json"] },
+      { name: "authmd-check", command: options.packageManager, args: ["run", "forge", "--", "authmd", "check", "--json"] },
+      { name: "workos-doctor", command: options.packageManager, args: ["run", "forge", "--", "workos", "doctor", "--json"] },
+      { name: "workos-seed", command: options.packageManager, args: ["run", "forge", "--", "workos", "seed", "--file", "workos-seed.yml", "--dry-run", "--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,
   };
 }
@@ -520,6 +657,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."]
       : [
@@ -531,3 +675,11 @@ export function formatNewHuman(result: NewCommandResult): string {
     "",
   ].join("\n");
 }
+
+export function formatNewJson(result: NewCommandResult): string {
+  return `${JSON.stringify({
+    schemaVersion: "0.1.0",
+    ok: result.exitCode === 0,
+    ...result,
+  }, null, 2)}\n`;
+}

package/src/forge/cli/next-actions.ts

@@ -0,0 +1,23 @@
+export function uniqueNextActions(actions: string[]): string[] {
+  return [...new Set(actions)].filter(Boolean);
+}
+
+export function releasePrepareNextActions(): string[] {
+  return ["forge release prepare --env production", "forge release check --json"];
+}
+
+export function releaseReadyNextActions(): string[] {
+  return ["forge artifacts verify --json", "forge sourcemaps check --json"];
+}
+
+export function selfHostPrepareNextActions(): string[] {
+  return ["forge self-host compose", "forge self-host env", "forge self-host check --json"];
+}
+
+export function selfHostReadyNextActions(): string[] {
+  return ["docker compose -f deploy/docker-compose.yml config", "forge release prepare --env production"];
+}
+
+export function docsReadyNextActions(): string[] {
+  return ["bun test tests/docs/readthedocs.test.ts", "mkdocs build --strict"];
+}