@planu/cli 4.6.1 → 4.7.1

package/dist/tools/token-intelligence-handler.js

@@ -2,6 +2,7 @@ import { getEntries, getAggregation } from '../storage/token-ledger-store.js';
 import { hashProjectPath } from '../storage/base-store.js';
 import { buildTokenWasteReport, detectTokenWasteLoops, formatTokenWasteReport, loadTokenWastePolicy, recommendRelevantTools, } from '../engine/token-optimizer/index.js';
 import { join } from 'node:path';
+import { formatProjectGraphContext, queryProjectGraphSlice, } from '../engine/project-graph/index.js';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
@@ -390,6 +391,26 @@ async function renderAutopilot(entries, agg, period, projectPath) {
         '',
     ].join('\n');
 }
+async function renderGraphView(projectPath, specId) {
+    const slice = await queryProjectGraphSlice({ projectPath, specId }).catch(() => null);
+    if (slice === null) {
+        return [
+            '# Token Intelligence Dashboard — Graph View',
+            '',
+            'Project graph is unavailable; existing token intelligence views still work.',
+            '',
+        ].join('\n');
+    }
+    return [
+        '# Token Intelligence Dashboard — Graph View',
+        '',
+        `Graph freshness: ${slice.freshness.stale ? slice.freshness.reason : 'fresh'}`,
+        `Compact slice: ${String(slice.nodes.length)} nodes / ${String(slice.edges.length)} edges`,
+        `Estimated raw context avoided: ${String(slice.tokenSavings.estimatedRawContextAvoided)} graph items`,
+        '',
+        await formatProjectGraphContext(slice),
+    ].join('\n');
+}
 // ---------------------------------------------------------------------------
 // Empty state
 // ---------------------------------------------------------------------------
@@ -429,7 +450,10 @@ export async function handleTokenIntelligence(input) {
         getEntries(projectHash, dataDir, filter),
         getAggregation(projectHash, dataDir, filter),
     ]);
-    if (entries.length === 0 && view !== 'reconciliation' && view !== 'autopilot') {
+    if (entries.length === 0 &&
+        view !== 'reconciliation' &&
+        view !== 'autopilot' &&
+        view !== 'graph') {
         return { content: [{ type: 'text', text: renderEmpty(view, period) }] };
     }
     let text;
@@ -449,6 +473,9 @@ export async function handleTokenIntelligence(input) {
         case 'autopilot':
             text = await renderAutopilot(entries, agg, period, projectPath);
             break;
+        case 'graph':
+            text = await renderGraphView(projectPath, specId);
+            break;
         default:
             text = renderSummary(agg, entries, period, groupBy);
             break;

package/dist/tools/validate.js

@@ -17,8 +17,67 @@ import { validateScopeCompliance } from '../engine/scope-boundaries/index.js';
 import { compareWithBaseline } from '../storage/convention-baseline.js';
 import { writeImplementationReviewReport } from '../engine/validator/validation-report-writer.js';
 import { evaluateNewCodeGate } from '../engine/ai-assurance/index.js';
+import { queryProjectGraphSlice } from '../engine/project-graph/index.js';
 // Re-export for external use (SPEC-018)
 export { validateContractCompliance };
+function graphCoverageGaps(slice) {
+    if (slice === null) {
+        return [];
+    }
+    const criteria = slice.nodes.filter((node) => node.type === 'criterion');
+    return criteria
+        .filter((criterion) => {
+        const outgoing = slice.edges.filter((edge) => edge.from === criterion.id);
+        return !outgoing.some((edge) => edge.type === 'implements' || edge.type === 'tests');
+    })
+        .map((criterion) => criterion.label)
+        .slice(0, 10);
+}
+async function buildGraphCoverageReport(args) {
+    const graphSlice = await queryProjectGraphSlice(args).catch(() => null);
+    return {
+        freshness: graphSlice?.freshness,
+        gaps: graphCoverageGaps(graphSlice),
+        compactNodes: graphSlice?.nodes.length ?? 0,
+        compactEdges: graphSlice?.edges.length ?? 0,
+    };
+}
+function formatGraphCoverageText(report) {
+    return report.gaps.length > 0
+        ? `\nGRAPH     ${String(report.gaps.length)} graph-backed coverage gap(s)`
+        : '';
+}
+async function validateStrictLayoutOrError(args) {
+    try {
+        const { validateStrictPlanuLayout } = await import('../engine/spec-migrator/index.js');
+        const layout = await validateStrictPlanuLayout(args.projectPath, {
+            specPath: args.specPath,
+            includeRoot: false,
+        });
+        if (layout.ok) {
+            return null;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Strict Planu layout validation failed for ${args.specId}.\n\n` +
+                        `Non-canonical paths:\n${layout.offenders.map((p) => `- ${p}`).join('\n')}\n\n` +
+                        `Canonical contract:\n${layout.contract}`,
+                },
+            ],
+            isError: true,
+            structuredContent: {
+                error: 'strict_planu_layout_violation',
+                offenders: layout.offenders,
+                contract: layout.contract,
+            },
+        };
+    }
+    catch {
+        return null;
+    }
+}
 /** Build the fallback interactiveQuestion for validation failures. */
 function buildValidateFailureFallback(failedCount) {
     return {
@@ -72,36 +131,17 @@ export async function handleValidate(args, server) {
     }
     const projectPath = knowledge.projectPath;
     // SPEC-1017: fail closed when planu/ contains non-canonical artifacts.
-    try {
-        const { validateStrictPlanuLayout } = await import('../engine/spec-migrator/index.js');
-        const layout = await validateStrictPlanuLayout(projectPath, {
-            specPath: spec.specPath,
-            includeRoot: false,
-        });
-        if (!layout.ok) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Strict Planu layout validation failed for ${specId}.\n\n` +
-                            `Non-canonical paths:\n${layout.offenders.map((p) => `- ${p}`).join('\n')}\n\n` +
-                            `Canonical contract:\n${layout.contract}`,
-                    },
-                ],
-                isError: true,
-                structuredContent: {
-                    error: 'strict_planu_layout_violation',
-                    offenders: layout.offenders,
-                    contract: layout.contract,
-                },
-            };
-        }
-    }
-    catch {
-        /* best-effort — implementation validation still runs if layout check is unavailable */
+    const strictLayoutError = await validateStrictLayoutOrError({
+        projectPath,
+        specId,
+        specPath: spec.specPath,
+    });
+    if (strictLayoutError !== null) {
+        return strictLayoutError;
     }
     // 3. Run validation engine
     const result = await validateSpec(spec, projectPath);
+    const graphCoverage = await buildGraphCoverageReport({ projectId, projectPath, specId });
     // 4. Generate DoR and DoD checklists
     const dor = generateDoR(spec);
     const dod = await generateDoD(spec, result, undefined, projectPath);
@@ -222,6 +262,7 @@ export async function handleValidate(args, server) {
         lintCheck,
         assuranceGates,
         validationReport,
+        graphCoverage,
     };
     // SPEC-612: Scope boundary validation — warn if impl files match outOfScope items
     if (spec.outOfScope !== undefined && spec.outOfScope.length > 0) {
@@ -256,6 +297,9 @@ export async function handleValidate(args, server) {
     if (result.missing.length > 0) {
         suggestions.push(`${result.missing.length} criteria still missing. Run detect_drift to identify gaps.`);
     }
+    if (graphCoverage.gaps.length > 0) {
+        suggestions.push(`${graphCoverage.gaps.length} graph-backed coverage gap(s) found without broad repository scan.`);
+    }
     if (conventionViolations.length > 0) {
         suggestions.push(`${conventionViolations.length} convention violation(s) detected. Fix before marking as done.`);
     }
@@ -327,6 +371,7 @@ export async function handleValidate(args, server) {
         commitReminder,
         planuReminder,
     });
+    const graphText = formatGraphCoverageText(graphCoverage);
     // SPEC-512: Compact structuredContent — essential fields only at top level
     const compactSummary = {
         specId,
@@ -346,7 +391,7 @@ export async function handleValidate(args, server) {
             return {
                 phaseEvent: createBasicPhaseEvent('validate', 'completed', 100, 'validating'),
                 content: [
-                    { type: 'text', text: compactText },
+                    { type: 'text', text: compactText + graphText },
                     {
                         type: 'text',
                         text: '⚡ INTERACTIVE — call AskUserQuestion now with the interactiveQuestions from structuredContent',
@@ -364,7 +409,7 @@ export async function handleValidate(args, server) {
             : 're-implement';
         return {
             phaseEvent: createBasicPhaseEvent('validate', 'completed', 100, 'validating'),
-            content: [{ type: 'text', text: compactText }],
+            content: [{ type: 'text', text: compactText + graphText }],
             structuredContent: {
                 ...outputWithSuggestions,
                 summary: compactSummary,
@@ -374,7 +419,7 @@ export async function handleValidate(args, server) {
     }
     return {
         phaseEvent: createBasicPhaseEvent('validate', 'completed', 100, 'validating'),
-        content: [{ type: 'text', text: compactText }],
+        content: [{ type: 'text', text: compactText + graphText }],
         structuredContent: {
             ...outputWithSuggestions,
             summary: compactSummary,

package/dist/types/index.d.ts

@@ -220,6 +220,7 @@ export * from './sentry.js';
 export * from './supabase.js';
 export * from './skill-bootstrap.js';
 export * from './technology-selection.js';
+export * from './project-knowledge-graph.js';
 export * from './compliance-gate.js';
 export * from './schema-parity.js';
 export * from './auto-update.js';

package/dist/types/index.js

@@ -217,6 +217,7 @@ export * from './sentry.js';
 export * from './supabase.js';
 export * from './skill-bootstrap.js';
 export * from './technology-selection.js';
+export * from './project-knowledge-graph.js';
 export * from './compliance-gate.js';
 export * from './schema-parity.js';
 export * from './auto-update.js';

package/dist/types/project-knowledge-graph.d.ts

@@ -0,0 +1,139 @@
+export type ProjectGraphNodeType = string;
+export type ProjectGraphEdgeType = string;
+export type ProjectGraphConfidence = 'high' | 'medium' | 'low';
+export type ProjectGraphEdgeClassification = 'extracted' | 'inferred' | 'ambiguous';
+export interface ProjectGraphPolicy {
+    version: 1;
+    graphVersion: string;
+    enabled: boolean;
+    artifactPaths: {
+        directory: string;
+        graph: string;
+        sourceHashes: string;
+    };
+    nodeTypes: string[];
+    edgeTypes: string[];
+    classifications: ProjectGraphEdgeClassification[];
+    confidenceLabels: ProjectGraphConfidence[];
+    freshness: {
+        staleAfterMinutes: number;
+    };
+    query: {
+        maxNodes: number;
+        maxEdges: number;
+        maxListItems: number;
+    };
+    redaction: {
+        maxSnippetChars: number;
+        redactPatterns: string[];
+    };
+    toolNamePatterns: string[];
+}
+export interface ProjectGraphEvidencePointer {
+    path: string;
+    selector?: string;
+    hash?: string;
+}
+export interface ProjectGraphNode {
+    id: string;
+    type: ProjectGraphNodeType;
+    label: string;
+    source: string;
+    evidence: ProjectGraphEvidencePointer[];
+    metadata?: Record<string, string | number | boolean | string[] | null>;
+    updatedAt: string;
+}
+export interface ProjectGraphEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: ProjectGraphEdgeType;
+    source: string;
+    confidence: ProjectGraphConfidence;
+    evidence: ProjectGraphEvidencePointer;
+    classification: ProjectGraphEdgeClassification;
+    updatedAt: string;
+}
+export interface ProjectKnowledgeGraph {
+    version: 1;
+    graphVersion: string;
+    projectId: string;
+    projectPath?: string;
+    generatedAt: string;
+    sourceHash: string;
+    sourceHashes: Record<string, string>;
+    metadata: {
+        nodeCount: number;
+        edgeCount: number;
+        sourceCount: number;
+        reprocessedSourceCount: number;
+        skippedSourceCount: number;
+    };
+    nodes: ProjectGraphNode[];
+    edges: ProjectGraphEdge[];
+}
+export interface ProjectGraphSource {
+    id: string;
+    kind: string;
+    path: string;
+    content: string;
+    hash: string;
+}
+export interface ProjectGraphExtractionResult {
+    nodes: ProjectGraphNode[];
+    edges: ProjectGraphEdge[];
+}
+export interface ProjectGraphBuildResult {
+    graph: ProjectKnowledgeGraph;
+    graphPath: string;
+    cachePath: string;
+    reprocessedSources: string[];
+    skippedSources: string[];
+    usedCache: boolean;
+}
+export interface ProjectGraphFreshness {
+    exists: boolean;
+    stale: boolean;
+    reason: 'missing' | 'fresh' | 'expired' | 'source_changed' | 'corrupt';
+    graphPath: string;
+    generatedAt?: string;
+    changedSources: string[];
+}
+export interface ProjectGraphSlice {
+    graphVersion: string;
+    generatedAt: string;
+    freshness: ProjectGraphFreshness;
+    nodes: ProjectGraphNode[];
+    edges: ProjectGraphEdge[];
+    summary: {
+        specs: number;
+        criteria: number;
+        files: number;
+        tests: number;
+        decisions: number;
+        risks: number;
+        tools: number;
+        releases: number;
+    };
+    tokenSavings: {
+        compactNodes: number;
+        compactEdges: number;
+        estimatedRawContextAvoided: number;
+    };
+}
+export interface ProjectGraphQueryInput {
+    projectId?: string;
+    projectPath: string;
+    specId?: string;
+    filePath?: string;
+    nodeId?: string;
+    maxNodes?: number;
+    maxEdges?: number;
+}
+export interface GraphCoverageReport {
+    freshness?: ProjectGraphFreshness;
+    gaps: string[];
+    compactNodes: number;
+    compactEdges: number;
+}
+//# sourceMappingURL=project-knowledge-graph.d.ts.map

package/dist/types/project-knowledge-graph.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project-knowledge-graph.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.6.1",
+  "version": "4.7.1",
   "description": "Planu — MCP Server for Spec Driven Development with native Rust acceleration for hot paths. Cross-platform (Linux/macOS/Windows, x64/arm64, glibc/musl).",
   "type": "module",
   "main": "dist/index.js",
@@ -34,14 +34,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.6.1",
-    "@planu/core-darwin-x64": "4.6.1",
-    "@planu/core-linux-arm64-gnu": "4.6.1",
-    "@planu/core-linux-arm64-musl": "4.6.1",
-    "@planu/core-linux-x64-gnu": "4.6.1",
-    "@planu/core-linux-x64-musl": "4.6.1",
-    "@planu/core-win32-arm64-msvc": "4.6.1",
-    "@planu/core-win32-x64-msvc": "4.6.1"
+    "@planu/core-darwin-arm64": "4.7.1",
+    "@planu/core-darwin-x64": "4.7.1",
+    "@planu/core-linux-arm64-gnu": "4.7.1",
+    "@planu/core-linux-arm64-musl": "4.7.1",
+    "@planu/core-linux-x64-gnu": "4.7.1",
+    "@planu/core-linux-x64-musl": "4.7.1",
+    "@planu/core-win32-arm64-msvc": "4.7.1",
+    "@planu/core-win32-x64-msvc": "4.7.1"
   },
   "engines": {
     "node": ">=24.0.0"
@@ -147,6 +147,7 @@
       "lodash-es": ">=4.18.0",
       "hono": ">=4.12.14",
       "postcss": ">=8.5.10",
+      "esbuild": "0.28.1",
       "fast-uri": ">=3.1.2",
       "qs": ">=6.15.2"
     },
@@ -186,11 +187,11 @@
     "@vitejs/plugin-vue": "^6.0.7",
     "@vitest/coverage-v8": "^4.1.8",
     "@vue/test-utils": "^2.4.11",
-    "eslint": "^10.4.1",
+    "eslint": "^10.5.0",
     "eslint-config-prettier": "^10.1.8",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "happy-dom": "^20.10.2",
+    "happy-dom": "^20.10.3",
     "husky": "^9.1.7",
     "javascript-obfuscator": "^5.4.3",
     "knip": "^6.16.1",

package/planu-native.json

@@ -1,7 +1,7 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "4.6.1",
+  "version": "4.7.1",
   "packageName": "@planu/cli",
   "modes": {
     "lightweight": {

package/planu-plugin.json

@@ -2,7 +2,7 @@
   "name": "dev.planu.cli",
   "displayName": "Planu — Spec Driven Development",
   "description": "Manage software specs, estimations, and autonomous SDD workflows. Language-agnostic MCP server for Claude Code.",
-  "version": "4.6.1",
+  "version": "4.7.1",
   "icon": "assets/plugin/icon.svg",
   "command": [
     "npx",