forgeos 0.1.0-alpha.0 → 0.1.0-alpha.2

package/src/forge/compiler/app-graph/parser.ts

@@ -1,119 +1,119 @@
-import Parser from "tree-sitter";
-import TypeScript from "tree-sitter-typescript";
-import { createDiagnostic } from "../diagnostics/create.ts";
-import type { Diagnostic } from "../types/diagnostic.ts";
-import type { ForgeSymbol, SourceFile } from "../types/app-graph.ts";
-import { normalizePath } from "../primitives/paths.ts";
-import { extractSymbolsFromTree } from "./extract.ts";
-import type { ParseInvalidationKey, RawSymbol } from "./types.ts";
-import { parseInvalidationKeyEquals } from "./types.ts";
-
-const tsParser = new Parser();
-tsParser.setLanguage(TypeScript.typescript as unknown as Parser.Language);
-
-const tsxParser = new Parser();
-tsxParser.setLanguage(TypeScript.tsx as unknown as Parser.Language);
-
-function parserForFile(path: string): Parser {
-  return path.endsWith(".tsx") ? tsxParser : tsParser;
-}
-
-function priorSymbolsToRaw(symbols: ForgeSymbol[]): RawSymbol[] {
-  return symbols.map((symbol) => ({
-    kind: symbol.kind,
-    name: symbol.name,
-    qualifiedName: symbol.qualifiedName,
-    file: symbol.file,
-    span: symbol.span,
-    exportPath:
-      typeof symbol.meta.exportPath === "string" ? symbol.meta.exportPath : "",
-    sourceSlice:
-      typeof symbol.meta.sourceSlice === "string" ? symbol.meta.sourceSlice : "",
-  }));
-}
-
-function groupPriorSymbolsByFile(
-  priorSymbols: ForgeSymbol[],
-): Map<string, ForgeSymbol[]> {
-  const byFile = new Map<string, ForgeSymbol[]>();
-  for (const symbol of priorSymbols) {
-    const list = byFile.get(symbol.file) ?? [];
-    list.push(symbol);
-    byFile.set(symbol.file, list);
-  }
-  return byFile;
-}
-
-function priorFileContentHash(
-  priorSymbols: ForgeSymbol[],
-  file: string,
-): string | undefined {
-  const match = priorSymbols.find((symbol) => symbol.file === file);
-  if (!match) {
-    return undefined;
-  }
-  // All symbols from the same file share the same slice hash basis; use meta when present.
-  const fromMeta = match.meta.fileContentHash;
-  return typeof fromMeta === "string" ? fromMeta : undefined;
-}
-
-export interface IncrementalParseResult {
-  symbols: RawSymbol[];
-  diagnostics: Diagnostic[];
-}
-
-export function incrementalParse(
-  sources: SourceFile[],
-  priorSymbols: ForgeSymbol[] | undefined,
-  priorInvalidation: ParseInvalidationKey | undefined,
-  currentInvalidation: ParseInvalidationKey,
-): IncrementalParseResult {
-  const diagnostics: Diagnostic[] = [];
-  const allSymbols: RawSymbol[] = [];
-  const globalInvalidated =
-    priorInvalidation === undefined ||
-    !parseInvalidationKeyEquals(priorInvalidation, currentInvalidation);
-
-  const priorByFile = priorSymbols
-    ? groupPriorSymbolsByFile(priorSymbols)
-    : new Map<string, ForgeSymbol[]>();
-
-  for (const source of sources) {
-    const normalizedFile = normalizePath(source.path);
-    const priorForFile = priorByFile.get(normalizedFile);
-    const priorHash = priorSymbols
-      ? priorFileContentHash(priorSymbols, normalizedFile)
-      : undefined;
-
-    const fileUnchanged =
-      !globalInvalidated &&
-      priorForFile !== undefined &&
-      priorHash === source.contentHash;
-
-    if (fileUnchanged) {
-      allSymbols.push(...priorSymbolsToRaw(priorForFile));
-      continue;
-    }
-
-    try {
-      const tree = parserForFile(normalizedFile).parse(source.text);
-      const extracted = extractSymbolsFromTree(
-        tree.rootNode,
-        normalizedFile,
-        source.text,
-      );
-      allSymbols.push(...extracted);
-    } catch {
-      diagnostics.push(
-        createDiagnostic({
-          severity: "warning",
-          code: "FORGE_UNPARSEABLE_FILE",
-          message: `cannot parse source file: ${normalizedFile}`,
-          file: normalizedFile,
-        }),
-      );
-    }
-  }
-
-  return { symbols: allSymbols, diagnostics };
-}
+import Parser from "tree-sitter";
+import TypeScript from "tree-sitter-typescript";
+import { createDiagnostic } from "../diagnostics/create.ts";
+import type { Diagnostic } from "../types/diagnostic.ts";
+import type { ForgeSymbol, SourceFile } from "../types/app-graph.ts";
+import { normalizePath } from "../primitives/paths.ts";
+import { extractSymbolsFromTree } from "./extract.ts";
+import type { ParseInvalidationKey, RawSymbol } from "./types.ts";
+import { parseInvalidationKeyEquals } from "./types.ts";
+
+const tsParser = new Parser();
+tsParser.setLanguage(TypeScript.typescript as unknown as Parser.Language);
+
+const tsxParser = new Parser();
+tsxParser.setLanguage(TypeScript.tsx as unknown as Parser.Language);
+
+function parserForFile(path: string): Parser {
+  return path.endsWith(".tsx") ? tsxParser : tsParser;
+}
+
+function priorSymbolsToRaw(symbols: ForgeSymbol[]): RawSymbol[] {
+  return symbols.map((symbol) => ({
+    kind: symbol.kind,
+    name: symbol.name,
+    qualifiedName: symbol.qualifiedName,
+    file: symbol.file,
+    span: symbol.span,
+    exportPath:
+      typeof symbol.meta.exportPath === "string" ? symbol.meta.exportPath : "",
+    sourceSlice:
+      typeof symbol.meta.sourceSlice === "string" ? symbol.meta.sourceSlice : "",
+  }));
+}
+
+function groupPriorSymbolsByFile(
+  priorSymbols: ForgeSymbol[],
+): Map<string, ForgeSymbol[]> {
+  const byFile = new Map<string, ForgeSymbol[]>();
+  for (const symbol of priorSymbols) {
+    const list = byFile.get(symbol.file) ?? [];
+    list.push(symbol);
+    byFile.set(symbol.file, list);
+  }
+  return byFile;
+}
+
+function priorFileContentHash(
+  priorSymbols: ForgeSymbol[],
+  file: string,
+): string | undefined {
+  const match = priorSymbols.find((symbol) => symbol.file === file);
+  if (!match) {
+    return undefined;
+  }
+  // All symbols from the same file share the same slice hash basis; use meta when present.
+  const fromMeta = match.meta.fileContentHash;
+  return typeof fromMeta === "string" ? fromMeta : undefined;
+}
+
+export interface IncrementalParseResult {
+  symbols: RawSymbol[];
+  diagnostics: Diagnostic[];
+}
+
+export function incrementalParse(
+  sources: SourceFile[],
+  priorSymbols: ForgeSymbol[] | undefined,
+  priorInvalidation: ParseInvalidationKey | undefined,
+  currentInvalidation: ParseInvalidationKey,
+): IncrementalParseResult {
+  const diagnostics: Diagnostic[] = [];
+  const allSymbols: RawSymbol[] = [];
+  const globalInvalidated =
+    priorInvalidation === undefined ||
+    !parseInvalidationKeyEquals(priorInvalidation, currentInvalidation);
+
+  const priorByFile = priorSymbols
+    ? groupPriorSymbolsByFile(priorSymbols)
+    : new Map<string, ForgeSymbol[]>();
+
+  for (const source of sources) {
+    const normalizedFile = normalizePath(source.path);
+    const priorForFile = priorByFile.get(normalizedFile);
+    const priorHash = priorSymbols
+      ? priorFileContentHash(priorSymbols, normalizedFile)
+      : undefined;
+
+    const fileUnchanged =
+      !globalInvalidated &&
+      priorForFile !== undefined &&
+      priorHash === source.contentHash;
+
+    if (fileUnchanged) {
+      allSymbols.push(...priorSymbolsToRaw(priorForFile));
+      continue;
+    }
+
+    try {
+      const tree = parserForFile(normalizedFile).parse(source.text);
+      const extracted = extractSymbolsFromTree(
+        tree.rootNode,
+        normalizedFile,
+        source.text,
+      );
+      allSymbols.push(...extracted);
+    } catch {
+      diagnostics.push(
+        createDiagnostic({
+          severity: "warning",
+          code: "FORGE_UNPARSEABLE_FILE",
+          message: `cannot parse source file: ${normalizedFile}`,
+          file: normalizedFile,
+        }),
+      );
+    }
+  }
+
+  return { symbols: allSymbols, diagnostics };
+}

package/src/forge/compiler/app-graph/symbols.ts

@@ -1,48 +1,48 @@
-import { deriveStableSymbolId, hashStable } from "../primitives/hash.ts";
-import type { ForgeSymbol } from "../types/app-graph.ts";
-import type { SourceFile } from "../types/app-graph.ts";
-import type { RawSymbol } from "./types.ts";
-
-export function rawToForgeSymbol(
-  raw: RawSymbol,
-  fileContentHash: string,
-): ForgeSymbol {
-  const id = deriveStableSymbolId({
-    kind: raw.kind,
-    canonicalModulePath: raw.file,
-    qualifiedName: raw.qualifiedName,
-    exportPath: raw.exportPath,
-  });
-
-  const slice = raw.sourceSlice || "";
-  const contentHash = slice.length > 0 ? hashStable(slice) : fileContentHash;
-
-  return {
-    id,
-    kind: raw.kind,
-    name: raw.name,
-    qualifiedName: raw.qualifiedName,
-    file: raw.file,
-    span: raw.span,
-    contentHash,
-    meta: {
-      exportPath: raw.exportPath,
-      fileContentHash,
-      ...(slice.length > 0 ? { sourceSlice: slice } : {}),
-    },
-  };
-}
-
-export function buildForgeSymbols(
-  rawSymbols: RawSymbol[],
-  sources: SourceFile[],
-): ForgeSymbol[] {
-  const hashByFile = new Map<string, string>();
-  for (const source of sources) {
-    hashByFile.set(source.path, source.contentHash);
-  }
-
-  return rawSymbols.map((raw) =>
-    rawToForgeSymbol(raw, hashByFile.get(raw.file) ?? ""),
-  );
-}
+import { deriveStableSymbolId, hashStable } from "../primitives/hash.ts";
+import type { ForgeSymbol } from "../types/app-graph.ts";
+import type { SourceFile } from "../types/app-graph.ts";
+import type { RawSymbol } from "./types.ts";
+
+export function rawToForgeSymbol(
+  raw: RawSymbol,
+  fileContentHash: string,
+): ForgeSymbol {
+  const id = deriveStableSymbolId({
+    kind: raw.kind,
+    canonicalModulePath: raw.file,
+    qualifiedName: raw.qualifiedName,
+    exportPath: raw.exportPath,
+  });
+
+  const slice = raw.sourceSlice || "";
+  const contentHash = slice.length > 0 ? hashStable(slice) : fileContentHash;
+
+  return {
+    id,
+    kind: raw.kind,
+    name: raw.name,
+    qualifiedName: raw.qualifiedName,
+    file: raw.file,
+    span: raw.span,
+    contentHash,
+    meta: {
+      exportPath: raw.exportPath,
+      fileContentHash,
+      ...(slice.length > 0 ? { sourceSlice: slice } : {}),
+    },
+  };
+}
+
+export function buildForgeSymbols(
+  rawSymbols: RawSymbol[],
+  sources: SourceFile[],
+): ForgeSymbol[] {
+  const hashByFile = new Map<string, string>();
+  for (const source of sources) {
+    hashByFile.set(source.path, source.contentHash);
+  }
+
+  return rawSymbols.map((raw) =>
+    rawToForgeSymbol(raw, hashByFile.get(raw.file) ?? ""),
+  );
+}

package/src/forge/compiler/app-graph/tsconfig-hash.ts

@@ -1,62 +1,62 @@
-import ts from "typescript";
-import { canonicalJson } from "../primitives/serialize.ts";
-import { hashStable } from "../primitives/hash.ts";
-
-const RELEVANT_COMPILER_OPTIONS: (keyof ts.CompilerOptions)[] = [
-  "baseUrl",
-  "paths",
-  "module",
-  "moduleResolution",
-  "target",
-  "jsx",
-  "allowJs",
-  "resolveJsonModule",
-  "esModuleInterop",
-  "strict",
-  "rootDir",
-  "outDir",
-];
-
-export function hashTsCompilerOptions(options: ts.CompilerOptions): string {
-  const relevant: Record<string, unknown> = {};
-  for (const key of RELEVANT_COMPILER_OPTIONS) {
-    const value = options[key];
-    if (value !== undefined) {
-      relevant[key] = value;
-    }
-  }
-  return hashStable(canonicalJson(relevant));
-}
-
-export function loadTsconfig(
-  workspaceRoot: string,
-  tsconfigPath?: string,
-): ts.ParsedCommandLine {
-  const configPath =
-    tsconfigPath ?? ts.findConfigFile(workspaceRoot, ts.sys.fileExists, "tsconfig.json");
-
-  if (!configPath) {
-    return {
-      options: {},
-      fileNames: [],
-      errors: [],
-    };
-  }
-
-  const read = ts.readConfigFile(configPath, ts.sys.readFile);
-  return ts.parseJsonConfigFileContent(
-    read.config,
-    ts.sys,
-    workspaceRoot,
-    undefined,
-    configPath,
-  );
-}
-
-export function hashTsconfigForWorkspace(
-  workspaceRoot: string,
-  tsconfigPath?: string,
-): string {
-  const parsed = loadTsconfig(workspaceRoot, tsconfigPath);
-  return hashTsCompilerOptions(parsed.options);
-}
+import ts from "typescript";
+import { canonicalJson } from "../primitives/serialize.ts";
+import { hashStable } from "../primitives/hash.ts";
+
+const RELEVANT_COMPILER_OPTIONS: (keyof ts.CompilerOptions)[] = [
+  "baseUrl",
+  "paths",
+  "module",
+  "moduleResolution",
+  "target",
+  "jsx",
+  "allowJs",
+  "resolveJsonModule",
+  "esModuleInterop",
+  "strict",
+  "rootDir",
+  "outDir",
+];
+
+export function hashTsCompilerOptions(options: ts.CompilerOptions): string {
+  const relevant: Record<string, unknown> = {};
+  for (const key of RELEVANT_COMPILER_OPTIONS) {
+    const value = options[key];
+    if (value !== undefined) {
+      relevant[key] = value;
+    }
+  }
+  return hashStable(canonicalJson(relevant));
+}
+
+export function loadTsconfig(
+  workspaceRoot: string,
+  tsconfigPath?: string,
+): ts.ParsedCommandLine {
+  const configPath =
+    tsconfigPath ?? ts.findConfigFile(workspaceRoot, ts.sys.fileExists, "tsconfig.json");
+
+  if (!configPath) {
+    return {
+      options: {},
+      fileNames: [],
+      errors: [],
+    };
+  }
+
+  const read = ts.readConfigFile(configPath, ts.sys.readFile);
+  return ts.parseJsonConfigFileContent(
+    read.config,
+    ts.sys,
+    workspaceRoot,
+    undefined,
+    configPath,
+  );
+}
+
+export function hashTsconfigForWorkspace(
+  workspaceRoot: string,
+  tsconfigPath?: string,
+): string {
+  const parsed = loadTsconfig(workspaceRoot, tsconfigPath);
+  return hashTsCompilerOptions(parsed.options);
+}

package/src/forge/compiler/app-graph/types.ts

@@ -1,43 +1,43 @@
-import type { ForgeKind } from "../types/app-graph.ts";
-import { APP_GRAPH_ANALYZER_VERSION } from "./versions.ts";
-
-/** Symbol extracted from tree-sitter before stable-id assignment. */
-export interface RawSymbol {
-  kind: ForgeKind;
-  name: string;
-  qualifiedName: string;
-  file: string;
-  span: { start: number; end: number };
-  exportPath: string;
-  sourceSlice: string;
-}
-
-/** Factors that invalidate cached per-file parse results. */
-export interface ParseInvalidationKey {
-  schemaVersion: string;
-  grammarVersion: string;
-  classifierVersion: string;
-  tsconfigHash: string;
-}
-
-export function parseInvalidationKeyEquals(
-  a: ParseInvalidationKey,
-  b: ParseInvalidationKey,
-): boolean {
-  return (
-    a.schemaVersion === b.schemaVersion &&
-    a.grammarVersion === b.grammarVersion &&
-    a.classifierVersion === b.classifierVersion &&
-    a.tsconfigHash === b.tsconfigHash
-  );
-}
-
-export function buildAnalyzerVersion(key: ParseInvalidationKey): string {
-  return [
-    APP_GRAPH_ANALYZER_VERSION,
-    `schema:${key.schemaVersion}`,
-    `grammar:${key.grammarVersion}`,
-    `classifier:${key.classifierVersion}`,
-    `tsconfig:${key.tsconfigHash}`,
-  ].join("+");
-}
+import type { ForgeKind } from "../types/app-graph.ts";
+import { APP_GRAPH_ANALYZER_VERSION } from "./versions.ts";
+
+/** Symbol extracted from tree-sitter before stable-id assignment. */
+export interface RawSymbol {
+  kind: ForgeKind;
+  name: string;
+  qualifiedName: string;
+  file: string;
+  span: { start: number; end: number };
+  exportPath: string;
+  sourceSlice: string;
+}
+
+/** Factors that invalidate cached per-file parse results. */
+export interface ParseInvalidationKey {
+  schemaVersion: string;
+  grammarVersion: string;
+  classifierVersion: string;
+  tsconfigHash: string;
+}
+
+export function parseInvalidationKeyEquals(
+  a: ParseInvalidationKey,
+  b: ParseInvalidationKey,
+): boolean {
+  return (
+    a.schemaVersion === b.schemaVersion &&
+    a.grammarVersion === b.grammarVersion &&
+    a.classifierVersion === b.classifierVersion &&
+    a.tsconfigHash === b.tsconfigHash
+  );
+}
+
+export function buildAnalyzerVersion(key: ParseInvalidationKey): string {
+  return [
+    APP_GRAPH_ANALYZER_VERSION,
+    `schema:${key.schemaVersion}`,
+    `grammar:${key.grammarVersion}`,
+    `classifier:${key.classifierVersion}`,
+    `tsconfig:${key.tsconfigHash}`,
+  ].join("+");
+}

package/src/forge/compiler/app-graph/versions.ts

@@ -1,14 +1,14 @@
-/** AppGraph model schema version. */
-export const APP_GRAPH_SCHEMA_VERSION = "1.0.0";
-
-/** AppGraph analyzer / classifier toolchain version. */
-export const APP_GRAPH_ANALYZER_VERSION = "0.1.0";
-
-/** tree-sitter-typescript grammar package version (invalidates parse cache). */
-export const TREE_SITTER_GRAMMAR_VERSION = "0.23.2";
-
-/** Forge builder API → ForgeKind classifier version. */
-export const FORGE_CLASSIFIER_VERSION = "0.1.1";
-
-/** Generation orchestrator version (recorded on emitted AppGraph). */
-export const GENERATOR_VERSION = "0.0.0";
+/** AppGraph model schema version. */
+export const APP_GRAPH_SCHEMA_VERSION = "1.0.0";
+
+/** AppGraph analyzer / classifier toolchain version. */
+export const APP_GRAPH_ANALYZER_VERSION = "0.1.0";
+
+/** tree-sitter-typescript grammar package version (invalidates parse cache). */
+export const TREE_SITTER_GRAMMAR_VERSION = "0.23.2";
+
+/** Forge builder API → ForgeKind classifier version. */
+export const FORGE_CLASSIFIER_VERSION = "0.1.1";
+
+/** Generation orchestrator version (recorded on emitted AppGraph). */
+export { GENERATOR_VERSION } from "../../version.ts";

package/src/forge/compiler/cache/index.ts

@@ -1,17 +1,17 @@
-export {
-  buildPackageCacheKey,
-  serializePackageCacheKey,
-  fingerprintPackageCacheKey,
-  cacheKeysEqual,
-  lockfileHashAffectsCache,
-} from "./key.ts";
-export {
-  PackageCacheStore,
-  forgeCacheDiscardedMessage,
-} from "./store.ts";
-export type { CacheEntry } from "./store.ts";
-export {
-  runWithConcurrency,
-  runWithConcurrencyTracked,
-  ConcurrencyTracker,
-} from "./scheduler.ts";
+export {
+  buildPackageCacheKey,
+  serializePackageCacheKey,
+  fingerprintPackageCacheKey,
+  cacheKeysEqual,
+  lockfileHashAffectsCache,
+} from "./key.ts";
+export {
+  PackageCacheStore,
+  forgeCacheDiscardedMessage,
+} from "./store.ts";
+export type { CacheEntry } from "./store.ts";
+export {
+  runWithConcurrency,
+  runWithConcurrencyTracked,
+  ConcurrencyTracker,
+} from "./scheduler.ts";