forgeos 0.1.0-alpha.65 → 0.1.0-alpha.67

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

@@ -1,59 +1,59 @@
 import path from "node:path";
 import ts from "typescript";
-import { compareBytes } from "../primitives/compare.ts";
-import { hashStable } from "../primitives/hash.ts";
-import { normalizePath } from "../primitives/paths.ts";
-import { stableSortStrings } from "../primitives/sort.ts";
-import type {
-  AppGraph,
-  ImportKind,
-  LocalImport,
-  ModuleGraph,
-  ModuleNode,
-  PackageImport,
-  SourceFile,
-} from "../types/app-graph.ts";
+import { compareBytes } from "../primitives/compare.ts";
+import { hashStable } from "../primitives/hash.ts";
+import { normalizePath } from "../primitives/paths.ts";
+import { stableSortStrings } from "../primitives/sort.ts";
+import type {
+  AppGraph,
+  ImportKind,
+  LocalImport,
+  ModuleGraph,
+  ModuleNode,
+  PackageImport,
+  SourceFile,
+} from "../types/app-graph.ts";
 import type { RuntimeContext } from "../types/runtime.ts";
 import { FORGE_KIND_TO_CONTEXT } from "./forge-apis.ts";
 import type { RawSymbol } from "./types.ts";
-
-export function moduleIdForFile(file: string): string {
-  return hashStable(normalizePath(file));
-}
-
-export function parsePackageSpecifier(
-  specifier: string,
-): { packageName: string; subpath: string } | null {
-  if (
-    specifier.startsWith(".") ||
-    specifier.startsWith("/") ||
-    specifier.startsWith("node:")
-  ) {
-    return null;
-  }
-
-  const parts = specifier.split("/");
-  if (specifier.startsWith("@") && parts.length >= 2) {
-    return {
-      packageName: `${parts[0]}/${parts[1]}`,
-      subpath: parts.length > 2 ? `/${parts.slice(2).join("/")}` : "",
-    };
-  }
-
-  return {
-    packageName: parts[0] ?? specifier,
-    subpath: parts.length > 1 ? `/${parts.slice(1).join("/")}` : "",
-  };
-}
-
-function compareModuleNodes(a: ModuleNode, b: ModuleNode): number {
-  return compareBytes(a.id, b.id);
-}
-
-function stableSortModuleNodes(nodes: ModuleNode[]): ModuleNode[] {
-  return [...nodes].sort(compareModuleNodes);
-}
-
+
+export function moduleIdForFile(file: string): string {
+  return hashStable(normalizePath(file));
+}
+
+export function parsePackageSpecifier(
+  specifier: string,
+): { packageName: string; subpath: string } | null {
+  if (
+    specifier.startsWith(".") ||
+    specifier.startsWith("/") ||
+    specifier.startsWith("node:")
+  ) {
+    return null;
+  }
+
+  const parts = specifier.split("/");
+  if (specifier.startsWith("@") && parts.length >= 2) {
+    return {
+      packageName: `${parts[0]}/${parts[1]}`,
+      subpath: parts.length > 2 ? `/${parts.slice(2).join("/")}` : "",
+    };
+  }
+
+  return {
+    packageName: parts[0] ?? specifier,
+    subpath: parts.length > 1 ? `/${parts.slice(1).join("/")}` : "",
+  };
+}
+
+function compareModuleNodes(a: ModuleNode, b: ModuleNode): number {
+  return compareBytes(a.id, b.id);
+}
+
+function stableSortModuleNodes(nodes: ModuleNode[]): ModuleNode[] {
+  return [...nodes].sort(compareModuleNodes);
+}
+
 function declaredContextsForFile(
   file: string,
   contextsByFile: Map<string, RuntimeContext[]>,
@@ -78,16 +78,16 @@ function buildDeclaredContextsByFile(symbols: RawSymbol[]): Map<string, RuntimeC
   }
   return byFile;
 }
-
-function spanFromNode(node: ts.Node, sourceFile: ts.SourceFile): {
-  start: number;
-  end: number;
-} {
-  const start = node.getStart(sourceFile);
-  const end = node.getEnd();
-  return { start, end };
-}
-
+
+function spanFromNode(node: ts.Node, sourceFile: ts.SourceFile): {
+  start: number;
+  end: number;
+} {
+  const start = node.getStart(sourceFile);
+  const end = node.getEnd();
+  return { start, end };
+}
+
 function resolveLocalTarget(
   specifier: string,
   fromFile: string,
@@ -115,15 +115,15 @@ function resolveLocalTarget(
 
   return candidates.find((candidate) => sourcePaths.has(candidate)) ?? null;
 }
-
+
 function collectImports(
   sourceFile: ts.SourceFile,
   sourcePaths: Set<string>,
 ): { packageImports: PackageImport[]; localImports: LocalImport[] } {
-  const packageImports: PackageImport[] = [];
-  const localImports: LocalImport[] = [];
-  const fromFile = normalizePath(sourceFile.fileName);
-
+  const packageImports: PackageImport[] = [];
+  const localImports: LocalImport[] = [];
+  const fromFile = normalizePath(sourceFile.fileName);
+
   function recordPackageImport(
     specifier: string,
     parsed: { packageName: string; subpath: string },
@@ -132,17 +132,17 @@ function collectImports(
   ): void {
     packageImports.push({
       specifier,
-      packageName: parsed.packageName,
-      subpath: parsed.subpath,
-      span,
-      importKind,
-    });
-  }
-
-  function visit(node: ts.Node): void {
-    if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
-      if (ts.isStringLiteral(node.moduleSpecifier)) {
-        const specifier = node.moduleSpecifier.text;
+      packageName: parsed.packageName,
+      subpath: parsed.subpath,
+      span,
+      importKind,
+    });
+  }
+
+  function visit(node: ts.Node): void {
+    if (ts.isImportDeclaration(node) && node.moduleSpecifier) {
+      if (ts.isStringLiteral(node.moduleSpecifier)) {
+        const specifier = node.moduleSpecifier.text;
         const span = spanFromNode(node.moduleSpecifier, sourceFile);
         const parsed = parsePackageSpecifier(specifier);
         if (parsed) {
@@ -153,23 +153,23 @@ function collectImports(
             fromFile,
             sourcePaths,
           );
-          if (target) {
-            localImports.push({
-              toModuleId: moduleIdForFile(target),
-              span,
-            });
-          }
-        }
-      }
-    }
-
-    if (
-      ts.isCallExpression(node) &&
-      node.expression.kind === ts.SyntaxKind.ImportKeyword &&
-      node.arguments[0] &&
-      ts.isStringLiteral(node.arguments[0])
-    ) {
-      const specifier = node.arguments[0].text;
+          if (target) {
+            localImports.push({
+              toModuleId: moduleIdForFile(target),
+              span,
+            });
+          }
+        }
+      }
+    }
+
+    if (
+      ts.isCallExpression(node) &&
+      node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+      node.arguments[0] &&
+      ts.isStringLiteral(node.arguments[0])
+    ) {
+      const specifier = node.arguments[0].text;
       const span = spanFromNode(node.arguments[0], sourceFile);
       const parsed = parsePackageSpecifier(specifier);
       if (parsed) {
@@ -180,23 +180,23 @@ function collectImports(
           fromFile,
           sourcePaths,
         );
-        if (target) {
-          localImports.push({
-            toModuleId: moduleIdForFile(target),
-            span,
-          });
-        }
-      }
-    }
-
-    if (
-      ts.isCallExpression(node) &&
-      ts.isIdentifier(node.expression) &&
-      node.expression.text === "require" &&
-      node.arguments[0] &&
-      ts.isStringLiteral(node.arguments[0])
-    ) {
-      const specifier = node.arguments[0].text;
+        if (target) {
+          localImports.push({
+            toModuleId: moduleIdForFile(target),
+            span,
+          });
+        }
+      }
+    }
+
+    if (
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === "require" &&
+      node.arguments[0] &&
+      ts.isStringLiteral(node.arguments[0])
+    ) {
+      const specifier = node.arguments[0].text;
       const span = spanFromNode(node.arguments[0], sourceFile);
       const parsed = parsePackageSpecifier(specifier);
       if (parsed) {
@@ -207,22 +207,22 @@ function collectImports(
           fromFile,
           sourcePaths,
         );
-        if (target) {
-          localImports.push({
-            toModuleId: moduleIdForFile(target),
-            span,
-          });
-        }
-      }
-    }
-
-    ts.forEachChild(node, visit);
-  }
-
-  visit(sourceFile);
-  return { packageImports, localImports };
-}
-
+        if (target) {
+          localImports.push({
+            toModuleId: moduleIdForFile(target),
+            span,
+          });
+        }
+      }
+    }
+
+    ts.forEachChild(node, visit);
+  }
+
+  visit(sourceFile);
+  return { packageImports, localImports };
+}
+
 function sourcesUnchangedSincePrior(
   sources: SourceFile[],
   prior?: AppGraph,
@@ -232,21 +232,21 @@ function sourcesUnchangedSincePrior(
     return false;
   }
   const priorHashes = new Map(Object.entries(prior.sourceHashes ?? {}));
-  if (priorHashes.size !== sources.length) {
-    return false;
-  }
-  for (const source of sources) {
-    if (priorHashes.get(source.path) !== source.contentHash) {
-      return false;
-    }
-  }
-  return true;
+  if (priorHashes.size !== sources.length) {
+    return false;
+  }
+  for (const source of sources) {
+    if (priorHashes.get(source.path) !== source.contentHash) {
+      return false;
+    }
+  }
+  return true;
 }
 
 function priorModuleNodesByFile(prior?: AppGraph): Map<string, ModuleNode> {
   return new Map((prior?.moduleGraph.nodes ?? []).map((node) => [node.file, node]));
 }
-
+
 export function buildModuleGraph(
   sources: SourceFile[],
   rawSymbols: RawSymbol[],
@@ -285,31 +285,31 @@ export function buildModuleGraph(
     );
 
     if (!sourceFile) {
-      nodes.push({
-        id: moduleIdForFile(normalizedFile),
-        file: normalizedFile,
+      nodes.push({
+        id: moduleIdForFile(normalizedFile),
+        file: normalizedFile,
         directPackageImports: [],
         localImports: [],
         declaredContexts: declaredContextsForFile(normalizedFile, contextsByFile),
         effectiveContexts: [],
       });
-      continue;
-    }
-
+      continue;
+    }
+
     const { packageImports, localImports } = collectImports(
       sourceFile,
       sourcePaths,
     );
-
-    nodes.push({
-      id: moduleIdForFile(normalizedFile),
-      file: normalizedFile,
+
+    nodes.push({
+      id: moduleIdForFile(normalizedFile),
+      file: normalizedFile,
       directPackageImports: packageImports,
       localImports,
       declaredContexts: declaredContextsForFile(normalizedFile, contextsByFile),
       effectiveContexts: [],
     });
-  }
-
-  return { nodes: stableSortModuleNodes(nodes) };
-}
+  }
+
+  return { nodes: stableSortModuleNodes(nodes) };
+}

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

@@ -1,37 +1,37 @@
-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 : "",
-  }));
-}
-
+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 : "",
+  }));
+}
+
 interface PriorSymbolsForFile {
   contentHash?: string;
   symbols: ForgeSymbol[];
@@ -55,12 +55,12 @@ function groupPriorSymbolsByFile(
   }
   return byFile;
 }
-
-export interface IncrementalParseResult {
-  symbols: RawSymbol[];
-  diagnostics: Diagnostic[];
-}
-
+
+export interface IncrementalParseResult {
+  symbols: RawSymbol[];
+  diagnostics: Diagnostic[];
+}
+
 export function incrementalParse(
   sources: SourceFile[],
   priorSymbols: ForgeSymbol[] | undefined,
@@ -68,17 +68,17 @@ export function incrementalParse(
   priorInvalidation: ParseInvalidationKey | undefined,
   currentInvalidation: ParseInvalidationKey,
 ): IncrementalParseResult {
-  const diagnostics: Diagnostic[] = [];
-  const allSymbols: RawSymbol[] = [];
-  const globalInvalidated =
-    priorInvalidation === undefined ||
-    !parseInvalidationKeyEquals(priorInvalidation, currentInvalidation);
-
+  const diagnostics: Diagnostic[] = [];
+  const allSymbols: RawSymbol[] = [];
+  const globalInvalidated =
+    priorInvalidation === undefined ||
+    !parseInvalidationKeyEquals(priorInvalidation, currentInvalidation);
+
   const priorByFile = priorSymbols
     ? groupPriorSymbolsByFile(priorSymbols)
     : new Map<string, PriorSymbolsForFile>();
-
-  for (const source of sources) {
+
+  for (const source of sources) {
     const normalizedFile = normalizePath(source.path);
     const priorForFile = priorByFile.get(normalizedFile);
     const priorHash = priorForFile?.contentHash ?? priorSourceHashes?.[normalizedFile];
@@ -94,26 +94,26 @@ export function incrementalParse(
     if (fileUnchanged) {
       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 };
-}
+
+    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) ?? ""),
+  );
+}