forgeos 0.1.0-alpha.25 → 0.1.0-alpha.26

package/AGENTS.md

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.25 input=f4bc0a51dfadbdbabe4e7083c29844716f74c2beebcb86ce30e7a70c4f9487b4 content=0d493cf0e41b71cb652d5e0e1b0c1f83d2a1281b748321f0b00f0773ba93074e
+// @forge-generated generator=0.1.0-alpha.26 input=23c00c5407aab4088b55b49905f2b195667a75b8544fa180786ac637ee67e1e5 content=0d493cf0e41b71cb652d5e0e1b0c1f83d2a1281b748321f0b00f0773ba93074e
 # AGENTS.md
 
 <!-- forge-generated:start -->

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # forgeos
 
+## 0.1.0-alpha.26
+
+### Patch Changes
+
+- Harden the field-demo loop after the Team Onboarding app exercise.
+
+  - Let `forge changed` and `forge handoff` summarize non-git workspaces with a filesystem inventory instead of reporting zero useful changes.
+  - Keep `forge make resource` global by default unless a tenants table exists or `--tenant-scoped` is explicit.
+  - Expand capability-map table detection for aliased `ctx.db` usage.
+  - Wait through short-lived DeltaDB writer locks before reporting `FORGE_DELTA_BUSY`.
+
 ## Unreleased
 
 ## 0.1.0-alpha.25

package/docs/changelog.md

@@ -6,6 +6,15 @@ The canonical source file in the repository is `CHANGELOG.md`.
 
 ## Unreleased
 
+## 0.1.0-alpha.26
+
+- Hardened the field-demo loop after the Team Onboarding app exercise:
+  non-git workspaces now get a filesystem-backed `changed`/`handoff` summary,
+  `forge make resource` stays global unless tenant scope is explicit or already
+  modeled, capability-map extraction sees aliased `ctx.db` table usage, and
+  Agent Memory waits through short-lived DeltaDB writer locks before reporting
+  `FORGE_DELTA_BUSY`.
+
 ## 0.1.0-alpha.25
 
 - Hardened DeltaDB and Agent Memory for concurrent `forge dev` usage:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forgeos",
-  "version": "0.1.0-alpha.25",
+  "version": "0.1.0-alpha.26",
   "description": "Agent-native application framework and compiler for building Forge apps without a mandatory dashboard.",
   "type": "module",
   "license": "MIT",

package/src/forge/_generated/releaseManifest.json

@@ -1 +1 @@
-{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.25","releaseId":"forgeos@0.1.0-alpha.25+unknown","schemaVersion":"0.1.0"}
+{"defaultProvider":"local","diagnostics":[],"env":{"deployEnv":"FORGE_DEPLOY_ENV","deployId":"FORGE_DEPLOY_ID","publicReleaseId":"NEXT_PUBLIC_FORGE_RELEASE_ID","releaseId":"FORGE_RELEASE_ID"},"gitSha":"unknown","optionalProviders":["local","sentry-compatible","sentry","glitchtip","bugsink","otel","custom"],"packageName":"forgeos","packageVersion":"0.1.0-alpha.26","releaseId":"forgeos@0.1.0-alpha.26+unknown","schemaVersion":"0.1.0"}

package/src/forge/_generated/releaseManifest.ts

@@ -1,4 +1,4 @@
-// @forge-generated generator=0.1.0-alpha.25 input=f4bc0a51dfadbdbabe4e7083c29844716f74c2beebcb86ce30e7a70c4f9487b4 content=a7c5e9f36b973e9b5a51716753739f57a63fa77c68b0fad18f059b5407aa58fe
+// @forge-generated generator=0.1.0-alpha.26 input=23c00c5407aab4088b55b49905f2b195667a75b8544fa180786ac637ee67e1e5 content=967d4e05aa540b3e3d843fa6ed4516658ab4c364c1d8c42a14f36c57b75dff71
 export const releaseManifest = {
   "defaultProvider": "local",
   "diagnostics": [],
@@ -19,7 +19,7 @@ export const releaseManifest = {
     "custom"
   ],
   "packageName": "forgeos",
-  "packageVersion": "0.1.0-alpha.25",
-  "releaseId": "forgeos@0.1.0-alpha.25+unknown",
+  "packageVersion": "0.1.0-alpha.26",
+  "releaseId": "forgeos@0.1.0-alpha.26+unknown",
   "schemaVersion": "0.1.0"
 } as const;

package/src/forge/agent-memory/bridge.ts

@@ -116,7 +116,10 @@ async function openMemoryStore(
   const retryDelays = access === "write" ? [25, 75, 150] : [];
   for (let attempt = 0; ; attempt += 1) {
     try {
-      return await DeltaStore.open(workspaceRoot, { access });
+      return await DeltaStore.open(workspaceRoot, {
+        access,
+        ...(access === "write" ? { waitMs: 1_500, retryDelayMs: 50 } : {}),
+      });
     } catch (error) {
       if (!(error instanceof DeltaStoreBusyError) || attempt >= retryDelays.length) {
         return memoryUnavailable(error, workspaceRoot);

package/src/forge/cli/changed.ts

@@ -82,8 +82,7 @@ function buildRisks(git: WorkspaceGitSummary): string[] {
   const risks: string[] = [];
   const changed = git.changeSummary.changed;
   if (!git.available) {
-    risks.push("git status is unavailable; changed-file analysis may be incomplete");
-    return risks;
+    risks.push("git status is unavailable; using filesystem inventory as untracked-file analysis");
   }
   if (git.untracked.count > 0) {
     risks.push(`${git.untracked.count} untracked file(s) are not in git history`);
@@ -103,7 +102,7 @@ function buildRisks(git: WorkspaceGitSummary): string[] {
 
 function buildRecommendedCommands(git: WorkspaceGitSummary): string[] {
   if (!git.available) {
-    return ["git status --short", "forge status --json"];
+    return ["forge status --json", "forge handoff --json", "git init"];
   }
   if (git.changeSummary.changed.total.count === 0) {
     return ["forge status --json", "forge dev --once --json"];
@@ -202,12 +201,13 @@ export function runChangedCommand(workspaceRoot: string, options: { authoredOnly
   const reviewFocus = buildReviewFocus(humanChanges, viewDerivedChanges);
   const generatedExplanation = buildGeneratedChangeExplanation(humanChanges, viewDerivedChanges);
   const diffPlan: DiffPlan = buildDiffPlanFromChangeSummary(viewChanged);
+  const ok = git.available || git.source === "filesystem";
 
   return {
-    ok: git.available,
+    ok,
     data: {
       schemaVersion: "0.1.0",
-      ok: git.available,
+      ok,
       summary: {
         branch: git.branch,
         commit: git.commit,
@@ -223,6 +223,7 @@ export function runChangedCommand(workspaceRoot: string, options: { authoredOnly
       },
       git: {
         available: git.available,
+        source: git.source,
         ...(git.error ? { error: git.error } : {}),
         branch: git.branch,
         commit: git.commit,
@@ -240,7 +241,7 @@ export function runChangedCommand(workspaceRoot: string, options: { authoredOnly
       recommendedCommands,
       nextActions: recommendedCommands,
     },
-    exitCode: git.available ? 0 : 1,
+    exitCode: ok ? 0 : 1,
   };
 }
 

package/src/forge/cli/handoff.ts

@@ -140,6 +140,7 @@ function buildOpeningBrief(input: {
 }): string {
   const agent = input.dev.summary.agentContext;
   const changedByType = summarizeChangeTypes(input.git.changeSummary.changed);
+  const changedFiles = Math.max(agent.changedFiles, input.git.changed.count);
   const tests = input.recentRuns.test
     ? input.recentRuns.test.ok
       ? "last test run passed"
@@ -150,7 +151,7 @@ function buildOpeningBrief(input: {
     : "no blocking issues";
   return [
     `ForgeOS handoff: ${input.dev.ok ? "dev diagnostics are clean" : "dev diagnostics need attention"}.`,
-    `${agent.changedFiles} changed file(s)${changedByType ? `: ${changedByType}` : ""}; ${input.git.staged.count} staged, ${input.git.untracked.count} untracked.`,
+    `${changedFiles} changed file(s)${changedByType ? `: ${changedByType}` : ""}; ${input.git.staged.count} staged, ${input.git.untracked.count} untracked.`,
     `${tests}; ${blockers}.`,
     `Next command: ${input.dev.summary.primaryAction?.command ?? input.dev.nextActions[0]?.command ?? "forge dev"}.`,
   ].join(" ");
@@ -168,6 +169,7 @@ export async function runHandoffCommand(options: HandoffCommandOptions): Promise
   const agent = dev.summary.agentContext;
   const risks = [
     ...agent.blockingIssues,
+    ...(!git.available ? ["git status is unavailable; using filesystem inventory as untracked-file analysis"] : []),
     ...(git.untracked.count > 0 ? [`${git.untracked.count} untracked file(s) are not in git history`] : []),
     ...(recentRuns.test && !recentRuns.test.ok ? ["last test run failed"] : []),
     ...(recentRuns.ui && !recentRuns.ui.ok ? ["last UI run failed"] : []),
@@ -181,6 +183,7 @@ export async function runHandoffCommand(options: HandoffCommandOptions): Promise
     agent.blockingIssues.length === 0 &&
     (!recentRuns.test || recentRuns.test.ok) &&
     (!recentRuns.ui || recentRuns.ui.ok);
+  const changedFiles = Math.max(agent.changedFiles, git.changed.count);
 
   return {
     schemaVersion: "0.1.0",
@@ -192,7 +195,7 @@ export async function runHandoffCommand(options: HandoffCommandOptions): Promise
       generatedChanged: agent.generatedChanged,
       generatedChangedFiles: agent.generatedChangedFiles,
       frontendReady: agent.frontendReady,
-      changedFiles: agent.changedFiles,
+      changedFiles,
       stagedFiles: git.staged.count,
       unstagedFiles: git.unstaged.count,
       untrackedFiles: git.untracked.count,

package/src/forge/compiler/agent-contract/build.ts

@@ -186,6 +186,38 @@ function sourceText(workspaceRoot: string, file: string | undefined): string {
   return nodeFileSystem.readText(absolute) ?? "";
 }
 
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function addDbAliasesForText(
+  text: string,
+  tableNames: Set<string>,
+  aliases: Map<string, string>,
+): void {
+  for (const match of text.matchAll(
+    /\b(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*ctx\.db(?:\.([A-Za-z_$][A-Za-z0-9_$]*)|\[\s*["'`]([^"'`]+)["'`]\s*\])/g,
+  )) {
+    const alias = match[1] ?? "";
+    const table = match[2] ?? match[3] ?? "";
+    if (alias && tableNames.has(table)) {
+      aliases.set(alias, table);
+    }
+  }
+
+  for (const match of text.matchAll(/\b(?:const|let|var)\s*\{([^}]+)\}\s*=\s*ctx\.db/g)) {
+    const body = match[1] ?? "";
+    for (const part of body.split(",")) {
+      const [rawTable, rawAlias] = part.split(":").map((value) => value.trim());
+      const table = rawTable?.replace(/["'`]/g, "") ?? "";
+      const alias = (rawAlias ?? rawTable ?? "").replace(/\s*=.*$/, "").trim();
+      if (tableNames.has(table) && alias) {
+        aliases.set(alias, table);
+      }
+    }
+  }
+}
+
 function dbTablesForText(
   text: string,
   tableNames: Set<string>,
@@ -199,6 +231,24 @@ function dbTablesForText(
       tables.push(table);
     }
   }
+  for (const match of text.matchAll(/ctx\.db\s*\[\s*["'`]([^"'`]+)["'`]\s*\]\s*\.\s*([A-Za-z_$][A-Za-z0-9_$]*)/g)) {
+    const table = match[1] ?? "";
+    const op = match[2] ?? "";
+    if (tableNames.has(table) && ops.has(op)) {
+      tables.push(table);
+    }
+  }
+  const aliases = new Map<string, string>();
+  addDbAliasesForText(text, tableNames, aliases);
+  for (const [alias, table] of aliases) {
+    const aliasPattern = new RegExp(`\\b${escapeRegExp(alias)}\\s*\\.\\s*([A-Za-z_$][A-Za-z0-9_$]*)`, "g");
+    for (const match of text.matchAll(aliasPattern)) {
+      const op = match[1] ?? "";
+      if (ops.has(op)) {
+        tables.push(table);
+      }
+    }
+  }
   return uniqueSorted(tables);
 }
 

package/src/forge/delta/recorder.ts

@@ -407,7 +407,7 @@ const DELTA_STORE_RETRY_DELAYS_MS = [25, 75, 150];
 async function openDeltaStoreWithRetry(workspaceRoot: string): Promise<DeltaStore> {
   for (let attempt = 0; ; attempt += 1) {
     try {
-      return await DeltaStore.open(workspaceRoot);
+      return await DeltaStore.open(workspaceRoot, { waitMs: 1_500, retryDelayMs: 50 });
     } catch (error) {
       if (!(error instanceof DeltaStoreBusyError) || attempt >= DELTA_STORE_RETRY_DELAYS_MS.length) {
         throw error;

package/src/forge/delta/store.ts

@@ -348,6 +348,12 @@ interface DeltaStoreLock {
   token: string;
 }
 
+export interface DeltaStoreOpenOptions {
+  access?: DeltaStoreAccess;
+  waitMs?: number;
+  retryDelayMs?: number;
+}
+
 function getDeltaLockPath(workspaceRoot: string): string {
   return join(workspaceRoot, ".forge", "delta", "delta.lock");
 }
@@ -488,6 +494,33 @@ function acquireDeltaStoreLock(workspaceRoot: string): DeltaStoreLock {
   throw new DeltaStoreBusyError(lockPath, readLockHolder(lockPath));
 }
 
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function acquireDeltaStoreLockWithWait(
+  workspaceRoot: string,
+  options: { waitMs?: number; retryDelayMs?: number } = {},
+): Promise<DeltaStoreLock> {
+  const waitMs = Math.max(0, options.waitMs ?? 0);
+  const retryDelayMs = Math.max(10, options.retryDelayMs ?? 50);
+  const started = Date.now();
+  for (;;) {
+    try {
+      return acquireDeltaStoreLock(workspaceRoot);
+    } catch (error) {
+      if (!(error instanceof DeltaStoreBusyError)) {
+        throw error;
+      }
+      const elapsed = Date.now() - started;
+      if (elapsed >= waitMs) {
+        throw error;
+      }
+      await sleep(Math.min(retryDelayMs, waitMs - elapsed));
+    }
+  }
+}
+
 export function probeDeltaStoreBusy(workspaceRoot: string): DeltaStoreBusyError | null {
   const lockPath = getDeltaLockPath(workspaceRoot);
   if (!existsSync(lockPath)) {
@@ -551,11 +584,11 @@ export class DeltaStore {
     private readonly lock: DeltaStoreLock | null,
   ) {}
 
-  static async open(workspaceRoot: string, options: { access?: DeltaStoreAccess } = {}): Promise<DeltaStore> {
+  static async open(workspaceRoot: string, options: DeltaStoreOpenOptions = {}): Promise<DeltaStore> {
     const storePath = getDeltaStorePath(workspaceRoot);
     mkdirSync(dirname(storePath), { recursive: true });
     const initializedBeforeOpen = deltaStoreInitialized(storePath);
-    const lock = options.access === "read" ? null : acquireDeltaStoreLock(workspaceRoot);
+    const lock = options.access === "read" ? null : await acquireDeltaStoreLockWithWait(workspaceRoot, options);
     let store: DeltaStore | null = null;
     try {
       const adapter = await createPgliteAdapter(storePath);
@@ -565,7 +598,7 @@ export class DeltaStore {
       } else if (await store.needsSchemaInit()) {
         await store.close();
         store = null;
-        const migrateLock = acquireDeltaStoreLock(workspaceRoot);
+        const migrateLock = await acquireDeltaStoreLockWithWait(workspaceRoot, options);
         try {
           const migrateAdapter = await createPgliteAdapter(storePath);
           store = new DeltaStore(workspaceRoot, storePath, migrateAdapter, migrateLock);

package/src/forge/make/index.ts

@@ -200,6 +200,13 @@ function chooseSchemaFile(workspaceRoot: string): string {
   return "src/forge/schema.ts";
 }
 
+function schemaHasTenantsTable(workspaceRoot: string): boolean {
+  const schema = readIfExists(workspaceRoot, chooseSchemaFile(workspaceRoot)) ?? "";
+  return schema.includes('name: "tenants"') ||
+    schema.includes("name: 'tenants'") ||
+    /\btenants\s*=\s*(?:defineTable|table)\s*\(/.test(schema);
+}
+
 function choosePolicyFile(workspaceRoot: string): string {
   if (fileExists(workspaceRoot, "src/policies.ts")) {
     return "src/policies.ts";
@@ -551,6 +558,8 @@ function buildIntent(options: MakeCommandOptions): {
     kind === "command"
       ? actionName?.replace(/^(create|update|delete)/, "") || "create"
       : "read";
+  const tenantScoped =
+    options.tenantScoped || (kind === "resource" && schemaHasTenantsTable(options.workspaceRoot));
 
   return {
     diagnostics,
@@ -560,7 +569,7 @@ function buildIntent(options: MakeCommandOptions): {
       table,
       field: fieldOptions.field,
       fields,
-      tenantScoped: options.tenantScoped || kind === "resource",
+      tenantScoped,
       crud: options.withCrud || kind === "resource",
       liveQuery: options.withLiveQuery || kind === "resource" || kind === "livequery",
       react:
@@ -898,7 +907,7 @@ function buildPlan(options: MakeCommandOptions): MakePlan {
     kind: "resource" as const,
     name: options.name ?? "resource",
     fields: [],
-    tenantScoped: true,
+    tenantScoped: false,
     crud: true,
     liveQuery: true,
     react: true,

package/src/forge/version.ts

@@ -1,3 +1,3 @@
-export const FORGEOS_VERSION = "0.1.0-alpha.25";
+export const FORGEOS_VERSION = "0.1.0-alpha.26";
 export const GENERATOR_VERSION = FORGEOS_VERSION;
 export const CLI_VERSION = FORGEOS_VERSION;

package/src/forge/workspace/git-summary.ts

@@ -1,6 +1,7 @@
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { readdirSync, readFileSync } from "node:fs";
+import { join, relative } from "node:path";
+import { normalizePath } from "../compiler/primitives/paths.ts";
 import {
   categorizeFiles,
   classifyChangeType,
@@ -13,6 +14,7 @@ import {
 
 export interface WorkspaceGitSummary {
   available: boolean;
+  source?: "git" | "filesystem";
   branch?: string;
   commit?: string;
   changed: FileListSummary;
@@ -28,18 +30,64 @@ export interface WorkspaceGitSummary {
   error?: string;
 }
 
-function emptySummary(error?: string): WorkspaceGitSummary {
+const FALLBACK_IGNORED_DIRS = new Set([
+  ".git",
+  "node_modules",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".nuxt",
+  ".turbo",
+  ".cache",
+]);
+
+function listWorkspaceFiles(root: string): string[] {
+  const files: string[] = [];
+  const visit = (dir: string): void => {
+    let entries: Array<{ name: string; isDirectory: () => boolean; isFile: () => boolean }> = [];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.isDirectory() && FALLBACK_IGNORED_DIRS.has(entry.name)) {
+        continue;
+      }
+      const absolute = join(dir, entry.name);
+      const rel = normalizePath(relative(root, absolute));
+      if (!rel || rel === ".") {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        visit(absolute);
+        continue;
+      }
+      if (entry.isFile()) {
+        files.push(rel);
+      }
+    }
+  };
+  visit(root);
+  return filterVolatileForgeState(files).sort();
+}
+
+function filesystemSummary(workspaceRoot: string, error?: string): WorkspaceGitSummary {
+  const files = listWorkspaceFiles(workspaceRoot);
+  const classify = workspaceChangeClassifier(workspaceRoot);
   return {
     available: false,
-    changed: compactFiles([]),
+    source: "filesystem",
+    changed: compactFiles(files),
     staged: compactFiles([]),
     unstaged: compactFiles([]),
-    untracked: compactFiles([]),
+    untracked: compactFiles(files),
     changeSummary: {
-      changed: categorizeFiles([]),
+      changed: categorizeFiles(files, 8, classify),
       staged: categorizeFiles([]),
       unstaged: categorizeFiles([]),
-      untracked: categorizeFiles([]),
+      untracked: categorizeFiles(files, 8, classify),
     },
     ...(error ? { error } : {}),
   };
@@ -227,7 +275,7 @@ function parseStatusPath(line: string): string {
 export function buildWorkspaceGitSummary(workspaceRoot: string): WorkspaceGitSummary {
   const root = runGit(["rev-parse", "--show-toplevel"], workspaceRoot);
   if (!root.ok) {
-    return emptySummary(root.error);
+    return filesystemSummary(workspaceRoot, root.error);
   }
 
   const status = runGit(["status", "--porcelain=v1", "-uall"], workspaceRoot, { trim: false });
@@ -262,6 +310,7 @@ export function buildWorkspaceGitSummary(workspaceRoot: string): WorkspaceGitSum
 
   return {
     available: true,
+    source: "git",
     ...(branch.ok ? { branch: branch.stdout } : {}),
     ...(commit.ok ? { commit: commit.stdout } : {}),
     changed: compactFiles(changedFiles),