@aiready/agent-grounding 0.9.2 → 0.9.3

package/.turbo/turbo-build.log

@@ -1,6 +1,6 @@
 
 
-> @aiready/agent-grounding@0.9.1 build /Users/pengcao/projects/aiready/packages/agent-grounding
+> @aiready/agent-grounding@0.9.2 build /Users/pengcao/projects/aiready/packages/agent-grounding
 > tsup src/index.ts src/cli.ts --format cjs,esm --dts
 
 CLI Building entry: src/cli.ts, src/index.ts
@@ -9,16 +9,16 @@
 CLI Target: es2020
 CJS Build start
 ESM Build start
-ESM dist/chunk-NXIMJNCK.mjs 9.55 KB
-ESM dist/index.mjs          154.00 B
 ESM dist/cli.mjs            5.16 KB
-ESM ⚡️ Build success in 210ms
-CJS dist/cli.js   16.22 KB
-CJS dist/index.js 10.75 KB
-CJS ⚡️ Build success in 210ms
+ESM dist/chunk-L3MLD6K4.mjs 9.65 KB
+ESM dist/index.mjs          154.00 B
+ESM ⚡️ Build success in 214ms
+CJS dist/index.js 10.96 KB
+CJS dist/cli.js   16.44 KB
+CJS ⚡️ Build success in 214ms
 DTS Build start
-DTS ⚡️ Build success in 3163ms
+DTS ⚡️ Build success in 2292ms
 DTS dist/cli.d.ts    20.00 B
-DTS dist/index.d.ts  2.34 KB
+DTS dist/index.d.ts  2.36 KB
 DTS dist/cli.d.mts   20.00 B
-DTS dist/index.d.mts 2.34 KB
+DTS dist/index.d.mts 2.36 KB

package/.turbo/turbo-test.log

@@ -1,16 +1,16 @@
 
 
-> @aiready/agent-grounding@0.9.1 test /Users/pengcao/projects/aiready/packages/agent-grounding
+> @aiready/agent-grounding@0.9.2 test /Users/pengcao/projects/aiready/packages/agent-grounding
 > vitest run
 
 [?25l
  RUN  v4.0.18 /Users/pengcao/projects/aiready/packages/agent-grounding
 
- ✓ src/__tests__/analyzer.test.ts (3 tests) 327ms
+ ✓ src/__tests__/analyzer.test.ts (3 tests) 317ms
 
  Test Files  1 passed (1)
       Tests  3 passed (3)
-   Start at  20:13:24
-   Duration  1.96s (transform 202ms, setup 0ms, import 1.19s, tests 327ms, environment 0ms)
+   Start at  20:00:26
+   Duration  2.35s (transform 316ms, setup 0ms, import 1.51s, tests 317ms, environment 0ms)
 
 [?25h

package/dist/chunk-ITKTRW4G.mjs

@@ -0,0 +1,295 @@
+// src/analyzer.ts
+import {
+  scanEntries,
+  calculateAgentGrounding,
+  VAGUE_FILE_NAMES,
+  Severity
+} from "@aiready/core";
+import { readFileSync, existsSync, statSync } from "fs";
+import { join, extname, basename, relative } from "path";
+import { parse } from "@typescript-eslint/typescript-estree";
+function analyzeFile(filePath) {
+  let code;
+  try {
+    code = readFileSync(filePath, "utf-8");
+  } catch {
+    return {
+      isBarrel: false,
+      exportedNames: [],
+      untypedExports: 0,
+      totalExports: 0,
+      domainTerms: []
+    };
+  }
+  let ast;
+  try {
+    ast = parse(code, {
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      range: false,
+      loc: false
+    });
+  } catch {
+    return {
+      isBarrel: false,
+      exportedNames: [],
+      untypedExports: 0,
+      totalExports: 0,
+      domainTerms: []
+    };
+  }
+  let isBarrel = false;
+  const exportedNames = [];
+  let untypedExports = 0;
+  let totalExports = 0;
+  const domainTerms = [];
+  for (const node of ast.body) {
+    if (node.type === "ExportAllDeclaration") {
+      isBarrel = true;
+      continue;
+    }
+    if (node.type === "ExportNamedDeclaration") {
+      totalExports++;
+      const decl = node.declaration;
+      if (decl) {
+        const name = decl.id?.name ?? decl.declarations?.[0]?.id?.name;
+        if (name) {
+          exportedNames.push(name);
+          domainTerms.push(
+            ...name.replace(/([A-Z])/g, " $1").toLowerCase().split(/\s+/).filter(Boolean)
+          );
+          const hasType = decl.returnType != null || decl.declarations?.[0]?.id?.typeAnnotation != null || decl.typeParameters != null;
+          if (!hasType) untypedExports++;
+        }
+      } else if (node.specifiers && node.specifiers.length > 0) {
+        isBarrel = true;
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration") {
+      totalExports++;
+    }
+  }
+  return { isBarrel, exportedNames, untypedExports, totalExports, domainTerms };
+}
+function detectInconsistentTerms(allTerms) {
+  const termFreq = /* @__PURE__ */ new Map();
+  for (const term of allTerms) {
+    if (term.length >= 3) {
+      termFreq.set(term, (termFreq.get(term) ?? 0) + 1);
+    }
+  }
+  const orphans = [...termFreq.values()].filter((count) => count === 1).length;
+  const common = [...termFreq.values()].filter((count) => count >= 3).length;
+  const vocabularySize = termFreq.size;
+  const inconsistent = Math.max(0, orphans - common * 2);
+  return { inconsistent, vocabularySize };
+}
+async function analyzeAgentGrounding(options) {
+  const rootDir = options.rootDir;
+  const maxRecommendedDepth = options.maxRecommendedDepth ?? 4;
+  const readmeStaleDays = options.readmeStaleDays ?? 90;
+  const { files, dirs: rawDirs } = await scanEntries({
+    ...options,
+    include: options.include || ["**/*.{ts,tsx,js,jsx}"]
+  });
+  const dirs = rawDirs.map((d) => ({
+    path: d,
+    depth: relative(rootDir, d).split(/[/\\]/).filter(Boolean).length
+  }));
+  const deepDirectories = dirs.filter(
+    (d) => d.depth > maxRecommendedDepth
+  ).length;
+  const additionalVague = new Set(
+    (options.additionalVagueNames ?? []).map((n) => n.toLowerCase())
+  );
+  let vagueFileNames = 0;
+  for (const f of files) {
+    const base = basename(f, extname(f)).toLowerCase();
+    if (VAGUE_FILE_NAMES.has(base) || additionalVague.has(base)) {
+      vagueFileNames++;
+    }
+  }
+  const readmePath = join(rootDir, "README.md");
+  const hasRootReadme = existsSync(readmePath);
+  let readmeIsFresh = false;
+  if (hasRootReadme) {
+    try {
+      const stat = statSync(readmePath);
+      const ageDays = (Date.now() - stat.mtimeMs) / (1e3 * 60 * 60 * 24);
+      readmeIsFresh = ageDays < readmeStaleDays;
+    } catch {
+    }
+  }
+  const allDomainTerms = [];
+  let barrelExports = 0;
+  let untypedExports = 0;
+  let totalExports = 0;
+  let processed = 0;
+  for (const f of files) {
+    processed++;
+    options.onProgress?.(
+      processed,
+      files.length,
+      `agent-grounding: analyzing files`
+    );
+    const analysis = analyzeFile(f);
+    if (analysis.isBarrel) barrelExports++;
+    untypedExports += analysis.untypedExports;
+    totalExports += analysis.totalExports;
+    allDomainTerms.push(...analysis.domainTerms);
+  }
+  const {
+    inconsistent: inconsistentDomainTerms,
+    vocabularySize: domainVocabularySize
+  } = detectInconsistentTerms(allDomainTerms);
+  const groundingResult = calculateAgentGrounding({
+    deepDirectories,
+    totalDirectories: dirs.length,
+    vagueFileNames,
+    totalFiles: files.length,
+    hasRootReadme,
+    readmeIsFresh,
+    barrelExports,
+    untypedExports,
+    totalExports: Math.max(1, totalExports),
+    inconsistentDomainTerms,
+    domainVocabularySize: Math.max(1, domainVocabularySize)
+  });
+  const issues = [];
+  if (groundingResult.dimensions.structureClarityScore < 70) {
+    issues.push({
+      type: "agent-navigation-failure",
+      dimension: "structure-clarity",
+      severity: Severity.Major,
+      message: `${deepDirectories} directories exceed recommended depth of ${maxRecommendedDepth} \u2014 agents struggle to navigate deep trees.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: `Flatten nested directories to ${maxRecommendedDepth} levels or fewer.`
+    });
+  }
+  if (groundingResult.dimensions.selfDocumentationScore < 70) {
+    issues.push({
+      type: "agent-navigation-failure",
+      dimension: "self-documentation",
+      severity: Severity.Major,
+      message: `${vagueFileNames} files use vague names (utils, helpers, misc) \u2014 an agent cannot determine their purpose from the name alone.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Rename to domain-specific names: e.g., userAuthUtils \u2192 tokenValidator."
+    });
+  }
+  if (!hasRootReadme) {
+    issues.push({
+      type: "agent-navigation-failure",
+      dimension: "entry-point",
+      severity: Severity.Critical,
+      message: "No root README.md found \u2014 agents have no orientation document to start from.",
+      location: { file: join(rootDir, "README.md"), line: 0 },
+      suggestion: "Add a README.md explaining the project structure, entry points, and key conventions."
+    });
+  } else if (!readmeIsFresh) {
+    issues.push({
+      type: "agent-navigation-failure",
+      dimension: "entry-point",
+      severity: Severity.Minor,
+      message: `README.md is stale (>${readmeStaleDays} days without updates) \u2014 agents may be misled by outdated context.`,
+      location: { file: readmePath, line: 0 },
+      suggestion: "Update README.md to reflect the current codebase structure."
+    });
+  }
+  if (groundingResult.dimensions.apiClarityScore < 70) {
+    issues.push({
+      type: "agent-navigation-failure",
+      dimension: "api-clarity",
+      severity: Severity.Major,
+      message: `${untypedExports} of ${totalExports} public exports lack TypeScript type annotations \u2014 agents cannot infer the API contract.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Add explicit return type and parameter annotations to all exported functions."
+    });
+  }
+  if (groundingResult.dimensions.domainConsistencyScore < 70) {
+    issues.push({
+      type: "agent-navigation-failure",
+      dimension: "domain-consistency",
+      severity: Severity.Major,
+      message: `${inconsistentDomainTerms} domain terms appear to be used inconsistently \u2014 agents get confused when one concept has multiple names.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Establish a domain glossary and enforce one term per concept across the codebase."
+    });
+  }
+  return {
+    summary: {
+      filesAnalyzed: files.length,
+      directoriesAnalyzed: dirs.length,
+      score: groundingResult.score,
+      rating: groundingResult.rating,
+      dimensions: groundingResult.dimensions
+    },
+    issues,
+    rawData: {
+      deepDirectories,
+      totalDirectories: dirs.length,
+      vagueFileNames,
+      totalFiles: files.length,
+      hasRootReadme,
+      readmeIsFresh,
+      barrelExports,
+      untypedExports,
+      totalExports,
+      inconsistentDomainTerms,
+      domainVocabularySize
+    },
+    recommendations: groundingResult.recommendations
+  };
+}
+
+// src/scoring.ts
+function calculateGroundingScore(report) {
+  const { summary, rawData, recommendations } = report;
+  const factors = [
+    {
+      name: "Structure Clarity",
+      impact: Math.round(summary.dimensions.structureClarityScore - 50),
+      description: `${rawData.deepDirectories} of ${rawData.totalDirectories} dirs exceed recommended depth`
+    },
+    {
+      name: "Self-Documentation",
+      impact: Math.round(summary.dimensions.selfDocumentationScore - 50),
+      description: `${rawData.vagueFileNames} of ${rawData.totalFiles} files have vague names`
+    },
+    {
+      name: "Entry Points",
+      impact: Math.round(summary.dimensions.entryPointScore - 50),
+      description: rawData.hasRootReadme ? rawData.readmeIsFresh ? "README present and fresh" : "README present but stale" : "No root README"
+    },
+    {
+      name: "API Clarity",
+      impact: Math.round(summary.dimensions.apiClarityScore - 50),
+      description: `${rawData.untypedExports} of ${rawData.totalExports} exports lack type annotations`
+    },
+    {
+      name: "Domain Consistency",
+      impact: Math.round(summary.dimensions.domainConsistencyScore - 50),
+      description: `${rawData.inconsistentDomainTerms} inconsistent domain terms detected`
+    }
+  ];
+  const recs = recommendations.map(
+    (action) => ({
+      action,
+      estimatedImpact: 6,
+      priority: summary.score < 50 ? "high" : "medium"
+    })
+  );
+  return {
+    toolName: "agent-grounding",
+    score: summary.score,
+    rawMetrics: {
+      ...rawData,
+      rating: summary.rating
+    },
+    factors,
+    recommendations: recs
+  };
+}
+
+export {
+  analyzeAgentGrounding,
+  calculateGroundingScore
+};

package/dist/chunk-L3MLD6K4.mjs

@@ -0,0 +1,296 @@
+// src/analyzer.ts
+import {
+  scanEntries,
+  calculateAgentGrounding,
+  VAGUE_FILE_NAMES,
+  Severity,
+  IssueType
+} from "@aiready/core";
+import { readFileSync, existsSync, statSync } from "fs";
+import { join, extname, basename, relative } from "path";
+import { parse } from "@typescript-eslint/typescript-estree";
+function analyzeFile(filePath) {
+  let code;
+  try {
+    code = readFileSync(filePath, "utf-8");
+  } catch {
+    return {
+      isBarrel: false,
+      exportedNames: [],
+      untypedExports: 0,
+      totalExports: 0,
+      domainTerms: []
+    };
+  }
+  let ast;
+  try {
+    ast = parse(code, {
+      jsx: filePath.endsWith(".tsx") || filePath.endsWith(".jsx"),
+      range: false,
+      loc: false
+    });
+  } catch {
+    return {
+      isBarrel: false,
+      exportedNames: [],
+      untypedExports: 0,
+      totalExports: 0,
+      domainTerms: []
+    };
+  }
+  let isBarrel = false;
+  const exportedNames = [];
+  let untypedExports = 0;
+  let totalExports = 0;
+  const domainTerms = [];
+  for (const node of ast.body) {
+    if (node.type === "ExportAllDeclaration") {
+      isBarrel = true;
+      continue;
+    }
+    if (node.type === "ExportNamedDeclaration") {
+      totalExports++;
+      const decl = node.declaration;
+      if (decl) {
+        const name = decl.id?.name ?? decl.declarations?.[0]?.id?.name;
+        if (name) {
+          exportedNames.push(name);
+          domainTerms.push(
+            ...name.replace(/([A-Z])/g, " $1").toLowerCase().split(/\s+/).filter(Boolean)
+          );
+          const hasType = decl.returnType != null || decl.declarations?.[0]?.id?.typeAnnotation != null || decl.typeParameters != null;
+          if (!hasType) untypedExports++;
+        }
+      } else if (node.specifiers && node.specifiers.length > 0) {
+        isBarrel = true;
+      }
+    }
+    if (node.type === "ExportDefaultDeclaration") {
+      totalExports++;
+    }
+  }
+  return { isBarrel, exportedNames, untypedExports, totalExports, domainTerms };
+}
+function detectInconsistentTerms(allTerms) {
+  const termFreq = /* @__PURE__ */ new Map();
+  for (const term of allTerms) {
+    if (term.length >= 3) {
+      termFreq.set(term, (termFreq.get(term) ?? 0) + 1);
+    }
+  }
+  const orphans = [...termFreq.values()].filter((count) => count === 1).length;
+  const common = [...termFreq.values()].filter((count) => count >= 3).length;
+  const vocabularySize = termFreq.size;
+  const inconsistent = Math.max(0, orphans - common * 2);
+  return { inconsistent, vocabularySize };
+}
+async function analyzeAgentGrounding(options) {
+  const rootDir = options.rootDir;
+  const maxRecommendedDepth = options.maxRecommendedDepth ?? 4;
+  const readmeStaleDays = options.readmeStaleDays ?? 90;
+  const { files, dirs: rawDirs } = await scanEntries({
+    ...options,
+    include: options.include || ["**/*.{ts,tsx,js,jsx}"]
+  });
+  const dirs = rawDirs.map((d) => ({
+    path: d,
+    depth: relative(rootDir, d).split(/[/\\]/).filter(Boolean).length
+  }));
+  const deepDirectories = dirs.filter(
+    (d) => d.depth > maxRecommendedDepth
+  ).length;
+  const additionalVague = new Set(
+    (options.additionalVagueNames ?? []).map((n) => n.toLowerCase())
+  );
+  let vagueFileNames = 0;
+  for (const f of files) {
+    const base = basename(f, extname(f)).toLowerCase();
+    if (VAGUE_FILE_NAMES.has(base) || additionalVague.has(base)) {
+      vagueFileNames++;
+    }
+  }
+  const readmePath = join(rootDir, "README.md");
+  const hasRootReadme = existsSync(readmePath);
+  let readmeIsFresh = false;
+  if (hasRootReadme) {
+    try {
+      const stat = statSync(readmePath);
+      const ageDays = (Date.now() - stat.mtimeMs) / (1e3 * 60 * 60 * 24);
+      readmeIsFresh = ageDays < readmeStaleDays;
+    } catch {
+    }
+  }
+  const allDomainTerms = [];
+  let barrelExports = 0;
+  let untypedExports = 0;
+  let totalExports = 0;
+  let processed = 0;
+  for (const f of files) {
+    processed++;
+    options.onProgress?.(
+      processed,
+      files.length,
+      `agent-grounding: analyzing files`
+    );
+    const analysis = analyzeFile(f);
+    if (analysis.isBarrel) barrelExports++;
+    untypedExports += analysis.untypedExports;
+    totalExports += analysis.totalExports;
+    allDomainTerms.push(...analysis.domainTerms);
+  }
+  const {
+    inconsistent: inconsistentDomainTerms,
+    vocabularySize: domainVocabularySize
+  } = detectInconsistentTerms(allDomainTerms);
+  const groundingResult = calculateAgentGrounding({
+    deepDirectories,
+    totalDirectories: dirs.length,
+    vagueFileNames,
+    totalFiles: files.length,
+    hasRootReadme,
+    readmeIsFresh,
+    barrelExports,
+    untypedExports,
+    totalExports: Math.max(1, totalExports),
+    inconsistentDomainTerms,
+    domainVocabularySize: Math.max(1, domainVocabularySize)
+  });
+  const issues = [];
+  if (groundingResult.dimensions.structureClarityScore < 70) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "structure-clarity",
+      severity: Severity.Major,
+      message: `${deepDirectories} directories exceed recommended depth of ${maxRecommendedDepth} \u2014 agents struggle to navigate deep trees.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: `Flatten nested directories to ${maxRecommendedDepth} levels or fewer.`
+    });
+  }
+  if (groundingResult.dimensions.selfDocumentationScore < 70) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "self-documentation",
+      severity: Severity.Major,
+      message: `${vagueFileNames} files use vague names (utils, helpers, misc) \u2014 an agent cannot determine their purpose from the name alone.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Rename to domain-specific names: e.g., userAuthUtils \u2192 tokenValidator."
+    });
+  }
+  if (!hasRootReadme) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "entry-point",
+      severity: Severity.Critical,
+      message: "No root README.md found \u2014 agents have no orientation document to start from.",
+      location: { file: join(rootDir, "README.md"), line: 0 },
+      suggestion: "Add a README.md explaining the project structure, entry points, and key conventions."
+    });
+  } else if (!readmeIsFresh) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "entry-point",
+      severity: Severity.Minor,
+      message: `README.md is stale (>${readmeStaleDays} days without updates) \u2014 agents may be misled by outdated context.`,
+      location: { file: readmePath, line: 0 },
+      suggestion: "Update README.md to reflect the current codebase structure."
+    });
+  }
+  if (groundingResult.dimensions.apiClarityScore < 70) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "api-clarity",
+      severity: Severity.Major,
+      message: `${untypedExports} of ${totalExports} public exports lack TypeScript type annotations \u2014 agents cannot infer the API contract.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Add explicit return type and parameter annotations to all exported functions."
+    });
+  }
+  if (groundingResult.dimensions.domainConsistencyScore < 70) {
+    issues.push({
+      type: IssueType.AgentNavigationFailure,
+      dimension: "domain-consistency",
+      severity: Severity.Major,
+      message: `${inconsistentDomainTerms} domain terms appear to be used inconsistently \u2014 agents get confused when one concept has multiple names.`,
+      location: { file: rootDir, line: 0 },
+      suggestion: "Establish a domain glossary and enforce one term per concept across the codebase."
+    });
+  }
+  return {
+    summary: {
+      filesAnalyzed: files.length,
+      directoriesAnalyzed: dirs.length,
+      score: groundingResult.score,
+      rating: groundingResult.rating,
+      dimensions: groundingResult.dimensions
+    },
+    issues,
+    rawData: {
+      deepDirectories,
+      totalDirectories: dirs.length,
+      vagueFileNames,
+      totalFiles: files.length,
+      hasRootReadme,
+      readmeIsFresh,
+      barrelExports,
+      untypedExports,
+      totalExports,
+      inconsistentDomainTerms,
+      domainVocabularySize
+    },
+    recommendations: groundingResult.recommendations
+  };
+}
+
+// src/scoring.ts
+function calculateGroundingScore(report) {
+  const { summary, rawData, recommendations } = report;
+  const factors = [
+    {
+      name: "Structure Clarity",
+      impact: Math.round(summary.dimensions.structureClarityScore - 50),
+      description: `${rawData.deepDirectories} of ${rawData.totalDirectories} dirs exceed recommended depth`
+    },
+    {
+      name: "Self-Documentation",
+      impact: Math.round(summary.dimensions.selfDocumentationScore - 50),
+      description: `${rawData.vagueFileNames} of ${rawData.totalFiles} files have vague names`
+    },
+    {
+      name: "Entry Points",
+      impact: Math.round(summary.dimensions.entryPointScore - 50),
+      description: rawData.hasRootReadme ? rawData.readmeIsFresh ? "README present and fresh" : "README present but stale" : "No root README"
+    },
+    {
+      name: "API Clarity",
+      impact: Math.round(summary.dimensions.apiClarityScore - 50),
+      description: `${rawData.untypedExports} of ${rawData.totalExports} exports lack type annotations`
+    },
+    {
+      name: "Domain Consistency",
+      impact: Math.round(summary.dimensions.domainConsistencyScore - 50),
+      description: `${rawData.inconsistentDomainTerms} inconsistent domain terms detected`
+    }
+  ];
+  const recs = recommendations.map(
+    (action) => ({
+      action,
+      estimatedImpact: 6,
+      priority: summary.score < 50 ? "high" : "medium"
+    })
+  );
+  return {
+    toolName: "agent-grounding",
+    score: summary.score,
+    rawMetrics: {
+      ...rawData,
+      rating: summary.rating
+    },
+    factors,
+    recommendations: recs
+  };
+}
+
+export {
+  analyzeAgentGrounding,
+  calculateGroundingScore
+};

package/dist/cli.js

@@ -180,9 +180,9 @@ async function analyzeAgentGrounding(options) {
   const issues = [];
   if (groundingResult.dimensions.structureClarityScore < 70) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "structure-clarity",
-      severity: "major",
+      severity: import_core.Severity.Major,
       message: `${deepDirectories} directories exceed recommended depth of ${maxRecommendedDepth} \u2014 agents struggle to navigate deep trees.`,
       location: { file: rootDir, line: 0 },
       suggestion: `Flatten nested directories to ${maxRecommendedDepth} levels or fewer.`
@@ -190,9 +190,9 @@ async function analyzeAgentGrounding(options) {
   }
   if (groundingResult.dimensions.selfDocumentationScore < 70) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "self-documentation",
-      severity: "major",
+      severity: import_core.Severity.Major,
       message: `${vagueFileNames} files use vague names (utils, helpers, misc) \u2014 an agent cannot determine their purpose from the name alone.`,
       location: { file: rootDir, line: 0 },
       suggestion: "Rename to domain-specific names: e.g., userAuthUtils \u2192 tokenValidator."
@@ -200,18 +200,18 @@ async function analyzeAgentGrounding(options) {
   }
   if (!hasRootReadme) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "entry-point",
-      severity: "critical",
+      severity: import_core.Severity.Critical,
       message: "No root README.md found \u2014 agents have no orientation document to start from.",
       location: { file: (0, import_path.join)(rootDir, "README.md"), line: 0 },
       suggestion: "Add a README.md explaining the project structure, entry points, and key conventions."
     });
   } else if (!readmeIsFresh) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "entry-point",
-      severity: "minor",
+      severity: import_core.Severity.Minor,
       message: `README.md is stale (>${readmeStaleDays} days without updates) \u2014 agents may be misled by outdated context.`,
       location: { file: readmePath, line: 0 },
       suggestion: "Update README.md to reflect the current codebase structure."
@@ -219,9 +219,9 @@ async function analyzeAgentGrounding(options) {
   }
   if (groundingResult.dimensions.apiClarityScore < 70) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "api-clarity",
-      severity: "major",
+      severity: import_core.Severity.Major,
       message: `${untypedExports} of ${totalExports} public exports lack TypeScript type annotations \u2014 agents cannot infer the API contract.`,
       location: { file: rootDir, line: 0 },
       suggestion: "Add explicit return type and parameter annotations to all exported functions."
@@ -229,9 +229,9 @@ async function analyzeAgentGrounding(options) {
   }
   if (groundingResult.dimensions.domainConsistencyScore < 70) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "domain-consistency",
-      severity: "major",
+      severity: import_core.Severity.Major,
       message: `${inconsistentDomainTerms} domain terms appear to be used inconsistently \u2014 agents get confused when one concept has multiple names.`,
       location: { file: rootDir, line: 0 },
       suggestion: "Establish a domain glossary and enforce one term per concept across the codebase."

package/dist/cli.mjs

@@ -2,7 +2,7 @@
 import {
   analyzeAgentGrounding,
   calculateGroundingScore
-} from "./chunk-NXIMJNCK.mjs";
+} from "./chunk-L3MLD6K4.mjs";
 
 // src/cli.ts
 import { Command } from "commander";

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-import { Issue, ScanOptions, ToolScoringOutput } from '@aiready/core';
+import { Issue, IssueType, ScanOptions, ToolScoringOutput } from '@aiready/core';
 
 interface AgentGroundingOptions extends ScanOptions {
     /** Max directory depth before flagging as "too deep" */
@@ -9,7 +9,7 @@ interface AgentGroundingOptions extends ScanOptions {
     additionalVagueNames?: string[];
 }
 interface AgentGroundingIssue extends Issue {
-    type: 'agent-navigation-failure';
+    type: IssueType.AgentNavigationFailure;
     /** Which grounding dimension is affected */
     dimension: 'structure-clarity' | 'self-documentation' | 'entry-point' | 'api-clarity' | 'domain-consistency';
 }

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { Issue, ScanOptions, ToolScoringOutput } from '@aiready/core';
+import { Issue, IssueType, ScanOptions, ToolScoringOutput } from '@aiready/core';
 
 interface AgentGroundingOptions extends ScanOptions {
     /** Max directory depth before flagging as "too deep" */
@@ -9,7 +9,7 @@ interface AgentGroundingOptions extends ScanOptions {
     additionalVagueNames?: string[];
 }
 interface AgentGroundingIssue extends Issue {
-    type: 'agent-navigation-failure';
+    type: IssueType.AgentNavigationFailure;
     /** Which grounding dimension is affected */
     dimension: 'structure-clarity' | 'self-documentation' | 'entry-point' | 'api-clarity' | 'domain-consistency';
 }

package/dist/index.js

@@ -179,9 +179,9 @@ async function analyzeAgentGrounding(options) {
   const issues = [];
   if (groundingResult.dimensions.structureClarityScore < 70) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "structure-clarity",
-      severity: "major",
+      severity: import_core.Severity.Major,
       message: `${deepDirectories} directories exceed recommended depth of ${maxRecommendedDepth} \u2014 agents struggle to navigate deep trees.`,
       location: { file: rootDir, line: 0 },
       suggestion: `Flatten nested directories to ${maxRecommendedDepth} levels or fewer.`
@@ -189,9 +189,9 @@ async function analyzeAgentGrounding(options) {
   }
   if (groundingResult.dimensions.selfDocumentationScore < 70) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "self-documentation",
-      severity: "major",
+      severity: import_core.Severity.Major,
       message: `${vagueFileNames} files use vague names (utils, helpers, misc) \u2014 an agent cannot determine their purpose from the name alone.`,
       location: { file: rootDir, line: 0 },
       suggestion: "Rename to domain-specific names: e.g., userAuthUtils \u2192 tokenValidator."
@@ -199,18 +199,18 @@ async function analyzeAgentGrounding(options) {
   }
   if (!hasRootReadme) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "entry-point",
-      severity: "critical",
+      severity: import_core.Severity.Critical,
       message: "No root README.md found \u2014 agents have no orientation document to start from.",
       location: { file: (0, import_path.join)(rootDir, "README.md"), line: 0 },
       suggestion: "Add a README.md explaining the project structure, entry points, and key conventions."
     });
   } else if (!readmeIsFresh) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "entry-point",
-      severity: "minor",
+      severity: import_core.Severity.Minor,
       message: `README.md is stale (>${readmeStaleDays} days without updates) \u2014 agents may be misled by outdated context.`,
       location: { file: readmePath, line: 0 },
       suggestion: "Update README.md to reflect the current codebase structure."
@@ -218,9 +218,9 @@ async function analyzeAgentGrounding(options) {
   }
   if (groundingResult.dimensions.apiClarityScore < 70) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "api-clarity",
-      severity: "major",
+      severity: import_core.Severity.Major,
       message: `${untypedExports} of ${totalExports} public exports lack TypeScript type annotations \u2014 agents cannot infer the API contract.`,
       location: { file: rootDir, line: 0 },
       suggestion: "Add explicit return type and parameter annotations to all exported functions."
@@ -228,9 +228,9 @@ async function analyzeAgentGrounding(options) {
   }
   if (groundingResult.dimensions.domainConsistencyScore < 70) {
     issues.push({
-      type: "agent-navigation-failure",
+      type: import_core.IssueType.AgentNavigationFailure,
       dimension: "domain-consistency",
-      severity: "major",
+      severity: import_core.Severity.Major,
       message: `${inconsistentDomainTerms} domain terms appear to be used inconsistently \u2014 agents get confused when one concept has multiple names.`,
       location: { file: rootDir, line: 0 },
       suggestion: "Establish a domain glossary and enforce one term per concept across the codebase."

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   analyzeAgentGrounding,
   calculateGroundingScore
-} from "./chunk-NXIMJNCK.mjs";
+} from "./chunk-L3MLD6K4.mjs";
 export {
   analyzeAgentGrounding,
   calculateGroundingScore

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aiready/agent-grounding",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Measures how well an AI agent can navigate a codebase autonomously without human assistance",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
@@ -40,7 +40,7 @@
     "chalk": "^5.3.0",
     "commander": "^14.0.0",
     "glob": "^13.0.0",
-    "@aiready/core": "0.19.2"
+    "@aiready/core": "0.19.3"
   },
   "devDependencies": {
     "@types/node": "^24.0.0",

package/src/analyzer.ts

@@ -13,6 +13,8 @@ import {
   scanEntries,
   calculateAgentGrounding,
   VAGUE_FILE_NAMES,
+  Severity,
+  IssueType,
 } from '@aiready/core';
 import { readFileSync, existsSync, statSync } from 'fs';
 import { join, extname, basename, relative } from 'path';
@@ -241,9 +243,9 @@ export async function analyzeAgentGrounding(
 
   if (groundingResult.dimensions.structureClarityScore < 70) {
     issues.push({
-      type: 'agent-navigation-failure',
+      type: IssueType.AgentNavigationFailure,
       dimension: 'structure-clarity',
-      severity: 'major',
+      severity: Severity.Major,
       message: `${deepDirectories} directories exceed recommended depth of ${maxRecommendedDepth} — agents struggle to navigate deep trees.`,
       location: { file: rootDir, line: 0 },
       suggestion: `Flatten nested directories to ${maxRecommendedDepth} levels or fewer.`,
@@ -252,9 +254,9 @@ export async function analyzeAgentGrounding(
 
   if (groundingResult.dimensions.selfDocumentationScore < 70) {
     issues.push({
-      type: 'agent-navigation-failure',
+      type: IssueType.AgentNavigationFailure,
       dimension: 'self-documentation',
-      severity: 'major',
+      severity: Severity.Major,
       message: `${vagueFileNames} files use vague names (utils, helpers, misc) — an agent cannot determine their purpose from the name alone.`,
       location: { file: rootDir, line: 0 },
       suggestion:
@@ -264,9 +266,9 @@ export async function analyzeAgentGrounding(
 
   if (!hasRootReadme) {
     issues.push({
-      type: 'agent-navigation-failure',
+      type: IssueType.AgentNavigationFailure,
       dimension: 'entry-point',
-      severity: 'critical',
+      severity: Severity.Critical,
       message:
         'No root README.md found — agents have no orientation document to start from.',
       location: { file: join(rootDir, 'README.md'), line: 0 },
@@ -275,9 +277,9 @@ export async function analyzeAgentGrounding(
     });
   } else if (!readmeIsFresh) {
     issues.push({
-      type: 'agent-navigation-failure',
+      type: IssueType.AgentNavigationFailure,
       dimension: 'entry-point',
-      severity: 'minor',
+      severity: Severity.Minor,
       message: `README.md is stale (>${readmeStaleDays} days without updates) — agents may be misled by outdated context.`,
       location: { file: readmePath, line: 0 },
       suggestion: 'Update README.md to reflect the current codebase structure.',
@@ -286,9 +288,9 @@ export async function analyzeAgentGrounding(
 
   if (groundingResult.dimensions.apiClarityScore < 70) {
     issues.push({
-      type: 'agent-navigation-failure',
+      type: IssueType.AgentNavigationFailure,
       dimension: 'api-clarity',
-      severity: 'major',
+      severity: Severity.Major,
       message: `${untypedExports} of ${totalExports} public exports lack TypeScript type annotations — agents cannot infer the API contract.`,
       location: { file: rootDir, line: 0 },
       suggestion:
@@ -298,9 +300,9 @@ export async function analyzeAgentGrounding(
 
   if (groundingResult.dimensions.domainConsistencyScore < 70) {
     issues.push({
-      type: 'agent-navigation-failure',
+      type: IssueType.AgentNavigationFailure,
       dimension: 'domain-consistency',
-      severity: 'major',
+      severity: Severity.Major,
       message: `${inconsistentDomainTerms} domain terms appear to be used inconsistently — agents get confused when one concept has multiple names.`,
       location: { file: rootDir, line: 0 },
       suggestion:

package/src/types.ts

@@ -1,4 +1,4 @@
-import type { ScanOptions, Issue } from '@aiready/core';
+import type { ScanOptions, Issue, IssueType } from '@aiready/core';
 
 export interface AgentGroundingOptions extends ScanOptions {
   /** Max directory depth before flagging as "too deep" */
@@ -10,7 +10,7 @@ export interface AgentGroundingOptions extends ScanOptions {
 }
 
 export interface AgentGroundingIssue extends Issue {
-  type: 'agent-navigation-failure';
+  type: IssueType.AgentNavigationFailure;
   /** Which grounding dimension is affected */
   dimension:
     | 'structure-clarity'