@sprig-and-prose/sprig 0.9.1 → 0.10.0

package/src/compiler.ts

@@ -1,12 +1,15 @@
 import { readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { execSync } from "node:child_process";
-// @ts-expect-error - sprig-universe doesn't have TypeScript types
-import { parseFiles, parseFilesLegacy } from "@sprig-and-prose/sprig-universe";
+// @ts-expect-error - prose-parser package does not ship TS types
+import { compileFiles as compileProseFiles } from "@sprig-and-prose/prose-parser";
 
 export interface CompileResult {
   success: boolean;
-  manifest?: Record<string, unknown> & { repositories?: Record<string, unknown>; generatedAt: string; meta?: { generatedAt: string; manifestId: string } };
+  manifest?: Record<string, unknown> & {
+    generatedAt: string;
+    meta?: { generatedAt: string; manifestId: string };
+  };
   diagnostics: Array<{ severity: string; message: string; source?: unknown }>;
 }
 
@@ -25,64 +28,22 @@ function generateManifestId(): string {
   return `time:${new Date().toISOString()}`;
 }
 
-/**
- * Validates that exactly one universe declaration exists in the parsed graph
- */
-function validateUniverseCount(graph: Record<string, unknown>): {
-  valid: boolean;
-  universeName?: string;
-  error?: string;
-} {
-  const universes = graph.universes as Record<string, unknown> | undefined;
-  const universeNames = Object.keys(universes || {});
-
-  if (universeNames.length === 0) {
-    return {
-      valid: false,
-      error: "No universe declaration found. At least one universe declaration is required.",
-    };
-  }
-
-  if (universeNames.length > 1) {
-    const nodes = graph.nodes as Record<string, { source?: { file?: string } }> | undefined;
-    const fileList = Array.from(universeNames)
-      .map((name) => {
-        const universe = universes?.[name] as { root?: string } | undefined;
-        const rootNode = universe?.root && nodes ? nodes[universe.root] : null;
-        return rootNode?.source?.file || "unknown";
-      })
-      .filter((file, index, arr) => arr.indexOf(file) === index) // unique files
-      .sort()
-      .join(", ");
-    return {
-      valid: false,
-      error: `Multiple distinct universes found: ${universeNames.join(", ")}. Files: ${fileList}. Exactly one universe declaration is required.`,
-    };
-  }
-
-  return {
-    valid: true,
-    universeName: universeNames[0],
-  };
-}
-
 /**
  * Compiles prose files into a manifest
  * @param universeRoot - Universe root directory
  * @param files - Array of prose file paths
  * @param writeManifest - If true, write manifest to disk
- * @param options - Compilation options (legacy, outputDir)
+ * @param options - Compilation options (outputDir)
  * @returns Compile result with success status, manifest, and diagnostics
  */
 export async function compileUniverse(
   universeRoot: string,
   files: string[],
   writeManifest = true,
-  options?: { legacy?: boolean; outputDir?: string },
+  options?: { outputDir?: string },
 ): Promise<CompileResult> {
   const outputDir = options?.outputDir || join(universeRoot, ".sprig");
   const manifestPath = join(outputDir, "manifest.json");
-  const useLegacy = options?.legacy ?? false;
 
   // Read and parse files
   const fileContents = files.map((file) => ({
@@ -91,43 +52,46 @@ export async function compileUniverse(
   }));
 
   try {
-    const graph = useLegacy ? parseFilesLegacy(fileContents) : parseFiles(fileContents);
-
-    // Validate exactly one universe
-    const validation = validateUniverseCount(graph);
-    if (!validation.valid) {
-      return {
-        success: false,
-        diagnostics: [
-          {
-            severity: "error",
-            message: validation.error || "Unknown validation error",
-          },
-        ],
-      };
-    }
+    const result = compileProseFiles(fileContents);
+    const baseDiagnostics = result.diagnostics || [];
 
-    // Add repositories and metadata to manifest
+    // Add metadata to manifest
     const generatedAt = new Date().toISOString();
     const manifestId = generateManifestId();
-    
-    const manifest = {
-      ...graph,
-      repositories: graph.repositories || {},
-      generatedAt,
-      meta: {
-        generatedAt,
-        manifestId,
-      },
-    };
+
+    const manifest = result.manifest
+      ? {
+          ...result.manifest,
+          generatedAt,
+          meta: {
+            generatedAt,
+            manifestId,
+          },
+        }
+      : undefined;
 
     // Check for parsing errors
-    const hasErrors = graph.diagnostics.some((d: { severity: string }) => d.severity === "error");
+    const hasErrors = baseDiagnostics.some(
+      (d: { severity: string }) => d.severity === "error",
+    );
     if (hasErrors) {
       return {
         success: false,
         manifest,
-        diagnostics: graph.diagnostics,
+        diagnostics: baseDiagnostics,
+      };
+    }
+
+    if (!manifest) {
+      return {
+        success: false,
+        diagnostics: [
+          ...baseDiagnostics,
+          {
+            severity: "error",
+            message: "Compilation produced no manifest output.",
+          },
+        ],
       };
     }
 
@@ -151,7 +115,7 @@ export async function compileUniverse(
     return {
       success: true,
       manifest,
-      diagnostics: graph.diagnostics,
+      diagnostics: baseDiagnostics,
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);

package/src/diagnostics.ts

@@ -0,0 +1,100 @@
+import { basename } from "node:path";
+
+export type Diagnostic = { severity: string; message: string; source?: unknown };
+
+export function printDiagnostics(diagnostics: Diagnostic[], label: "Error" | "Warning"): void {
+  const grouped = new Map<
+    string,
+    { count: number; diagnostic: Diagnostic; diagnosticWithSource: Diagnostic | null }
+  >();
+
+  for (const diag of diagnostics) {
+    const key = diag.message;
+    const entry = grouped.get(key) || { count: 0, diagnostic: diag, diagnosticWithSource: null };
+    entry.count += 1;
+    if (hasSource(diag.source) && !entry.diagnosticWithSource) {
+      entry.diagnosticWithSource = diag;
+    }
+    grouped.set(key, entry);
+  }
+
+  const entries = Array.from(grouped.values());
+  entries.forEach(({ count, diagnostic, diagnosticWithSource }, index) => {
+    const source = formatSource(diagnosticWithSource?.source || diagnostic.source);
+    const { text, code } = extractMessageAndCode(diagnostic.message);
+    const countText = count > 1 ? ` (and ${count - 1} more)` : "";
+    const codeLabel = label === "Warning" ? "Warning Code" : "Error Code";
+    console.error(`${text}${countText}`);
+    console.error("");
+    console.error(source);
+    console.error(`${codeLabel}: ${code}`);
+    if (index < entries.length - 1) {
+      console.error("");
+    }
+  });
+}
+
+function hasSource(source: unknown): boolean {
+  if (!source) {
+    return false;
+  }
+
+  if (typeof source === "string") {
+    return source.trim().length > 0;
+  }
+
+  if (typeof source !== "object") {
+    return false;
+  }
+
+  const candidate = source as {
+    file?: string;
+    source?: { file?: string };
+    location?: { file?: string };
+  };
+
+  const span = candidate.source || candidate.location || candidate;
+  return typeof span.file === "string" && span.file.length > 0;
+}
+
+function extractMessageAndCode(message: string): { text: string; code: string } {
+  const match = message.match(/^\[(SP\d{3})\]\s*(.*)$/);
+  if (!match) {
+    return { text: message, code: "UNKNOWN" };
+  }
+
+  return {
+    code: match[1],
+    text: match[2] || "Unknown error.",
+  };
+}
+
+function formatSource(source: unknown): string {
+  if (!source) {
+    return "<unknown>:0:0";
+  }
+
+  if (typeof source === "string") {
+    return `${basename(source)}:0:0`;
+  }
+
+  if (typeof source !== "object") {
+    return "<unknown>:0:0";
+  }
+
+  const candidate = source as {
+    file?: string;
+    line?: number;
+    col?: number;
+    start?: { line?: number; col?: number };
+    source?: { file?: string; start?: { line?: number; col?: number } };
+    location?: { file?: string; start?: { line?: number; col?: number } };
+  };
+
+  const span = candidate.source || candidate.location || candidate;
+  const file = span.file ? basename(span.file) : "<unknown>";
+  const line = span.start?.line ?? candidate.line ?? 0;
+  const col = span.start?.col ?? candidate.col ?? 0;
+
+  return `${file}:${line}:${col}`;
+}

package/src/prose.ts

@@ -4,7 +4,7 @@ import fastGlob from "fast-glob";
 const DEFAULT_EXCLUDES = [".sprig/**", "dist/**", "node_modules/**", ".git/**"];
 
 /**
- * Loads all .prose files under root (excluding .scene.prose files) with default excludes
+ * Loads all .prose files under root with default excludes
  * @param root - Universe root directory
  * @returns Array of prose file paths, sorted deterministically
  */
@@ -12,10 +12,7 @@ export async function loadProseFiles(root: string): Promise<string[]> {
   const pattern = join(root, "**/*.prose");
   const allFiles = await fastGlob(pattern, {
     absolute: true,
-    ignore: [
-      ...DEFAULT_EXCLUDES.map((exclude) => join(root, exclude)),
-      join(root, "**/*.scene.prose"), // Exclude scene files
-    ],
+    ignore: [...DEFAULT_EXCLUDES.map((exclude) => join(root, exclude))],
   });
 
   // Sort for deterministic ordering

package/src/ui.ts

@@ -7,6 +7,7 @@ import chokidar from "chokidar";
 import { discoverUniverseRoot } from "./root.js";
 import { loadProseFiles } from "./prose.js";
 import { compileUniverse } from "./compiler.js";
+import { printDiagnostics } from "./diagnostics.js";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -29,14 +30,14 @@ const mimeTypes: Record<string, string> = {
 };
 
 /**
- * Resolves the dist directory path for sprig-ui-csr
+ * Resolves the dist directory path for sprig-ui
  * Works for both local and global installations
  */
 function resolveUIDist(): string {
   try {
     // Use Node's module resolution to find the package location
     // This works for both local (node_modules) and global installations
-    const packageJsonPath = require.resolve("@sprig-and-prose/sprig-ui-csr/package.json");
+    const packageJsonPath = require.resolve("@sprig-and-prose/sprig-ui/package.json");
     const packageDir = dirname(packageJsonPath);
     const distPath = join(packageDir, "dist");
     
@@ -47,13 +48,13 @@ function resolveUIDist(): string {
     throw new Error(`Found package at ${packageDir} but dist directory does not exist`);
   } catch (error) {
     // Fallback: try relative to current package (for development)
-    const fallbackPath = resolve(__dirname, "../../sprig-ui-csr/dist");
+    const fallbackPath = resolve(__dirname, "../../sprig-ui/dist");
     if (existsSync(fallbackPath)) {
       return fallbackPath;
     }
     
     const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Could not locate sprig-ui-csr dist directory: ${errorMessage}`);
+    throw new Error(`Could not locate sprig-ui dist directory: ${errorMessage}`);
   }
 }
 
@@ -196,11 +197,10 @@ function createServerHandler(
 async function rebuildManifest(
   universeRoot: string,
   manifestPath: string,
-  legacy: boolean,
 ): Promise<boolean> {
   try {
     const files = await loadProseFiles(universeRoot);
-    const result = await compileUniverse(universeRoot, files, true, { legacy });
+    const result = await compileUniverse(universeRoot, files, true);
 
     // Only broadcast if compilation succeeded (manifest was atomically written)
     if (result.success) {
@@ -219,7 +219,6 @@ async function rebuildManifest(
 export async function startUIServer(
   universeRoot: string,
   port: number = 6336,
-  legacy = false,
 ): Promise<void> {
   const uiDistDir = resolveUIDist();
   const manifestPath = join(universeRoot, ".sprig", "manifest.json");
@@ -227,14 +226,12 @@ export async function startUIServer(
   // Compile once on startup
   console.log("Compiling universe...");
   const files = await loadProseFiles(universeRoot);
-  const result = await compileUniverse(universeRoot, files, true, { legacy });
+  const result = await compileUniverse(universeRoot, files, true);
 
   if (!result.success) {
     const errors = result.diagnostics.filter((d) => d.severity === "error");
     if (errors.length > 0) {
-      for (const error of errors) {
-        console.error(`Error: ${error.message}`);
-      }
+      printDiagnostics(errors, "Error");
     }
     process.exit(1);
   }
@@ -292,7 +289,7 @@ export async function startUIServer(
     }
 
     rebuildTimeout = setTimeout(async () => {
-      const success = await rebuildManifest(universeRoot, manifestPath, legacy);
+      const success = await rebuildManifest(universeRoot, manifestPath);
       if (success) {
         // One-line status per rebuild (calm output)
         process.stdout.write("\r✓ Rebuilt\n");

package/tests/compile.test.js

@@ -1,34 +1,33 @@
 import { test } from "node:test";
 import { strict as assert } from "node:assert";
 import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs";
-import { join, tmpdir } from "node:path";
-import { compileUniverse } from "../src/compiler.js";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { compileUniverse } from "../dist/compiler.js";
 test("compileUniverse writes .sprig/manifest.json", async () => {
     const testDir = join(tmpdir(), `sprig-test-${Date.now()}`);
     mkdirSync(testDir, { recursive: true });
-    // Create universe.prose marker
-    writeFileSync(join(testDir, "universe.prose"), `universe TestUniverse {
+    const universeFile = join(testDir, "universe.prose");
+    const proseFile = join(testDir, "flora.prose");
+    writeFileSync(universeFile, `universe TestUniverse {
   describe {
     A test universe.
   }
 }`);
-    // Create a simple prose file
-    const proseFile = join(testDir, "test.prose");
-    writeFileSync(proseFile, `series TestSeries {
+    writeFileSync(proseFile, `concept Rose in TestUniverse {
   describe {
-    A test series.
+    A flower.
   }
 }`);
     try {
-        const result = await compileUniverse(testDir, [proseFile], true);
+        const result = await compileUniverse(testDir, [universeFile, proseFile], true);
         assert.strictEqual(result.success, true);
         assert.ok(result.manifest);
-        // Check that manifest.json was written
         const manifestPath = join(testDir, ".sprig", "manifest.json");
         assert.ok(existsSync(manifestPath), "manifest.json should exist");
-        // Check manifest content
         const manifestContent = JSON.parse(readFileSync(manifestPath, "utf-8"));
-        assert.strictEqual(manifestContent.universes?.TestUniverse?.name, "TestUniverse");
+        assert.strictEqual(manifestContent.universe?.name, "TestUniverse");
+        assert.ok(manifestContent.concepts?.["TestUniverse.Rose"]);
         assert.ok(manifestContent.generatedAt);
     }
     finally {
@@ -38,22 +37,22 @@ test("compileUniverse writes .sprig/manifest.json", async () => {
 test("compileUniverse does not write manifest when writeManifest is false", async () => {
     const testDir = join(tmpdir(), `sprig-test-${Date.now()}`);
     mkdirSync(testDir, { recursive: true });
-    writeFileSync(join(testDir, "universe.prose"), `universe TestUniverse {
+    const universeFile = join(testDir, "universe.prose");
+    writeFileSync(universeFile, `universe TestUniverse {
   describe {
     A test universe.
   }
 }`);
     const proseFile = join(testDir, "test.prose");
-    writeFileSync(proseFile, `series TestSeries {
+    writeFileSync(proseFile, `concept Lily in TestUniverse {
   describe {
-    A test series.
+    A test concept.
   }
 }`);
     try {
-        const result = await compileUniverse(testDir, [proseFile], false);
+        const result = await compileUniverse(testDir, [universeFile, proseFile], false);
         assert.strictEqual(result.success, true);
         assert.ok(result.manifest);
-        // Check that manifest.json was NOT written
         const manifestPath = join(testDir, ".sprig", "manifest.json");
         assert.ok(!existsSync(manifestPath), "manifest.json should not exist when writeManifest is false");
     }
@@ -61,4 +60,32 @@ test("compileUniverse does not write manifest when writeManifest is false", asyn
         rmSync(testDir, { recursive: true, force: true });
     }
 });
+test("compileUniverse supports declarations split across files", async () => {
+    const testDir = join(tmpdir(), `sprig-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+    const universeFile = join(testDir, "universe.prose");
+    const relationshipsFile = join(testDir, "relationships.prose");
+    const conceptsFile = join(testDir, "concepts.prose");
+    writeFileSync(universeFile, `universe TestUniverse {
+  concept Fox {}
+  concept Chicken {}
+}`);
+    writeFileSync(relationshipsFile, `relationship hunts and isHuntedBy in TestUniverse {}`);
+    writeFileSync(conceptsFile, `concept Raid in TestUniverse {
+  relationships {
+    hunts {
+      TestUniverse.Fox
+      TestUniverse.Chicken
+    }
+  }
+}`);
+    try {
+        const result = await compileUniverse(testDir, [universeFile, relationshipsFile, conceptsFile], false);
+        assert.strictEqual(result.success, true);
+        assert.deepEqual(result.manifest?.concepts?.["TestUniverse.Raid"]?.relationships?.map((reference) => reference.to), ["TestUniverse.Fox", "TestUniverse.Chicken"]);
+    }
+    finally {
+        rmSync(testDir, { recursive: true, force: true });
+    }
+});
 //# sourceMappingURL=compile.test.js.map

package/tests/compile.test.ts

@@ -1,36 +1,36 @@
 import { test } from "node:test";
 import { strict as assert } from "node:assert";
 import { mkdirSync, writeFileSync, readFileSync, existsSync, rmSync } from "node:fs";
-import { join, tmpdir } from "node:path";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { compileUniverse } from "../src/compiler.js";
 
 test("compileUniverse writes .sprig/manifest.json", async () => {
   const testDir = join(tmpdir(), `sprig-test-${Date.now()}`);
   mkdirSync(testDir, { recursive: true });
 
-  // Create universe.prose marker
+  const universeFile = join(testDir, "universe.prose");
+  const proseFile = join(testDir, "flora.prose");
+
   writeFileSync(
-    join(testDir, "universe.prose"),
+    universeFile,
     `universe TestUniverse {
   describe {
     A test universe.
   }
 }`,
   );
-
-  // Create a simple prose file
-  const proseFile = join(testDir, "test.prose");
   writeFileSync(
     proseFile,
-    `series TestSeries {
+    `concept Rose in TestUniverse {
   describe {
-    A test series.
+    A flower.
   }
 }`,
   );
 
   try {
-    const result = await compileUniverse(testDir, [proseFile], true);
+    const result = await compileUniverse(testDir, [universeFile, proseFile], true);
 
     assert.strictEqual(result.success, true);
     assert.ok(result.manifest);
@@ -41,7 +41,8 @@ test("compileUniverse writes .sprig/manifest.json", async () => {
 
     // Check manifest content
     const manifestContent = JSON.parse(readFileSync(manifestPath, "utf-8"));
-    assert.strictEqual(manifestContent.universes?.TestUniverse?.name, "TestUniverse");
+    assert.strictEqual(manifestContent.universe?.name, "TestUniverse");
+    assert.ok(manifestContent.concepts?.["TestUniverse.Rose"]);
     assert.ok(manifestContent.generatedAt);
   } finally {
     rmSync(testDir, { recursive: true, force: true });
@@ -52,8 +53,9 @@ test("compileUniverse does not write manifest when writeManifest is false", asyn
   const testDir = join(tmpdir(), `sprig-test-${Date.now()}`);
   mkdirSync(testDir, { recursive: true });
 
+  const universeFile = join(testDir, "universe.prose");
   writeFileSync(
-    join(testDir, "universe.prose"),
+    universeFile,
     `universe TestUniverse {
   describe {
     A test universe.
@@ -64,15 +66,15 @@ test("compileUniverse does not write manifest when writeManifest is false", asyn
   const proseFile = join(testDir, "test.prose");
   writeFileSync(
     proseFile,
-    `series TestSeries {
+    `concept Lily in TestUniverse {
   describe {
-    A test series.
+    A test concept.
   }
 }`,
   );
 
   try {
-    const result = await compileUniverse(testDir, [proseFile], false);
+    const result = await compileUniverse(testDir, [universeFile, proseFile], false);
 
     assert.strictEqual(result.success, true);
     assert.ok(result.manifest);
@@ -85,3 +87,52 @@ test("compileUniverse does not write manifest when writeManifest is false", asyn
   }
 });
 
+test("compileUniverse supports declarations split across files", async () => {
+  const testDir = join(tmpdir(), `sprig-test-${Date.now()}`);
+  mkdirSync(testDir, { recursive: true });
+
+  const universeFile = join(testDir, "universe.prose");
+  const relationshipsFile = join(testDir, "relationships.prose");
+  const conceptsFile = join(testDir, "concepts.prose");
+
+  writeFileSync(
+    universeFile,
+    `universe TestUniverse {
+  concept Fox {}
+  concept Chicken {}
+}`,
+  );
+  writeFileSync(
+    relationshipsFile,
+    `relationship hunts and isHuntedBy in TestUniverse {}`,
+  );
+  writeFileSync(
+    conceptsFile,
+    `concept Raid in TestUniverse {
+  relationships {
+    hunts {
+      TestUniverse.Fox
+      TestUniverse.Chicken
+    }
+  }
+}`,
+  );
+
+  try {
+    const result = await compileUniverse(
+      testDir,
+      [universeFile, relationshipsFile, conceptsFile],
+      false,
+    );
+    assert.strictEqual(result.success, true);
+    assert.deepEqual(
+      result.manifest?.concepts?.["TestUniverse.Raid"]?.relationships?.map(
+        (reference: { to: string }) => reference.to,
+      ),
+      ["TestUniverse.Fox", "TestUniverse.Chicken"],
+    );
+  } finally {
+    rmSync(testDir, { recursive: true, force: true });
+  }
+});
+

package/tests/init.test.ts

@@ -20,6 +20,10 @@ test("init creates both files when directory is empty", async () => {
 
     const universeProseContent = readFileSync(universeProsePath, "utf-8");
     assert.ok(universeProseContent.includes("universe Primer"), "universe.prose should contain universe name");
+    assert.ok(
+      universeProseContent.includes("describe {"),
+      "universe.prose should use describe block syntax",
+    );
 
     const readmeContent = readFileSync(readmePath, "utf-8");
     assert.ok(readmeContent.includes("# Primer"), "readme.md should contain universe name");
@@ -102,6 +106,10 @@ test("init handles reverse partial file existence correctly", async () => {
     assert.ok(existsSync(universeProsePath), "universe.prose should be created");
     const universeProseContent = readFileSync(universeProsePath, "utf-8");
     assert.ok(universeProseContent.includes("universe ReversePartialTest"), "universe.prose should contain new universe name");
+    assert.ok(
+      universeProseContent.includes("describe {"),
+      "universe.prose should use describe block syntax",
+    );
   } finally {
     rmSync(testDir, { recursive: true, force: true });
   }

package/tests/root.test.js

@@ -3,7 +3,7 @@ import { strict as assert } from "node:assert";
 import { mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { discoverUniverseRoot } from "../src/root.js";
+import { discoverUniverseRoot } from "../dist/root.js";
 test("discoverUniverseRoot finds universe.prose in current directory", () => {
     const testDir = join(tmpdir(), `sprig-test-${Date.now()}`);
     mkdirSync(testDir, { recursive: true });