forgeos 0.1.0-alpha.2 → 0.1.0-alpha.20

package/src/forge/compiler/classifier/signals.ts

@@ -15,6 +15,64 @@ export interface PackageSignals {
   nativeAddonEvidence: string[];
 }
 
+export interface SignalProfile {
+  calls: number;
+  totalMs: number;
+  entrypoints: number;
+  exports: number;
+  textFragments: number;
+  corpusBytes: number;
+  packageCount: number;
+  topPackages: SignalPackageProfile[];
+}
+
+export interface SignalPackageProfile {
+  packageName: string;
+  calls: number;
+  totalMs: number;
+  entrypoints: number;
+  exports: number;
+  textFragments: number;
+  corpusBytes: number;
+}
+
+let activeProfile: SignalProfile | undefined;
+let activePackageProfiles: Map<string, SignalPackageProfile> | undefined;
+
+export function resetSignalProfile(): void {
+  activeProfile = {
+    calls: 0,
+    totalMs: 0,
+    entrypoints: 0,
+    exports: 0,
+    textFragments: 0,
+    corpusBytes: 0,
+    packageCount: 0,
+    topPackages: [],
+  };
+  activePackageProfiles = new Map();
+}
+
+export function getSignalProfile(): SignalProfile | undefined {
+  if (!activeProfile) {
+    return undefined;
+  }
+  const topPackages = [...(activePackageProfiles?.values() ?? [])]
+    .sort((a, b) => b.totalMs - a.totalMs)
+    .slice(0, 10)
+    .map((entry) => ({ ...entry }));
+  return {
+    ...activeProfile,
+    packageCount: activePackageProfiles?.size ?? 0,
+    topPackages,
+  };
+}
+
+export function clearSignalProfile(): void {
+  activeProfile = undefined;
+  activePackageProfiles = undefined;
+}
+
 const NODE_BUILTIN_PATTERNS = [
   /\bnode:/,
   /\brequire\s*\(\s*["'](?:fs|child_process|net|http|https|dns|tls|os|crypto)["']/,
@@ -89,9 +147,12 @@ function collectEnvVars(text: string): string[] {
 }
 
 export function gatherSignals(api: PackageApi): PackageSignals {
+  const started = activeProfile ? performance.now() : 0;
   const texts: string[] = [];
+  let exportCount = 0;
   for (const ep of api.entrypoints) {
     for (const exp of ep.exports) {
+      exportCount += 1;
       texts.push(exp.signature);
       if (exp.overloads) texts.push(...exp.overloads);
       if (exp.declarations) texts.push(...exp.declarations);
@@ -112,7 +173,7 @@ export function gatherSignals(api: PackageApi): PackageSignals {
   const nativeAddonEvidence = collectMatches(corpus, NATIVE_ADDON_PATTERNS);
   const envVars = collectEnvVars(corpus);
 
-  return {
+  const result = {
     usesNodeBuiltins: nodeBuiltins.length > 0,
     nodeBuiltins,
     usesNetwork: networkEvidence.length > 0,
@@ -126,4 +187,33 @@ export function gatherSignals(api: PackageApi): PackageSignals {
     usesNativeAddon: nativeAddonEvidence.length > 0,
     nativeAddonEvidence,
   };
+
+  if (activeProfile) {
+    const durationMs = performance.now() - started;
+    activeProfile.calls += 1;
+    activeProfile.totalMs += durationMs;
+    activeProfile.entrypoints += api.entrypoints.length;
+    activeProfile.exports += exportCount;
+    activeProfile.textFragments += texts.length;
+    activeProfile.corpusBytes += corpus.length;
+
+    const packageProfile = activePackageProfiles?.get(api.name) ?? {
+      packageName: api.name,
+      calls: 0,
+      totalMs: 0,
+      entrypoints: 0,
+      exports: 0,
+      textFragments: 0,
+      corpusBytes: 0,
+    };
+    packageProfile.calls += 1;
+    packageProfile.totalMs += durationMs;
+    packageProfile.entrypoints += api.entrypoints.length;
+    packageProfile.exports += exportCount;
+    packageProfile.textFragments += texts.length;
+    packageProfile.corpusBytes += corpus.length;
+    activePackageProfiles?.set(api.name, packageProfile);
+  }
+
+  return result;
 }

package/src/forge/compiler/client-sdk/build-manifest.ts

@@ -16,11 +16,17 @@ export interface ClientManifest {
     queries: string;
     commands: string;
     liveQueries: string;
+    externalQueries: string;
+    externalCommands: string;
   };
   react: {
     entrypoint: string;
     hooks: string[];
   };
+  vue: {
+    entrypoint: string;
+    composables: string[];
+  };
   excluded: {
     actions: string[];
     workflows: string[];
@@ -41,6 +47,18 @@ export interface ReactManifest {
   clientSafe: true;
 }
 
+export interface VueManifest {
+  schemaVersion: string;
+  generatorVersion: string;
+  inputHash: string;
+  entrypoint: string;
+  composables: string[];
+  queries: string[];
+  commands: string[];
+  liveQueries: string[];
+  clientSafe: true;
+}
+
 const SERVER_ADAPTER_SUFFIX = ".server.ts";
 
 function collectServerAdapters(classified: ClassifiedPackage[]): string[] {
@@ -101,6 +119,8 @@ export function buildClientManifest(
       queries: "POST /queries/:name",
       commands: "POST /commands/:name",
       liveQueries: "GET /live/:name",
+      externalQueries: "POST /external/:service/queries/:name",
+      externalCommands: "POST /external/:service/commands/:name",
     },
     react: {
       entrypoint: "src/forge/_generated/react.ts",
@@ -113,6 +133,17 @@ export function buildClientManifest(
         "useLiveQuery",
       ],
     },
+    vue: {
+      entrypoint: "src/forge/_generated/vue.ts",
+      composables: [
+        "provideForge",
+        "useForgeClient",
+        "useForgeAuth",
+        "useForgeQuery",
+        "useForgeCommand",
+        "useForgeLiveQuery",
+      ],
+    },
     excluded: {
       actions,
       workflows,
@@ -149,3 +180,31 @@ export function buildReactManifest(clientManifest: ClientManifest): ReactManifes
     clientSafe: true,
   };
 }
+
+export function buildVueManifest(clientManifest: ClientManifest): VueManifest {
+  const composables = [
+    "provideForge",
+    "useForgeClient",
+    "useForgeAuth",
+    "useForgeQuery",
+    "useForgeCommand",
+    "useForgeLiveQuery",
+  ];
+
+  return {
+    schemaVersion: "1.0.0",
+    generatorVersion: GENERATOR_VERSION,
+    inputHash: hashStable(
+      canonicalJson({
+        clientInputHash: clientManifest.inputHash,
+        composables,
+      }),
+    ),
+    entrypoint: "src/forge/_generated/vue.ts",
+    composables,
+    queries: clientManifest.queries,
+    commands: clientManifest.commands,
+    liveQueries: clientManifest.liveQueries,
+    clientSafe: true,
+  };
+}

package/src/forge/compiler/client-sdk/render-client.ts

@@ -1,4 +1,4 @@
-import type { ClientManifest, ReactManifest } from "./build-manifest.ts";
+import type { ClientManifest, ReactManifest, VueManifest } from "./build-manifest.ts";
 
 export function renderClientTypesTs(): string {
   return `export type ForgeStaticAuth = {
@@ -52,6 +52,22 @@ export class ForgeError extends Error {
 export type QueryName = keyof typeof import("./api.ts").api.queries;
 export type CommandName = keyof typeof import("./api.ts").api.commands;
 export type LiveQueryName = keyof typeof import("./api.ts").api.liveQueries;
+export type ExternalCommandName = string;
+export type ExternalQueryName = string;
+export type ExternalRuntimeRefObject = {
+  service: string;
+  name: string;
+  kind?: "command" | "query";
+  language?: string;
+  framework?: string;
+  transport?: string;
+};
+export type ExternalCommandRef =
+  | ExternalCommandName
+  | ExternalRuntimeRefObject;
+export type ExternalQueryRef =
+  | ExternalQueryName
+  | ExternalRuntimeRefObject;
 
 export type LiveSnapshot<T> = {
   subscriptionId: string;
@@ -70,6 +86,8 @@ export type ForgeClient = {
   readonly lastTraceId?: string;
   query<Name extends QueryName>(name: Name, args: unknown): Promise<unknown>;
   command<Name extends CommandName>(name: Name, args: unknown): Promise<unknown>;
+  externalQuery<Name extends ExternalQueryRef>(name: Name, args: unknown): Promise<unknown>;
+  externalCommand<Name extends ExternalCommandRef>(name: Name, args: unknown): Promise<unknown>;
   liveQuery<Name extends LiveQueryName>(
     name: Name,
     args: unknown,
@@ -87,6 +105,8 @@ import type {
   ForgeAuthProvider,
   ForgeClient,
   ForgeClientConfig,
+  ExternalCommandRef,
+  ExternalQueryRef,
   LiveQueryOptions,
   LiveSnapshot,
 } from "./clientTypes.ts";
@@ -102,6 +122,11 @@ export type {
   QueryName,
   CommandName,
   LiveQueryName,
+  ExternalCommandName,
+  ExternalQueryName,
+  ExternalRuntimeRefObject,
+  ExternalCommandRef,
+  ExternalQueryRef,
   ForgeResolvedAuth,
   LiveQueryOptions,
   LiveSnapshot,
@@ -179,6 +204,16 @@ function parseJsonPayload(body: unknown): {
   };
 }
 
+function normalizeExternalRef(
+  ref: ExternalCommandRef | ExternalQueryRef,
+): { service: string; name: string } {
+  if (typeof ref === "string") {
+    const [service, ...entryParts] = ref.split(".");
+    return { service: service ?? "", name: entryParts.join(".") };
+  }
+  return { service: ref.service, name: ref.name };
+}
+
 class ForgeHttpClient implements ForgeClient {
   lastTraceId?: string;
 
@@ -192,6 +227,14 @@ class ForgeHttpClient implements ForgeClient {
     return this.invoke("commands", name, args);
   }
 
+  externalQuery(name: ExternalQueryRef, args: unknown): Promise<unknown> {
+    return this.invokeExternal("queries", name, args);
+  }
+
+  externalCommand(name: ExternalCommandRef, args: unknown): Promise<unknown> {
+    return this.invokeExternal("commands", name, args);
+  }
+
   liveQuery(
     name: string,
     args: unknown,
@@ -268,6 +311,68 @@ class ForgeHttpClient implements ForgeClient {
     return payload.result;
   }
 
+  private async invokeExternal(
+    kind: "queries" | "commands",
+    name: ExternalCommandRef | ExternalQueryRef,
+    args: unknown,
+  ): Promise<unknown> {
+    const normalized = normalizeExternalRef(name);
+    const serviceName = normalized.service;
+    const entryName = normalized.name;
+    if (!serviceName || !entryName) {
+      throw new ForgeError(\`External runtime name must be service.entry\`, {
+        code: "FORGE_EXTERNAL_RUNTIME_NOT_FOUND",
+      });
+    }
+    const baseUrl = this.config.url.replace(/\\/$/, "");
+    const url = \`\${baseUrl}/external/\${encodeURIComponent(serviceName)}/\${kind}/\${encodeURIComponent(entryName)}\`;
+    return this.invokeUrl(url, args);
+  }
+
+  private async invokeUrl(url: string, args: unknown): Promise<unknown> {
+    const authHeaders = await resolveAuthHeaders(this.config.auth);
+
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...authHeaders,
+      },
+      body: JSON.stringify({ args }),
+    });
+
+    let body: unknown;
+    try {
+      body = await response.json();
+    } catch {
+      throw new ForgeError(\`HTTP \${response.status}\`, {
+        code: "FORGE_HTTP_ERROR",
+        status: response.status,
+      });
+    }
+
+    const payload = parseJsonPayload(body);
+    this.lastTraceId = payload.traceId;
+
+    if (!response.ok || payload.ok === false) {
+      const diagnostic = payload.diagnostics?.find((entry) => entry.code);
+      const code =
+        payload.error?.code ?? diagnostic?.code ?? "FORGE_REQUEST_FAILED";
+      const message =
+        payload.error?.message ??
+        diagnostic?.message ??
+        \`Request failed with status \${response.status}\`;
+      throw new ForgeError(message, {
+        code,
+        traceId: payload.traceId,
+        status: response.status,
+        details: payload.error?.details ?? payload.diagnostics,
+      });
+    }
+
+    return payload.result;
+  }
+
   private async openLiveQuery(
     name: string,
     args: unknown,
@@ -297,19 +402,24 @@ class ForgeHttpClient implements ForgeClient {
     const reader = response.body.getReader();
     let buffer = "";
 
-    while (!signal.aborted) {
-      const { done, value } = await reader.read();
-      if (done) {
-        break;
-      }
-      buffer += decoder.decode(value, { stream: true });
-      let boundary = buffer.indexOf("\\n\\n");
-      while (boundary !== -1) {
-        const frame = buffer.slice(0, boundary);
-        buffer = buffer.slice(boundary + 2);
-        this.handleSseFrame(frame, onSnapshot, onError);
-        boundary = buffer.indexOf("\\n\\n");
+    try {
+      while (!signal.aborted) {
+        const { done, value } = await reader.read();
+        if (done) {
+          break;
+        }
+        buffer += decoder.decode(value, { stream: true });
+        let boundary = buffer.indexOf("\\n\\n");
+        while (boundary !== -1) {
+          const frame = buffer.slice(0, boundary);
+          buffer = buffer.slice(boundary + 2);
+          this.handleSseFrame(frame, onSnapshot, onError);
+          boundary = buffer.indexOf("\\n\\n");
+        }
       }
+    } finally {
+      await reader.cancel().catch(() => undefined);
+      reader.releaseLock();
     }
   }
 
@@ -430,3 +540,68 @@ export declare const useLiveQuery: import("forge/react").ForgeReactBindings["use
 export function renderReactManifestTs(manifest: ReactManifest): string {
   return `export const reactManifest = ${JSON.stringify(manifest, null, 2)} as const;\n`;
 }
+
+export function renderVueTs(): string {
+  return `import { createForgeVueBindings } from "forge/vue";
+import { createForgeClient } from "./client.ts";
+
+export type {
+  ForgeDevAuthConfig,
+  ForgeVueAuth,
+  ForgeVueAuthProvider,
+  ForgeVueBindings,
+  ForgeVueClient,
+  ForgeVueClientConfig,
+  ForgeVueError,
+  ForgeVuePluginOptions,
+  UseForgeCommandOptions,
+  UseForgeCommandResult,
+  UseForgeLiveQueryOptions,
+  UseForgeLiveQueryResult,
+  UseForgeQueryOptions,
+  UseForgeQueryResult,
+} from "forge/vue";
+
+const forgeVue = createForgeVueBindings(createForgeClient);
+
+export const ForgeVuePlugin = forgeVue.ForgeVuePlugin;
+export const provideForge = forgeVue.provideForge;
+export const useForgeClient = forgeVue.useForgeClient;
+export const useForgeAuth = forgeVue.useForgeAuth;
+export const useForgeQuery = forgeVue.useForgeQuery;
+export const useForgeCommand = forgeVue.useForgeCommand;
+export const useForgeLiveQuery = forgeVue.useForgeLiveQuery;
+`;
+}
+
+export function renderVueDts(): string {
+  return `export type {
+  ForgeDevAuthConfig,
+  ForgeVueAuth,
+  ForgeVueAuthProvider,
+  ForgeVueBindings,
+  ForgeVueClient,
+  ForgeVueClientConfig,
+  ForgeVueError,
+  ForgeVuePluginOptions,
+  UseForgeCommandOptions,
+  UseForgeCommandResult,
+  UseForgeLiveQueryOptions,
+  UseForgeLiveQueryResult,
+  UseForgeQueryOptions,
+  UseForgeQueryResult,
+} from "forge/vue";
+
+export declare const ForgeVuePlugin: import("forge/vue").ForgeVueBindings["ForgeVuePlugin"];
+export declare const provideForge: import("forge/vue").ForgeVueBindings["provideForge"];
+export declare const useForgeClient: import("forge/vue").ForgeVueBindings["useForgeClient"];
+export declare const useForgeAuth: import("forge/vue").ForgeVueBindings["useForgeAuth"];
+export declare const useForgeQuery: import("forge/vue").ForgeVueBindings["useForgeQuery"];
+export declare const useForgeCommand: import("forge/vue").ForgeVueBindings["useForgeCommand"];
+export declare const useForgeLiveQuery: import("forge/vue").ForgeVueBindings["useForgeLiveQuery"];
+`;
+}
+
+export function renderVueManifestTs(manifest: VueManifest): string {
+  return `export const vueManifest = ${JSON.stringify(manifest, null, 2)} as const;\n`;
+}

package/src/forge/compiler/data-graph/parse.ts

@@ -36,7 +36,7 @@ function unwrapStringLiteral(node: SyntaxNode): string | null {
   return null;
 }
 
-function extractFieldsFromObject(objectNode: SyntaxNode): DataField[] {
+function extractFieldsFromObject(objectNode: SyntaxNode, options: { skipConfigName?: boolean } = {}): DataField[] {
   const fields: DataField[] = [];
 
   for (const child of objectNode.namedChildren) {
@@ -55,7 +55,7 @@ function extractFieldsFromObject(objectNode: SyntaxNode): DataField[] {
         ? keyNode.text
         : unwrapStringLiteral(keyNode);
 
-    if (!key || key === "name") {
+    if (!key || (options.skipConfigName && key === "name")) {
       continue;
     }
 
@@ -131,7 +131,7 @@ function parseCallArguments(callNode: SyntaxNode): ParsedDefineTable | null {
 
   if (first.type === "object") {
     const tableName = extractNameFromObject(first);
-    const fields = extractFieldsFromObject(first);
+    const fields = extractFieldsFromObject(first, { skipConfigName: true });
     return { tableName, fields };
   }
 

package/src/forge/compiler/data-graph/sql/ddl.ts

@@ -42,6 +42,61 @@ function stableSortTables(tables: DataTable[]): DataTable[] {
   return [...tables].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
 }
 
+function stableSortTableChangesByReferences(tables: SqlChange[]): SqlChange[] {
+  const orderedInput = [...tables].sort((a, b) => {
+    const tableA = a.table ?? "";
+    const tableB = b.table ?? "";
+    return tableA < tableB ? -1 : tableA > tableB ? 1 : 0;
+  });
+  const byName = new Map<string, SqlChange>();
+
+  for (const table of orderedInput) {
+    if (table.table) {
+      byName.set(table.table, table);
+    }
+  }
+
+  const pending = new Set(byName.keys());
+  const emitted = new Set<string>();
+  const ordered: SqlChange[] = [];
+
+  while (pending.size > 0) {
+    let progressed = false;
+
+    for (const tableName of pending) {
+      const table = byName.get(tableName);
+      if (!table) {
+        pending.delete(tableName);
+        continue;
+      }
+
+      const dependencies = (table.columns ?? [])
+        .map((column) => column.references?.table)
+        .filter((dependency): dependency is string => Boolean(dependency))
+        .filter((dependency) => dependency !== tableName && byName.has(dependency));
+
+      if (dependencies.every((dependency) => emitted.has(dependency))) {
+        ordered.push(table);
+        emitted.add(tableName);
+        pending.delete(tableName);
+        progressed = true;
+      }
+    }
+
+    if (!progressed) {
+      for (const tableName of pending) {
+        const table = byName.get(tableName);
+        if (table) {
+          ordered.push(table);
+        }
+      }
+      break;
+    }
+  }
+
+  return ordered;
+}
+
 function parseFieldType(
   field: DataField,
   tableName: string,
@@ -254,6 +309,7 @@ function buildTableChange(table: DataTable, diagnostics: Diagnostic[]): SqlChang
   return {
     kind: "create_table",
     table: tableName,
+    accessName: table.name,
     columns,
     sql: buildCreateTableSql(tableName, columns),
   };
@@ -342,6 +398,8 @@ export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
     }
   }
 
+  const orderedTables = stableSortTableChangesByReferences(tables);
+
   indexes.sort((a, b) => {
     const nameA = a.index?.name ?? "";
     const nameB = b.index?.name ?? "";
@@ -364,7 +422,7 @@ export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
   const payload = {
     schemaVersion: SQL_PLAN_SCHEMA_VERSION,
     systemTables: systemTables.map((change) => change.sql),
-    tables: tables.map((change) => change.sql),
+    tables: orderedTables.map((change) => change.sql),
     indexes: indexes.map((change) => change.sql),
   };
 
@@ -376,7 +434,7 @@ export function buildSqlPlan(dataGraph: DataGraph): SqlPlan {
     migrationId,
     checksum,
     systemTables,
-    tables,
+    tables: orderedTables,
     indexes,
     diagnostics: diagnostics.sort((a, b) => {
       const fileA = a.file ?? "";

package/src/forge/compiler/data-graph/sql/serialize.ts

@@ -15,6 +15,7 @@ export function serializeSqlPlanJson(plan: SqlPlan): string {
     tables: plan.tables.map((change) => ({
       kind: change.kind,
       table: change.table,
+      accessName: change.accessName,
       columns: change.columns,
       sql: change.sql,
     })),
@@ -69,6 +70,9 @@ export function buildTableMap(
         ? { tenantScoped: true, tenantIdColumn }
         : {}),
     };
+    if (change.accessName && change.accessName !== change.table) {
+      map[change.accessName] = map[change.table]!;
+    }
   }
 
   return map;

package/src/forge/compiler/data-graph/sql/types.ts

@@ -21,6 +21,7 @@ export interface IndexDef {
 export interface SqlChange {
   kind: "create_table" | "create_index" | "create_sequence";
   table?: string;
+  accessName?: string;
   columns?: ColumnDef[];
   index?: IndexDef;
   sql: string;

package/src/forge/compiler/dev-manifest/build.ts

@@ -61,6 +61,9 @@ function buildRoutes(
     { method: "GET", path: "/health", purpose: "health" },
     { method: "GET", path: "/entries", purpose: "entries" },
     { method: "GET", path: "/queries", purpose: "queries" },
+    { method: "POST", path: "/ai/agents/chat", purpose: "ai-agent-chat" },
+    { method: "POST", path: "/ai/agents/run", purpose: "ai-agent-run" },
+    { method: "GET", path: "/ai/providers", purpose: "ai-providers" },
     { method: "GET", path: "/workflows", purpose: "workflows" },
     { method: "GET", path: "/workflows/runs", purpose: "workflow-runs" },
     { method: "POST", path: "/workflows/process", purpose: "workflow-process" },