@forwardimpact/libuniverse 0.1.2 → 0.1.3

package/bin/fit-universe.js

@@ -79,7 +79,8 @@ async function main() {
 
   const monorepoRoot = resolve(__dirname, "../../..");
   const schemaDir = join(monorepoRoot, "products/map/schema/json");
-  const cachePath = join(__dirname, "..", ".prose-cache.json");
+  const cachePath =
+    args.cache || join(monorepoRoot, "data", "synthetic", "prose-cache.json");
 
   const libsyntheticproseDir = dirname(
     fileURLToPath(import.meta.resolve("@forwardimpact/libsyntheticprose")),
@@ -160,7 +161,7 @@ async function main() {
 
   const result = await pipeline.run({
     universePath:
-      args.universe || join(monorepoRoot, "examples", "universe.dsl"),
+      args.story || join(monorepoRoot, "data", "synthetic", "story.dsl"),
     only: args.only || null,
     schemaDir,
   });
@@ -266,7 +267,8 @@ function parseArgs(argv) {
     else if (arg === "--dry-run") args.dryRun = true;
     else if (arg === "--load") args.load = true;
     else if (arg.startsWith("--only=")) args.only = arg.slice(7);
-    else if (arg.startsWith("--universe=")) args.universe = arg.slice(11);
+    else if (arg.startsWith("--story=")) args.story = arg.slice(8);
+    else if (arg.startsWith("--cache=")) args.cache = arg.slice(8);
   }
   return args;
 }
@@ -284,11 +286,12 @@ Options:
   --dry-run           Show what would be written without writing
   --load              Load raw documents to Supabase Storage
   --only=<type>       Render only one content type (html|pathway|raw|markdown)
-  --universe=<path>   Path to a custom universe DSL file
+  --story=<path>      Path to a custom story DSL file
+  --cache=<path>      Path to prose cache file
   -h, --help          Show this help message
 
 Prose modes:
-  (default)           Use cached prose from .prose-cache.json
+  (default)           Use cached prose from prose-cache.json
   --generate          Call LLM to generate prose and update the cache
   --no-prose          No prose — produces minimal structural data only
 
@@ -304,7 +307,7 @@ Examples:
   npx fit-universe --strict                  # Cached prose, fail on miss
   npx fit-universe --no-prose                # Structural only, no prose
   npx fit-universe --only=pathway            # Generate pathway data only
-  npx fit-universe --universe=custom.dsl     # Use custom DSL file
+  npx fit-universe --story=custom.dsl        # Use custom DSL file
 `);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@forwardimpact/libuniverse",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Synthetic data universe DSL and generation engine",
   "license": "Apache-2.0",
   "repository": {

package/pipeline.js

@@ -66,7 +66,7 @@ export class Pipeline {
    * Run the full generation pipeline.
    *
    * @param {object} options
-   * @param {string} options.universePath - Path to the universe.dsl file
+   * @param {string} options.universePath - Path to the story DSL file
    * @param {string} [options.only=null] - Render only a specific content type
    * @param {string|null} [options.schemaDir=null] - Path to JSON schema directory
    * @returns {Promise<{files: Map<string,string>, rawDocuments: Map<string,string>, entities: object, validation: object, stats: {prose: {hits: number, misses: number, generated: number}, files: number, rawDocuments: number}}>}

package/test/fixtures/minimal.dsl

@@ -0,0 +1,103 @@
+universe minimal {
+  domain "test.example"
+  industry "technology"
+  seed 42
+
+  org testorg {
+    name "Test Organization"
+  }
+
+  department eng {
+    name "Engineering"
+    parent testorg
+    headcount 5
+
+    team alpha {
+      name "Alpha Team"
+      size 5
+      manager @alpha_lead
+      repos ["alpha-service"]
+    }
+  }
+
+  people {
+    count 5
+    distribution {
+      L3 40%
+      L4 40%
+      L5 20%
+    }
+    disciplines {
+      software_engineering 100%
+    }
+  }
+
+  project testproj {
+    name "Test Project"
+    type "drug"
+    teams [alpha]
+    prose_topic "Testing synthetic generation"
+    prose_tone "technical"
+  }
+
+  framework {
+    proficiencies [awareness, foundational, working, practitioner, expert]
+    maturities [emerging, developing, practicing, role_modeling, exemplifying]
+    stages [specify, plan, code, review]
+
+    levels {
+      J040 { title "Software Engineer" rank 1 experience "0-2 years" }
+      J050 { title "Senior Engineer" rank 2 experience "2-5 years" }
+    }
+
+    capabilities {
+      coding { name "Coding" skills [python_dev, code_review] }
+    }
+
+    behaviours {
+      collaboration { name "Collaboration" }
+    }
+
+    disciplines {
+      software_engineering {
+        roleTitle "Software Engineer"
+        core [python_dev]
+        supporting [code_review]
+      }
+    }
+
+    tracks {
+      backend { name "Backend" }
+    }
+
+    drivers {
+      clear_direction {
+        name "Clear Direction"
+        skills [python_dev]
+        behaviours [collaboration]
+      }
+    }
+  }
+
+  scenario baseline {
+    name "Baseline Scenario"
+    timerange_start 2025-01
+    timerange_end 2025-06
+
+    affect alpha {
+      github_commits "moderate"
+      github_prs "moderate"
+      dx_drivers {
+        clear_direction { trajectory "rising" magnitude 3 }
+      }
+      evidence_skills [python_dev]
+      evidence_floor "foundational"
+    }
+  }
+
+  content guide_html {
+    courses 2
+    events 1
+    blogs 3
+  }
+}

package/test/pipeline.test.js

@@ -0,0 +1,106 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import {
+  createDslParser,
+  createEntityGenerator,
+} from "@forwardimpact/libsyntheticgen";
+import { validateCrossContent } from "@forwardimpact/libsyntheticrender";
+import { readFileSync } from "fs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const FIXTURE_PATH = join(__dirname, "fixtures", "minimal.dsl");
+
+function makeLogger() {
+  return {
+    info: () => {},
+    debug: () => {},
+    warn: () => {},
+    error: () => {},
+  };
+}
+
+describe("Pipeline integration", () => {
+  test("parses minimal DSL fixture", () => {
+    const source = readFileSync(FIXTURE_PATH, "utf-8");
+    const parser = createDslParser();
+    const ast = parser.parse(source);
+
+    assert.strictEqual(ast.domain, "test.example");
+    assert.strictEqual(ast.industry, "technology");
+    assert.ok(ast.people);
+    assert.ok(ast.teams.length > 0);
+    assert.ok(ast.projects.length > 0);
+  });
+
+  test("generates entities from minimal DSL", () => {
+    const source = readFileSync(FIXTURE_PATH, "utf-8");
+    const parser = createDslParser();
+    const ast = parser.parse(source);
+    const generator = createEntityGenerator(makeLogger());
+    const entities = generator.generate(ast);
+
+    assert.ok(entities.orgs.length > 0);
+    assert.ok(entities.departments.length > 0);
+    assert.ok(entities.teams.length > 0);
+    assert.ok(entities.people.length > 0);
+    assert.ok(entities.projects.length > 0);
+    assert.ok(entities.domain);
+  });
+
+  test("entity IRIs use consistent /id/ namespace", () => {
+    const source = readFileSync(FIXTURE_PATH, "utf-8");
+    const parser = createDslParser();
+    const ast = parser.parse(source);
+    const generator = createEntityGenerator(makeLogger());
+    const entities = generator.generate(ast);
+
+    for (const org of entities.orgs) {
+      assert.ok(org.iri.includes("/id/org/"), `Bad org IRI: ${org.iri}`);
+    }
+    for (const dept of entities.departments) {
+      assert.ok(
+        dept.iri.includes("/id/department/"),
+        `Bad dept IRI: ${dept.iri}`,
+      );
+    }
+    for (const team of entities.teams) {
+      assert.ok(team.iri.includes("/id/team/"), `Bad team IRI: ${team.iri}`);
+    }
+    for (const person of entities.people) {
+      assert.ok(
+        person.iri.includes("/id/person/"),
+        `Bad person IRI: ${person.iri}`,
+      );
+    }
+    for (const proj of entities.projects) {
+      assert.ok(
+        proj.iri.includes("/id/project/"),
+        `Bad project IRI: ${proj.iri}`,
+      );
+    }
+  });
+
+  test("cross-content validation passes on generated entities", () => {
+    const source = readFileSync(FIXTURE_PATH, "utf-8");
+    const parser = createDslParser();
+    const ast = parser.parse(source);
+    const generator = createEntityGenerator(makeLogger());
+    const entities = generator.generate(ast);
+    const result = validateCrossContent(entities);
+
+    // Minimal fixture has no snapshots block, so snapshot checks are expected to fail
+    const snapshotChecks = new Set([
+      "getdx_snapshots_list_response",
+      "getdx_snapshots_info_responses",
+    ]);
+    const failures = result.checks.filter(
+      (c) => !c.passed && !snapshotChecks.has(c.name),
+    );
+    if (failures.length > 0) {
+      const names = failures.map((f) => f.name).join(", ");
+      assert.fail(`Validation failures: ${names}`);
+    }
+  });
+});