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

package/src/forge/vue/index.ts

@@ -0,0 +1,407 @@
+import {
+  computed,
+  inject,
+  onScopeDispose,
+  provide,
+  shallowRef,
+  toValue,
+  watch,
+} from "vue";
+import type { App, InjectionKey, MaybeRefOrGetter, ShallowRef } from "vue";
+
+export type ForgeVueAuth = {
+  userId?: string;
+  tenantId?: string;
+  role?: string;
+  token?: string;
+  getToken?: () => string | Promise<string>;
+  headers?: Record<string, string>;
+  [key: string]: unknown;
+};
+
+export type ForgeVueAuthProvider =
+  | ForgeVueAuth
+  | (() => Promise<ForgeVueAuth>);
+
+export type ForgeVueClientConfig = {
+  url: string;
+  auth?: ForgeVueAuthProvider;
+};
+
+export type ForgeDevAuthConfig =
+  | boolean
+  | {
+      userId?: string;
+      tenantId?: string;
+      role?: string;
+      headers?: Record<string, string>;
+    };
+
+export type ForgeVuePluginOptions = ForgeVueClientConfig & {
+  devAuth?: ForgeDevAuthConfig;
+};
+
+export type ForgeVueError = Error & {
+  code?: string;
+  status?: number;
+  traceId?: string;
+  details?: unknown;
+};
+
+export type LiveSnapshot<T> = {
+  subscriptionId: string;
+  revision: number;
+  data: T;
+  traceId?: string;
+};
+
+export type ForgeVueClient = {
+  lastTraceId?: string;
+  query(name: string, args: unknown): Promise<unknown>;
+  command(name: string, args: unknown): Promise<unknown>;
+  liveQuery(
+    name: string,
+    args: unknown,
+    onSnapshot: (snapshot: LiveSnapshot<unknown>) => void,
+    onError?: (error: ForgeVueError) => void,
+    options?: { signal?: AbortSignal },
+  ): () => void;
+};
+
+export type UseForgeQueryOptions = {
+  enabled?: MaybeRefOrGetter<boolean>;
+};
+
+export type UseForgeQueryResult<T> = {
+  data: Readonly<ShallowRef<T | undefined>>;
+  error: Readonly<ShallowRef<ForgeVueError | null>>;
+  loading: Readonly<ShallowRef<boolean>>;
+  refetch: () => Promise<void>;
+  traceId: Readonly<ShallowRef<string | undefined>>;
+};
+
+export type UseForgeCommandOptions<TResult> = {
+  onSuccess?: (result: TResult) => void;
+  onError?: (error: ForgeVueError) => void;
+};
+
+export type UseForgeCommandResult<TArgs, TResult> = {
+  run: (args: TArgs) => Promise<TResult>;
+  loading: Readonly<ShallowRef<boolean>>;
+  error: Readonly<ShallowRef<ForgeVueError | null>>;
+  result: Readonly<ShallowRef<TResult | undefined>>;
+  traceId: Readonly<ShallowRef<string | undefined>>;
+  reset: () => void;
+};
+
+export type UseForgeLiveQueryOptions = {
+  enabled?: MaybeRefOrGetter<boolean>;
+};
+
+export type UseForgeLiveQueryResult<T> = {
+  data: Readonly<ShallowRef<T | undefined>>;
+  error: Readonly<ShallowRef<ForgeVueError | null>>;
+  loading: Readonly<ShallowRef<boolean>>;
+  connected: Readonly<ShallowRef<boolean>>;
+  revision: Readonly<ShallowRef<number | undefined>>;
+  traceId: Readonly<ShallowRef<string | undefined>>;
+  reconnect: () => void;
+};
+
+type ForgeVueContext<TClient extends ForgeVueClient> = {
+  client: TClient;
+  auth?: ForgeVueAuthProvider;
+};
+
+export type ForgeVueBindings<TClient extends ForgeVueClient = ForgeVueClient> = {
+  ForgeVuePlugin: {
+    install(app: App, options: ForgeVuePluginOptions): void;
+  };
+  provideForge: (options: ForgeVuePluginOptions) => TClient;
+  useForgeClient: () => TClient;
+  useForgeAuth: () => ForgeVueAuth | undefined;
+  useForgeQuery: <TResult = unknown>(
+    name: MaybeRefOrGetter<string>,
+    args: MaybeRefOrGetter<unknown>,
+    options?: UseForgeQueryOptions,
+  ) => UseForgeQueryResult<TResult>;
+  useForgeCommand: <TArgs = unknown, TResult = unknown>(
+    name: MaybeRefOrGetter<string>,
+    options?: UseForgeCommandOptions<TResult>,
+  ) => UseForgeCommandResult<TArgs, TResult>;
+  useForgeLiveQuery: <TResult = unknown>(
+    name: MaybeRefOrGetter<string>,
+    args: MaybeRefOrGetter<unknown>,
+    options?: UseForgeLiveQueryOptions,
+  ) => UseForgeLiveQueryResult<TResult>;
+};
+
+function stableStringify(value: unknown): string {
+  const seen = new WeakSet<object>();
+
+  function normalize(input: unknown): unknown {
+    if (input === null || typeof input !== "object") {
+      return input;
+    }
+    if (seen.has(input)) {
+      return "[Circular]";
+    }
+    seen.add(input);
+    if (Array.isArray(input)) {
+      return input.map(normalize);
+    }
+    const record = input as Record<string, unknown>;
+    return Object.keys(record)
+      .sort()
+      .reduce<Record<string, unknown>>((acc, key) => {
+        acc[key] = normalize(record[key]);
+        return acc;
+      }, {});
+  }
+
+  return JSON.stringify(normalize(value));
+}
+
+function toForgeError(error: unknown): ForgeVueError {
+  if (error instanceof Error) {
+    return error as ForgeVueError;
+  }
+  const wrapped = new Error(String(error)) as ForgeVueError;
+  wrapped.code = "FORGE_VUE_ERROR";
+  return wrapped;
+}
+
+function resolveDevAuth(devAuth: ForgeDevAuthConfig | undefined): ForgeVueAuthProvider | undefined {
+  if (!devAuth) {
+    return undefined;
+  }
+  const config = typeof devAuth === "object" ? devAuth : {};
+  return {
+    userId: config.userId ?? "dev-user",
+    tenantId: config.tenantId ?? "dev-tenant",
+    role: config.role ?? "owner",
+    headers: config.headers,
+  };
+}
+
+function readonlyRef<T>(ref: ShallowRef<T>): Readonly<ShallowRef<T>> {
+  return ref;
+}
+
+export function createForgeVueBindings<TClient extends ForgeVueClient>(
+  createForgeClient: (config: ForgeVueClientConfig) => TClient,
+): ForgeVueBindings<TClient> {
+  const forgeVueKey: InjectionKey<ForgeVueContext<TClient>> = Symbol("ForgeVue");
+
+  function createContext(options: ForgeVuePluginOptions): ForgeVueContext<TClient> {
+    const auth = options.auth ?? resolveDevAuth(options.devAuth);
+    return {
+      client: createForgeClient({ url: options.url, auth }),
+      auth,
+    };
+  }
+
+  const ForgeVuePlugin = {
+    install(app: App, options: ForgeVuePluginOptions): void {
+      app.provide(forgeVueKey, createContext(options));
+    },
+  };
+
+  function provideForge(options: ForgeVuePluginOptions): TClient {
+    const context = createContext(options);
+    provide(forgeVueKey, context);
+    return context.client;
+  }
+
+  function useContextValue(): ForgeVueContext<TClient> {
+    const value = inject(forgeVueKey);
+    if (!value) {
+      const error = new Error("useForgeClient must be used after provideForge or ForgeVuePlugin.") as ForgeVueError;
+      error.code = "FORGE_VUE_PROVIDER_MISSING";
+      throw error;
+    }
+    return value;
+  }
+
+  function useForgeClient(): TClient {
+    return useContextValue().client;
+  }
+
+  function useForgeAuth(): ForgeVueAuth | undefined {
+    const { auth } = useContextValue();
+    return typeof auth === "function" ? undefined : auth;
+  }
+
+  function useForgeQuery<TResult = unknown>(
+    name: MaybeRefOrGetter<string>,
+    args: MaybeRefOrGetter<unknown>,
+    options?: UseForgeQueryOptions,
+  ): UseForgeQueryResult<TResult> {
+    const client = useForgeClient();
+    const data = shallowRef<TResult | undefined>();
+    const error = shallowRef<ForgeVueError | null>(null);
+    const loading = shallowRef(false);
+    const traceId = shallowRef<string | undefined>();
+    const enabled = computed(() => toValue(options?.enabled ?? true) !== false);
+    const argsKey = computed(() => stableStringify(toValue(args)));
+
+    async function refetch(): Promise<void> {
+      if (!enabled.value) {
+        return;
+      }
+      loading.value = true;
+      error.value = null;
+      try {
+        data.value = (await client.query(toValue(name), toValue(args))) as TResult;
+        traceId.value = client.lastTraceId;
+      } catch (caught) {
+        error.value = toForgeError(caught);
+      } finally {
+        loading.value = false;
+      }
+    }
+
+    watch(
+      [() => toValue(name), argsKey, enabled],
+      () => {
+        void refetch();
+      },
+      { immediate: true },
+    );
+
+    return {
+      data: readonlyRef(data),
+      error: readonlyRef(error),
+      loading: readonlyRef(loading),
+      refetch,
+      traceId: readonlyRef(traceId),
+    };
+  }
+
+  function useForgeCommand<TArgs = unknown, TResult = unknown>(
+    name: MaybeRefOrGetter<string>,
+    options?: UseForgeCommandOptions<TResult>,
+  ): UseForgeCommandResult<TArgs, TResult> {
+    const client = useForgeClient();
+    const result = shallowRef<TResult | undefined>();
+    const error = shallowRef<ForgeVueError | null>(null);
+    const loading = shallowRef(false);
+    const traceId = shallowRef<string | undefined>();
+
+    async function run(args: TArgs): Promise<TResult> {
+      loading.value = true;
+      error.value = null;
+      try {
+        const value = (await client.command(toValue(name), args)) as TResult;
+        result.value = value;
+        traceId.value = client.lastTraceId;
+        options?.onSuccess?.(value);
+        return value;
+      } catch (caught) {
+        const forgeError = toForgeError(caught);
+        error.value = forgeError;
+        options?.onError?.(forgeError);
+        throw forgeError;
+      } finally {
+        loading.value = false;
+      }
+    }
+
+    function reset(): void {
+      result.value = undefined;
+      error.value = null;
+      traceId.value = undefined;
+      loading.value = false;
+    }
+
+    return {
+      run,
+      loading: readonlyRef(loading),
+      error: readonlyRef(error),
+      result: readonlyRef(result),
+      traceId: readonlyRef(traceId),
+      reset,
+    };
+  }
+
+  function useForgeLiveQuery<TResult = unknown>(
+    name: MaybeRefOrGetter<string>,
+    args: MaybeRefOrGetter<unknown>,
+    options?: UseForgeLiveQueryOptions,
+  ): UseForgeLiveQueryResult<TResult> {
+    const client = useForgeClient();
+    const data = shallowRef<TResult | undefined>();
+    const error = shallowRef<ForgeVueError | null>(null);
+    const loading = shallowRef(true);
+    const connected = shallowRef(false);
+    const revision = shallowRef<number | undefined>();
+    const traceId = shallowRef<string | undefined>();
+    const reconnectNonce = shallowRef(0);
+    const enabled = computed(() => toValue(options?.enabled ?? true) !== false);
+    const argsKey = computed(() => stableStringify(toValue(args)));
+    let unsubscribe: (() => void) | undefined;
+
+    function close(): void {
+      unsubscribe?.();
+      unsubscribe = undefined;
+      connected.value = false;
+    }
+
+    function connect(): void {
+      close();
+      if (!enabled.value) {
+        loading.value = false;
+        return;
+      }
+      loading.value = true;
+      error.value = null;
+      unsubscribe = client.liveQuery(
+        toValue(name),
+        toValue(args),
+        (snapshot) => {
+          data.value = snapshot.data as TResult;
+          revision.value = snapshot.revision;
+          traceId.value = snapshot.traceId;
+          connected.value = true;
+          loading.value = false;
+        },
+        (caught) => {
+          error.value = toForgeError(caught);
+          connected.value = false;
+          loading.value = false;
+        },
+      );
+    }
+
+    function reconnect(): void {
+      reconnectNonce.value += 1;
+    }
+
+    watch(
+      [() => toValue(name), argsKey, enabled, reconnectNonce],
+      connect,
+      { immediate: true },
+    );
+    onScopeDispose(close);
+
+    return {
+      data: readonlyRef(data),
+      error: readonlyRef(error),
+      loading: readonlyRef(loading),
+      connected: readonlyRef(connected),
+      revision: readonlyRef(revision),
+      traceId: readonlyRef(traceId),
+      reconnect,
+    };
+  }
+
+  return {
+    ForgeVuePlugin,
+    provideForge,
+    useForgeClient,
+    useForgeAuth,
+    useForgeQuery,
+    useForgeCommand,
+    useForgeLiveQuery,
+  };
+}

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

@@ -0,0 +1,209 @@
+export type ChangeType =
+  | "source"
+  | "tests"
+  | "docs"
+  | "generated"
+  | "operational"
+  | "assets"
+  | "config"
+  | "other";
+
+export type FileListSummary = {
+  count: number;
+  sample: string[];
+  hidden: number;
+};
+
+export type CategorizedFileSummary = {
+  total: FileListSummary;
+  byType: Record<ChangeType, FileListSummary>;
+  primaryTypes: ChangeType[];
+};
+
+export type DiffPlan = {
+  first: "authored";
+  then: "generated";
+  generatedCollapsedByDefault: boolean;
+  generatedFiles: number;
+  authoredFiles: number;
+  authoredDiffCommand: string;
+  generatedDiffCommand: string;
+  fullDiffCommand: string;
+  summary: string;
+};
+
+export type ChangeClassifier = (file: string) => ChangeType;
+
+export const CHANGE_TYPES: ChangeType[] = [
+  "source",
+  "tests",
+  "docs",
+  "generated",
+  "operational",
+  "assets",
+  "config",
+  "other",
+];
+
+export function compactFiles(files: string[], sampleSize = 12): FileListSummary {
+  return {
+    count: files.length,
+    sample: files.slice(0, sampleSize),
+    hidden: Math.max(0, files.length - sampleSize),
+  };
+}
+
+export function isVolatileForgeState(file: string): boolean {
+  const lower = file.replace(/\\/g, "/").replace(/^\.\//, "").toLowerCase();
+  return (
+    lower.startsWith(".forge/locks/") ||
+    lower.startsWith(".forge/pglite/") ||
+    lower.startsWith(".forge/pglite.backups/") ||
+    lower.startsWith(".forge/runtime-cache/") ||
+    lower.startsWith(".forge/test-runs/") ||
+    lower.startsWith(".forge/ui-runs/") ||
+    lower.startsWith(".forge/local/") ||
+    lower.endsWith("/postmaster.pid") ||
+    lower.endsWith("/.s.pgsql.5432.lock") ||
+    lower.endsWith("/.s.pgsql.5432.lock.out")
+  );
+}
+
+export function filterVolatileForgeState(files: string[]): string[] {
+  return files.filter((file) => !isVolatileForgeState(file));
+}
+
+export function classifyChangeType(file: string): ChangeType {
+  const normalized = file.replace(/\\/g, "/");
+  const lower = normalized.toLowerCase();
+  const basename = lower.split("/").pop() ?? lower;
+
+  if (
+    lower.startsWith("src/forge/_generated/") ||
+    lower === ".forge/agent/context.json" ||
+    lower === "forge.lock" ||
+    lower.endsWith("/forge.lock")
+  ) {
+    return "generated";
+  }
+  if (lower === ".codex/hooks.json") {
+    return "config";
+  }
+  if (
+    lower.startsWith(".forge/") ||
+    lower.startsWith(".codex/") ||
+    lower.startsWith(".claude/") ||
+    lower.startsWith(".cursor/") ||
+    lower.startsWith(".vscode/") ||
+    lower.endsWith(".log") ||
+    lower.endsWith(".pid")
+  ) {
+    return "operational";
+  }
+  if (
+    lower === "readme.md" ||
+    lower === "agents.md" ||
+    lower === "claude.md" ||
+    lower.startsWith("docs/") ||
+    lower.endsWith(".md") ||
+    lower.endsWith(".mdx")
+  ) {
+    return "docs";
+  }
+  if (
+    lower.startsWith("tests/") ||
+    lower.startsWith("test/") ||
+    lower.includes("/__tests__/") ||
+    /\.test\.[cm]?[jt]sx?$/.test(lower) ||
+    /\.spec\.[cm]?[jt]sx?$/.test(lower)
+  ) {
+    return "tests";
+  }
+  if (
+    lower.startsWith("marketing/") ||
+    lower.startsWith("public/") ||
+    lower.startsWith("assets/") ||
+    lower.startsWith("static/") ||
+    /\.(png|jpe?g|gif|webp|svg|mp4|webm|mov|ico|pdf)$/i.test(lower)
+  ) {
+    return "assets";
+  }
+  if (
+    basename === "package.json" ||
+    basename === "bun.lock" ||
+    basename === "package-lock.json" ||
+    basename === "pnpm-lock.yaml" ||
+    basename === "yarn.lock" ||
+    basename.startsWith("tsconfig") ||
+    basename.startsWith("vite.config") ||
+    basename.startsWith("next.config") ||
+    basename.startsWith("nuxt.config") ||
+    basename.startsWith("eslint.config") ||
+    basename === "mkdocs.yml" ||
+    basename === "mkdocs.yaml" ||
+    basename.startsWith("biome") ||
+    basename.startsWith("vitest.config")
+  ) {
+    return "config";
+  }
+  if (
+    lower.startsWith("src/") ||
+    lower.startsWith("web/") ||
+    lower.startsWith("templates/") ||
+    lower.startsWith("examples/") ||
+    lower.startsWith("bin/")
+  ) {
+    return "source";
+  }
+  return "other";
+}
+
+export function categorizeFiles(
+  files: string[],
+  sampleSize = 8,
+  classify: ChangeClassifier = classifyChangeType,
+): CategorizedFileSummary {
+  const sorted = [...files].sort();
+  const groups = Object.fromEntries(
+    CHANGE_TYPES.map((type) => [type, [] as string[]]),
+  ) as Record<ChangeType, string[]>;
+  for (const file of sorted) {
+    groups[classify(file)].push(file);
+  }
+  const byType = Object.fromEntries(
+    CHANGE_TYPES.map((type) => [type, compactFiles(groups[type], sampleSize)]),
+  ) as Record<ChangeType, FileListSummary>;
+  const primaryTypes = CHANGE_TYPES
+    .filter((type) => byType[type].count > 0)
+    .sort((left, right) => byType[right].count - byType[left].count);
+  return {
+    total: compactFiles(sorted, sampleSize),
+    byType,
+    primaryTypes,
+  };
+}
+
+export function summarizeChangeTypes(summary: CategorizedFileSummary): string {
+  return summary.primaryTypes
+    .slice(0, 5)
+    .map((type) => `${summary.byType[type].count} ${type}`)
+    .join(", ");
+}
+
+export function buildDiffPlanFromChangeSummary(summary: CategorizedFileSummary): DiffPlan {
+  const generatedFiles = summary.byType.generated.count;
+  const authoredFiles = Math.max(0, summary.total.count - generatedFiles);
+  return {
+    first: "authored",
+    then: "generated",
+    generatedCollapsedByDefault: generatedFiles > 0,
+    generatedFiles,
+    authoredFiles,
+    authoredDiffCommand: 'git diff -- . ":(exclude)src/forge/_generated/**" ":(exclude)forge.lock"',
+    generatedDiffCommand: 'git diff -- src/forge/_generated forge.lock AGENTS.md ":(glob)**/AGENTS.md" .forge/agent/context.json',
+    fullDiffCommand: "git diff",
+    summary: generatedFiles > 0
+      ? `${authoredFiles} authored file(s) first; ${generatedFiles} generated artifact(s) are derived and should be reviewed after the source cause.`
+      : `${authoredFiles} authored file(s); no generated artifacts changed.`,
+  };
+}

package/src/forge/workspace/forge-cli.ts

@@ -0,0 +1,14 @@
+import { join } from "node:path";
+import { nodeFileSystem } from "../compiler/fs/index.ts";
+
+export function shouldUseLocalForgeCli(workspaceRoot: string): boolean {
+  return nodeFileSystem.exists(join(workspaceRoot, "bin", "forge.mjs"));
+}
+
+export function forgeCliCommandForWorkspace(workspaceRoot: string, command: string): string {
+  return shouldUseLocalForgeCli(workspaceRoot) ? command.replace(/^forge\b/, "node bin/forge.mjs") : command;
+}
+
+export function forgeCliCommandsForWorkspace(workspaceRoot: string, commands: string[]): string[] {
+  return commands.map((command) => forgeCliCommandForWorkspace(workspaceRoot, command));
+}