@principal-ai/principal-view-cli 0.1.29 → 0.1.30

package/dist/index.cjs

@@ -7745,41 +7745,41 @@ var require_queue = __commonJS({
       queue.drained = drained;
       return queue;
       function push(value) {
-        var p = new Promise(function(resolve8, reject) {
+        var p = new Promise(function(resolve9, reject) {
           pushCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve8(result);
+            resolve9(result);
           });
         });
         p.catch(noop2);
         return p;
       }
       function unshift(value) {
-        var p = new Promise(function(resolve8, reject) {
+        var p = new Promise(function(resolve9, reject) {
           unshiftCb(value, function(err, result) {
             if (err) {
               reject(err);
               return;
             }
-            resolve8(result);
+            resolve9(result);
           });
         });
         p.catch(noop2);
         return p;
       }
       function drained() {
-        var p = new Promise(function(resolve8) {
+        var p = new Promise(function(resolve9) {
           process.nextTick(function() {
             if (queue.idle()) {
-              resolve8();
+              resolve9();
             } else {
               var previousDrain = queue.drain;
               queue.drain = function() {
                 if (typeof previousDrain === "function") previousDrain();
-                resolve8();
+                resolve9();
                 queue.drain = previousDrain;
               };
             }
@@ -8265,9 +8265,9 @@ var require_stream3 = __commonJS({
         });
       }
       _getStat(filepath) {
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           this._stat(filepath, this._fsStatSettings, (error, stats) => {
-            return error === null ? resolve8(stats) : reject(error);
+            return error === null ? resolve9(stats) : reject(error);
           });
         });
       }
@@ -8291,10 +8291,10 @@ var require_async5 = __commonJS({
         this._readerStream = new stream_1.default(this._settings);
       }
       dynamic(root, options) {
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           this._walkAsync(root, options, (error, entries) => {
             if (error === null) {
-              resolve8(entries);
+              resolve9(entries);
             } else {
               reject(error);
             }
@@ -8304,10 +8304,10 @@ var require_async5 = __commonJS({
       async static(patterns, options) {
         const entries = [];
         const stream = this._readerStream.static(patterns, options);
-        return new Promise((resolve8, reject) => {
+        return new Promise((resolve9, reject) => {
           stream.once("error", reject);
           stream.on("data", (entry) => entries.push(entry));
-          stream.once("end", () => resolve8(entries));
+          stream.once("end", () => resolve9(entries));
         });
       }
     };
@@ -23759,6 +23759,504 @@ function createDefaultRulesEngine() {
   return createRulesEngine(builtinRules);
 }
 
+// node_modules/@principal-ai/principal-view-core/dist/narrative/validator.js
+var import_fs = require("fs");
+var import_path2 = require("path");
+var NarrativeValidator = class {
+  /**
+   * Validate a narrative template
+   */
+  async validate(context) {
+    const violations = [];
+    violations.push(...this.checkSchema(context));
+    violations.push(...this.checkCanvasExists(context));
+    if (context.canvas) {
+      violations.push(...this.checkEventReferences(context));
+      violations.push(...this.checkAttributeReferences(context));
+    }
+    violations.push(...this.checkScenarios(context));
+    violations.push(...this.checkTemplateSyntax(context));
+    violations.push(...this.checkFormattingOptions(context));
+    return this.aggregateResults(violations);
+  }
+  /**
+   * Check schema validity (required fields, valid values)
+   */
+  checkSchema(context) {
+    const violations = [];
+    const { narrative, narrativePath } = context;
+    if (!narrative.version) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "version",
+        message: 'Missing required field "version"',
+        impact: "Cannot determine template version for compatibility",
+        suggestion: 'Add a version field (e.g., "1.0.0")',
+        fixable: false
+      });
+    } else if (!this.isValidSemver(narrative.version)) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "version",
+        message: `Invalid version format: "${narrative.version}"`,
+        impact: "Version must follow semver format",
+        suggestion: 'Use semver format like "1.0.0"',
+        fixable: false
+      });
+    }
+    if (!narrative.canvas) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "canvas",
+        message: 'Missing required field "canvas"',
+        impact: "Cannot determine which canvas this narrative belongs to",
+        suggestion: "Add a canvas field pointing to an .otel.canvas file",
+        fixable: false
+      });
+    }
+    if (!narrative.name) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "name",
+        message: 'Missing required field "name"',
+        impact: "Cannot identify this narrative template",
+        suggestion: "Add a human-readable name",
+        fixable: false
+      });
+    }
+    if (!narrative.description) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "description",
+        message: 'Missing required field "description"',
+        impact: "Cannot understand the purpose of this narrative",
+        suggestion: "Add a description explaining what this narrative shows",
+        fixable: false
+      });
+    }
+    const validModes = ["span-tree", "timeline", "summary-only"];
+    if (!narrative.mode) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "mode",
+        message: 'Missing required field "mode"',
+        impact: "Cannot determine how to structure the narrative",
+        suggestion: `Set mode to one of: ${validModes.join(", ")}`,
+        fixable: false
+      });
+    } else if (!validModes.includes(narrative.mode)) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "mode",
+        message: `Invalid mode: "${narrative.mode}"`,
+        impact: "Mode must be one of the supported types",
+        suggestion: `Use one of: ${validModes.join(", ")}`,
+        fixable: false
+      });
+    }
+    const validSelections = ["first-match", "manual"];
+    if (narrative.scenarioSelection && !validSelections.includes(narrative.scenarioSelection)) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "scenarioSelection",
+        message: `Invalid scenarioSelection: "${narrative.scenarioSelection}"`,
+        impact: "Scenario selection must be a valid type",
+        suggestion: `Use one of: ${validSelections.join(", ")}`,
+        fixable: false
+      });
+    }
+    if (!narrative.scenarios || !Array.isArray(narrative.scenarios)) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "scenarios",
+        message: 'Missing or invalid "scenarios" field',
+        impact: "Cannot generate narratives without scenarios",
+        suggestion: "Add a scenarios array with at least one scenario",
+        fixable: false
+      });
+    } else if (narrative.scenarios.length === 0) {
+      violations.push({
+        ruleId: "narrative-schema-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "scenarios",
+        message: "Scenarios array is empty",
+        impact: "Cannot generate narratives without scenarios",
+        suggestion: "Add at least one scenario definition",
+        fixable: false
+      });
+    }
+    return violations;
+  }
+  /**
+   * Check that the referenced canvas file exists
+   */
+  checkCanvasExists(context) {
+    const violations = [];
+    const { narrative, narrativePath, basePath, canvasPath } = context;
+    if (!narrative.canvas) {
+      return violations;
+    }
+    const resolvedPath = canvasPath || (0, import_path2.resolve)(basePath, narrative.canvas);
+    if (!(0, import_fs.existsSync)(resolvedPath)) {
+      violations.push({
+        ruleId: "narrative-canvas-exists",
+        severity: "error",
+        file: narrativePath,
+        path: "canvas",
+        message: `Referenced canvas file does not exist: ${narrative.canvas}`,
+        impact: "Cannot validate event references without the canvas",
+        suggestion: "Ensure the canvas field points to a valid .otel.canvas file",
+        fixable: false
+      });
+    }
+    return violations;
+  }
+  /**
+   * Check that events referenced in templates exist in the canvas
+   *
+   * Note: This is currently a placeholder as canvas files don't yet define event schemas.
+   * In the future, when canvas files include OTEL event schema definitions,
+   * this will validate event references.
+   */
+  checkEventReferences(context) {
+    const violations = [];
+    return violations;
+  }
+  /**
+   * Check that scenarios are well-formed
+   */
+  checkScenarios(context) {
+    const violations = [];
+    const { narrative, narrativePath } = context;
+    if (!narrative.scenarios || narrative.scenarios.length === 0) {
+      return violations;
+    }
+    const scenarioIds = /* @__PURE__ */ new Set();
+    const priorities = /* @__PURE__ */ new Set();
+    let hasDefault = false;
+    narrative.scenarios.forEach((scenario, idx) => {
+      if (!scenario.id) {
+        violations.push({
+          ruleId: "narrative-scenario-valid",
+          severity: "error",
+          file: narrativePath,
+          path: `scenarios[${idx}].id`,
+          message: 'Scenario is missing required "id" field',
+          impact: "Cannot identify this scenario",
+          suggestion: "Add a unique ID for this scenario",
+          fixable: false
+        });
+      } else {
+        if (scenarioIds.has(scenario.id)) {
+          violations.push({
+            ruleId: "narrative-scenario-valid",
+            severity: "error",
+            file: narrativePath,
+            path: `scenarios[${idx}].id`,
+            message: `Duplicate scenario ID: "${scenario.id}"`,
+            impact: "Scenario IDs must be unique",
+            suggestion: "Use a unique identifier for each scenario",
+            fixable: false
+          });
+        }
+        scenarioIds.add(scenario.id);
+      }
+      if (scenario.priority === void 0 || scenario.priority === null) {
+        violations.push({
+          ruleId: "narrative-scenario-valid",
+          severity: "error",
+          file: narrativePath,
+          path: `scenarios[${idx}].priority`,
+          message: 'Scenario is missing required "priority" field',
+          impact: "Cannot determine scenario selection order",
+          suggestion: "Add a priority (lower number = higher priority)",
+          fixable: false
+        });
+      } else {
+        if (scenario.priority < 0) {
+          violations.push({
+            ruleId: "narrative-scenario-valid",
+            severity: "error",
+            file: narrativePath,
+            path: `scenarios[${idx}].priority`,
+            message: "Priority must be a non-negative number",
+            impact: "Invalid priority value",
+            suggestion: "Use a positive integer (1 = highest priority)",
+            fixable: false
+          });
+        }
+        if (priorities.has(scenario.priority)) {
+          violations.push({
+            ruleId: "narrative-scenario-valid",
+            severity: "error",
+            file: narrativePath,
+            path: `scenarios[${idx}].priority`,
+            message: `Duplicate priority: ${scenario.priority}`,
+            impact: "Priorities must be unique to determine selection order",
+            suggestion: "Assign unique priority values to each scenario",
+            fixable: false
+          });
+        }
+        priorities.add(scenario.priority);
+      }
+      if (scenario.condition?.default === true) {
+        hasDefault = true;
+      }
+      if (!scenario.condition) {
+        violations.push({
+          ruleId: "narrative-scenario-valid",
+          severity: "error",
+          file: narrativePath,
+          path: `scenarios[${idx}].condition`,
+          message: 'Scenario is missing required "condition" field',
+          impact: "Cannot determine when to use this scenario",
+          suggestion: "Add a condition or set default: true",
+          fixable: false
+        });
+      }
+      if (!scenario.template) {
+        violations.push({
+          ruleId: "narrative-scenario-valid",
+          severity: "error",
+          file: narrativePath,
+          path: `scenarios[${idx}].template`,
+          message: 'Scenario is missing required "template" field',
+          impact: "Cannot render narrative without a template",
+          suggestion: "Add a template with introduction, events, or flow",
+          fixable: false
+        });
+      }
+    });
+    if (!hasDefault) {
+      violations.push({
+        ruleId: "narrative-scenario-valid",
+        severity: "error",
+        file: narrativePath,
+        path: "scenarios",
+        message: "No default scenario defined",
+        impact: "Narrative rendering may fail if no scenario matches",
+        suggestion: 'Add a scenario with "condition.default: true" as a fallback',
+        fixable: false
+      });
+    }
+    return violations;
+  }
+  /**
+   * Check template syntax (balanced braces, valid expressions)
+   */
+  checkTemplateSyntax(context) {
+    const violations = [];
+    const { narrative, narrativePath } = context;
+    narrative.scenarios.forEach((scenario, scenarioIdx) => {
+      if (!scenario.template) {
+        return;
+      }
+      const template = scenario.template;
+      if (template.introduction) {
+        violations.push(...this.validateTemplateString(template.introduction, narrativePath, `scenarios[${scenarioIdx}].template.introduction`));
+      }
+      if (template.summary) {
+        violations.push(...this.validateTemplateString(template.summary, narrativePath, `scenarios[${scenarioIdx}].template.summary`));
+      }
+      if (template.events) {
+        Object.entries(template.events).forEach(([eventName, templateStr]) => {
+          violations.push(...this.validateTemplateString(templateStr, narrativePath, `scenarios[${scenarioIdx}].template.events.${eventName}`));
+        });
+      }
+      if (template.logs) {
+        Object.entries(template.logs).forEach(([severity, templateStr]) => {
+          if (typeof templateStr === "string") {
+            violations.push(...this.validateTemplateString(templateStr, narrativePath, `scenarios[${scenarioIdx}].template.logs.${severity}`));
+          }
+        });
+      }
+      if (template.flow && Array.isArray(template.flow)) {
+        template.flow.forEach((item, flowIdx) => {
+          if (typeof item === "string") {
+            violations.push(...this.validateTemplateString(item, narrativePath, `scenarios[${scenarioIdx}].template.flow[${flowIdx}]`));
+          } else if (typeof item === "object" && item.template) {
+            violations.push(...this.validateTemplateString(item.template, narrativePath, `scenarios[${scenarioIdx}].template.flow[${flowIdx}].template`));
+          }
+        });
+      }
+    });
+    return violations;
+  }
+  /**
+   * Validate a single template string
+   */
+  validateTemplateString(templateStr, file, path4) {
+    const violations = [];
+    let braceDepth = 0;
+    let inQuote = false;
+    let quoteChar = "";
+    for (let i = 0; i < templateStr.length; i++) {
+      const char = templateStr[i];
+      const prevChar = i > 0 ? templateStr[i - 1] : "";
+      if ((char === "'" || char === '"') && prevChar !== "\\") {
+        if (!inQuote) {
+          inQuote = true;
+          quoteChar = char;
+        } else if (char === quoteChar) {
+          inQuote = false;
+          quoteChar = "";
+        }
+      }
+      if (!inQuote) {
+        if (char === "{") {
+          braceDepth++;
+        } else if (char === "}") {
+          braceDepth--;
+          if (braceDepth < 0) {
+            violations.push({
+              ruleId: "narrative-template-syntax",
+              severity: "error",
+              file,
+              path: path4,
+              message: "Unbalanced braces: closing } without opening {",
+              impact: "Template will fail to render",
+              suggestion: "Ensure all {expressions} have matching braces",
+              fixable: false
+            });
+            break;
+          }
+        }
+      }
+    }
+    if (braceDepth > 0) {
+      violations.push({
+        ruleId: "narrative-template-syntax",
+        severity: "error",
+        file,
+        path: path4,
+        message: "Unbalanced braces: missing closing }",
+        impact: "Template will fail to render",
+        suggestion: "Ensure all {expressions} have matching braces",
+        fixable: false
+      });
+    }
+    const conditionalPattern = /\{[^}]*\?[^}]*\}/g;
+    const conditionals = templateStr.match(conditionalPattern) || [];
+    conditionals.forEach((expr) => {
+      const questionCount = (expr.match(/\?/g) || []).length;
+      const colonCount = (expr.match(/:/g) || []).length;
+      if (questionCount > colonCount) {
+        violations.push({
+          ruleId: "narrative-template-syntax",
+          severity: "error",
+          file,
+          path: path4,
+          message: `Incomplete conditional expression: ${expr}`,
+          impact: "Template will fail to render",
+          suggestion: 'Conditional format: {condition ? "true" : "false"}',
+          fixable: false
+        });
+      }
+    });
+    return violations;
+  }
+  /**
+   * Check attribute references (warning level)
+   */
+  checkAttributeReferences(context) {
+    const violations = [];
+    return violations;
+  }
+  /**
+   * Check formatting options
+   */
+  checkFormattingOptions(context) {
+    const violations = [];
+    const { narrative, narrativePath } = context;
+    if (!narrative.formatting) {
+      return violations;
+    }
+    if (narrative.formatting.showAttributes) {
+      const validValues = ["none", "matched", "all"];
+      if (!validValues.includes(narrative.formatting.showAttributes)) {
+        violations.push({
+          ruleId: "narrative-formatting-options",
+          severity: "warn",
+          file: narrativePath,
+          path: "formatting.showAttributes",
+          message: `Invalid showAttributes value: "${narrative.formatting.showAttributes}"`,
+          impact: "May not display attributes correctly",
+          suggestion: `Use one of: ${validValues.join(", ")}`,
+          fixable: false
+        });
+      }
+    }
+    return violations;
+  }
+  /**
+   * Aggregate violations into result
+   */
+  aggregateResults(violations) {
+    let errorCount = 0;
+    let warningCount = 0;
+    let fixableCount = 0;
+    violations.forEach((v) => {
+      if (v.severity === "error") {
+        errorCount++;
+      } else {
+        warningCount++;
+      }
+      if (v.fixable) {
+        fixableCount++;
+      }
+    });
+    return {
+      violations,
+      errorCount,
+      warningCount,
+      fixableCount
+    };
+  }
+  // ============================================================================
+  // Helper Methods
+  // ============================================================================
+  /**
+   * Check if a version string is valid semver
+   */
+  isValidSemver(version) {
+    const semverPattern = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.-]+)?(\+[a-zA-Z0-9.-]+)?$/;
+    return semverPattern.test(version);
+  }
+  /**
+   * Check if an event name matches any available event (supports globs)
+   */
+  matchesEventPattern(eventName, availableEvents) {
+    if (availableEvents.includes(eventName)) {
+      return true;
+    }
+    const pattern = eventName.replace(/\*/g, ".*");
+    const regex = new RegExp(`^${pattern}$`);
+    return availableEvents.some((e) => regex.test(e));
+  }
+};
+function createNarrativeValidator() {
+  return new NarrativeValidator();
+}
+
 // src/commands/lint.ts
 var CONFIG_FILE_NAMES2 = [".privurc.yaml", ".privurc.yml", ".privurc.json"];
 function findConfig(startDir) {
@@ -23838,6 +24336,44 @@ function loadGraphConfig(filePath) {
     return null;
   }
 }
+function loadNarrativeTemplate(filePath) {
+  if (!(0, import_node_fs10.existsSync)(filePath)) {
+    return null;
+  }
+  try {
+    const raw = (0, import_node_fs10.readFileSync)(filePath, "utf8");
+    const narrative = JSON.parse(raw);
+    return { narrative, raw };
+  } catch {
+    return null;
+  }
+}
+function loadCanvas(filePath) {
+  if (!(0, import_node_fs10.existsSync)(filePath)) {
+    return null;
+  }
+  try {
+    const content = (0, import_node_fs10.readFileSync)(filePath, "utf8");
+    const ext = filePath.toLowerCase();
+    if (ext.endsWith(".json")) {
+      return JSON.parse(content);
+    } else {
+      return jsYaml.load(content);
+    }
+  } catch {
+    return null;
+  }
+}
+function getFileType(filePath) {
+  const name = (0, import_node_path11.basename)(filePath).toLowerCase();
+  if (name.endsWith(".narrative.json")) {
+    return "narrative";
+  }
+  if (name.endsWith(".canvas") || name.endsWith(".otel.canvas")) {
+    return "canvas";
+  }
+  return "config";
+}
 function formatPrettyOutput(results, quiet) {
   const lines = [];
   let totalErrors = 0;
@@ -23921,6 +24457,14 @@ function createLintCommand() {
     "Files or glob patterns to lint (defaults to .principal-views/**/*.yaml)"
   ).option("-c, --config <path>", "Path to config file").option("--library <path>", "Path to component library file").option("-q, --quiet", "Only output errors").option("--json", "Output results as JSON").option("--rule <rules...>", "Only run specific rules").option("--ignore-rule <rules...>", "Skip specific rules").action(async (files, options) => {
     try {
+      let countByRule2 = function(violations) {
+        const counts = {};
+        for (const v of violations) {
+          counts[v.ruleId] = (counts[v.ruleId] || 0) + 1;
+        }
+        return counts;
+      };
+      var countByRule = countByRule2;
       const cwd = process.cwd();
       let privuConfig = getDefaultConfig();
       if (options.config) {
@@ -23978,10 +24522,8 @@ function createLintCommand() {
         const name = (0, import_node_path11.basename)(f).toLowerCase();
         const isLibraryFile = name.startsWith("library.");
         const isConfigFile = name.startsWith(".privurc");
-        const isCanvasFile = f.toLowerCase().endsWith(".canvas");
-        const isNarrativeTemplate = name.endsWith(".narrative.json");
         const isExecutionArtifact = f.includes("__executions__/");
-        return !isLibraryFile && !isConfigFile && !isCanvasFile && !isNarrativeTemplate && !isExecutionArtifact;
+        return !isLibraryFile && !isConfigFile && !isExecutionArtifact;
       });
       if (configFiles.length === 0) {
         if (options.json) {
@@ -24009,39 +24551,95 @@ function createLintCommand() {
         }
       }
       const engine = createDefaultRulesEngine();
+      const narrativeValidator = createNarrativeValidator();
       const results = /* @__PURE__ */ new Map();
       for (const filePath of configFiles) {
         const absolutePath = (0, import_node_path11.resolve)(cwd, filePath);
         const relativePath = (0, import_node_path11.relative)(cwd, absolutePath);
-        const loaded = loadGraphConfig(absolutePath);
-        if (!loaded) {
+        const fileType = getFileType(absolutePath);
+        if (fileType === "narrative") {
+          const loaded = loadNarrativeTemplate(absolutePath);
+          if (!loaded) {
+            results.set(relativePath, {
+              violations: [
+                {
+                  ruleId: "parse-error",
+                  severity: "error",
+                  file: relativePath,
+                  message: `Could not parse narrative file: ${filePath}`,
+                  impact: "File cannot be validated",
+                  fixable: false
+                }
+              ],
+              errorCount: 1,
+              warningCount: 0,
+              fixableCount: 0,
+              byCategory: { schema: 1, reference: 0, structure: 0, pattern: 0, library: 0 },
+              byRule: { "parse-error": 1 }
+            });
+            continue;
+          }
+          const canvasPath = loaded.narrative.canvas ? (0, import_node_path11.resolve)((0, import_node_path11.dirname)(absolutePath), loaded.narrative.canvas) : void 0;
+          const canvas = canvasPath ? loadCanvas(canvasPath) : void 0;
+          const narrativeResult = await narrativeValidator.validate({
+            narrative: loaded.narrative,
+            narrativePath: relativePath,
+            canvas: canvas ?? void 0,
+            canvasPath: canvasPath ? (0, import_node_path11.relative)(cwd, canvasPath) : void 0,
+            basePath: (0, import_node_path11.dirname)(absolutePath),
+            rawContent: loaded.raw
+          });
+          const violations = narrativeResult.violations.map((v) => ({
+            ruleId: v.ruleId,
+            severity: v.severity,
+            file: v.file,
+            line: v.line,
+            path: v.path,
+            message: v.message,
+            impact: v.impact,
+            suggestion: v.suggestion,
+            fixable: v.fixable
+          }));
           results.set(relativePath, {
-            violations: [
-              {
-                ruleId: "parse-error",
-                severity: "error",
-                file: relativePath,
-                message: `Could not parse file: ${filePath}`,
-                impact: "File cannot be validated",
-                fixable: false
-              }
-            ],
-            errorCount: 1,
-            warningCount: 0,
-            fixableCount: 0,
-            byCategory: { schema: 1, reference: 0, structure: 0, pattern: 0, library: 0 },
-            byRule: { "parse-error": 1 }
+            violations,
+            errorCount: narrativeResult.errorCount,
+            warningCount: narrativeResult.warningCount,
+            fixableCount: narrativeResult.fixableCount,
+            byCategory: { schema: 0, reference: 0, structure: 0, pattern: 0, library: 0 },
+            // Could categorize narrative rules
+            byRule: countByRule2(violations)
           });
-          continue;
+        } else {
+          const loaded = loadGraphConfig(absolutePath);
+          if (!loaded) {
+            results.set(relativePath, {
+              violations: [
+                {
+                  ruleId: "parse-error",
+                  severity: "error",
+                  file: relativePath,
+                  message: `Could not parse file: ${filePath}`,
+                  impact: "File cannot be validated",
+                  fixable: false
+                }
+              ],
+              errorCount: 1,
+              warningCount: 0,
+              fixableCount: 0,
+              byCategory: { schema: 1, reference: 0, structure: 0, pattern: 0, library: 0 },
+              byRule: { "parse-error": 1 }
+            });
+            continue;
+          }
+          const result = await engine.lintWithConfig(loaded.config, privuConfig, {
+            library,
+            configPath: relativePath,
+            rawContent: loaded.raw,
+            enabledRules: options.rule,
+            disabledRules: options.ignoreRule
+          });
+          results.set(relativePath, result);
         }
-        const result = await engine.lintWithConfig(loaded.config, privuConfig, {
-          library,
-          configPath: relativePath,
-          rawContent: loaded.raw,
-          enabledRules: options.rule,
-          disabledRules: options.ignoreRule
-        });
-        results.set(relativePath, result);
       }
       if (options.json) {
         console.log(JSON.stringify(formatJsonOutput(results), null, 2));