@planu/cli 4.10.7 → 4.10.8

package/CHANGELOG.md

@@ -1,3 +1,13 @@
+## [4.10.8] - 2026-07-07
+
+### Refactoring
+- refactor: merge SPEC-1113 native performance benchmark
+- refactor: benchmark native mcp performance
+
+### Chores
+- chore: exclude generated performance report
+
+
 ## [4.10.7] - 2026-07-07
 
 ### Bug Fixes

package/dist/tools/validate-lint.d.ts

@@ -1,3 +1,8 @@
 import type { LintCheckResult } from '../types/index.js';
-export declare function runLintCheck(projectPath: string, lintCommand: string | null): LintCheckResult;
+interface LintCheckContext {
+    projectId?: string;
+    specId?: string;
+}
+export declare function runLintCheck(projectPath: string, lintCommand: string | null, _context?: LintCheckContext): LintCheckResult;
+export {};
 //# sourceMappingURL=validate-lint.d.ts.map

package/dist/tools/validate-lint.js

@@ -1,7 +1,13 @@
+// tools/validate-lint.ts — Lint gate for validate.
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
 import { formatLintFailureDiagnostics, resolveProjectCommandPlan, runProjectCommandPlan, } from './validate-runtime.js';
 /** Allowlist: alphanumerics, spaces, and safe shell chars. Rejects ; | $ ` & < > */
 const SAFE_COMMAND_RE = /^[\w\s./:@~=-]+$/;
-const LINT_CHECK_TIMEOUT_MS = 50_000;
+const DEFAULT_LINT_CHECK_TIMEOUT_MS = 10_000;
+const LINT_CACHE_MAX_AGE_MS = 24 * 60 * 60 * 1000;
 function isSafeCommand(cmd) {
     return SAFE_COMMAND_RE.test(cmd);
 }
@@ -33,7 +39,7 @@ function parseLintIssueCount(output) {
     }
     return output.split('\n').filter((l) => l.trim().length > 0).length;
 }
-export function runLintCheck(projectPath, lintCommand) {
+export function runLintCheck(projectPath, lintCommand, _context = {}) {
     if (lintCommand !== null && !isSafeCommand(lintCommand)) {
         console.warn(`[Planu] validate: lintCommand contains unsafe characters — skipping execution`);
         return {
@@ -45,16 +51,23 @@ export function runLintCheck(projectPath, lintCommand) {
     }
     const command = lintCommand ?? 'pnpm lint';
     const plan = resolveProjectCommandPlan(projectPath, command);
+    const fingerprint = calculateLintFingerprint(projectPath);
+    const cached = readPassedLintCache(projectPath, command, fingerprint);
+    if (cached !== null) {
+        return cached;
+    }
+    const timeoutMs = lintCheckTimeoutMs();
     try {
-        runProjectCommandPlan(plan, projectPath, LINT_CHECK_TIMEOUT_MS);
+        runProjectCommandPlan(plan, projectPath, timeoutMs);
+        writePassedLintCache(projectPath, command, fingerprint);
         return { passed: true, command, issueCount: 0, output: '' };
     }
     catch (err) {
         if (isCommandTimeout(err)) {
-            const seconds = Math.round(LINT_CHECK_TIMEOUT_MS / 1000);
+            const seconds = Math.round(timeoutMs / 1000);
             const output = `Lint command timed out after ${String(seconds)}s and was skipped so validate can complete within MCP request limits. ` +
-                `Run \`${plan.executedCommand}\` manually before marking the spec done.`;
-            console.warn(`[Planu] lintCheck timed out: command="${plan.executedCommand}" cwd="${projectPath}" timeoutMs=${String(LINT_CHECK_TIMEOUT_MS)}`);
+                `Run \`${plan.executedCommand}\` manually before marking the spec done, or set PLANU_VALIDATE_LINT_TIMEOUT_MS for an explicit full lint pass.`;
+            console.warn(`[Planu] lintCheck timed out: command="${plan.executedCommand}" cwd="${projectPath}" timeoutMs=${String(timeoutMs)}`);
             return { passed: false, command, issueCount: 1, output };
         }
         const raw = commandOutput(err);
@@ -64,4 +77,124 @@ export function runLintCheck(projectPath, lintCommand) {
         return { passed: false, command, issueCount, output };
     }
 }
+function lintCheckTimeoutMs() {
+    const raw = process.env.PLANU_VALIDATE_LINT_TIMEOUT_MS;
+    if (raw === undefined || raw.trim() === '') {
+        return DEFAULT_LINT_CHECK_TIMEOUT_MS;
+    }
+    const parsed = Number.parseInt(raw, 10);
+    if (!Number.isFinite(parsed)) {
+        return DEFAULT_LINT_CHECK_TIMEOUT_MS;
+    }
+    return Math.min(300_000, Math.max(1_000, parsed));
+}
+function lintCachePath(projectPath) {
+    return join(projectPath, 'planu', 'state', 'lint-evidence.json');
+}
+function readPassedLintCache(projectPath, command, fingerprint) {
+    try {
+        const path = lintCachePath(projectPath);
+        if (!existsSync(path)) {
+            return null;
+        }
+        const cache = JSON.parse(readFileSync(path, 'utf-8'));
+        if (cache.schemaVersion !== '1.0.0' ||
+            cache.command !== command ||
+            cache.fingerprint !== fingerprint ||
+            typeof cache.checkedAt !== 'string') {
+            return null;
+        }
+        const ageMs = Date.now() - Date.parse(cache.checkedAt);
+        if (!Number.isFinite(ageMs) || ageMs < 0 || ageMs > LINT_CACHE_MAX_AGE_MS) {
+            return null;
+        }
+        return {
+            passed: true,
+            command,
+            issueCount: 0,
+            output: `(reused local lint evidence from ${cache.checkedAt})`,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function writePassedLintCache(projectPath, command, fingerprint) {
+    try {
+        const path = lintCachePath(projectPath);
+        mkdirSync(dirname(path), { recursive: true });
+        const cache = {
+            schemaVersion: '1.0.0',
+            command,
+            fingerprint,
+            checkedAt: new Date().toISOString(),
+        };
+        writeFileSync(path, `${JSON.stringify(cache, null, 2)}\n`, 'utf-8');
+    }
+    catch {
+        // Cache is a performance optimization only; lint result remains authoritative.
+    }
+}
+function calculateLintFingerprint(projectPath) {
+    const hash = createHash('sha256');
+    hash.update(gitOutput(projectPath, ['rev-parse', 'HEAD']));
+    hash.update('\0');
+    hash.update(gitOutput(projectPath, [
+        'diff',
+        '--binary',
+        'HEAD',
+        '--',
+        'src',
+        'tests',
+        'package.json',
+        'pnpm-lock.yaml',
+        'eslint.config.js',
+        'eslint.config.mjs',
+        'eslint.config.cjs',
+        'tsconfig.json',
+        'tsconfig.build.json',
+    ]));
+    hash.update('\0');
+    const untracked = gitOutput(projectPath, [
+        'ls-files',
+        '--others',
+        '--exclude-standard',
+        '--',
+        'src',
+        'tests',
+    ])
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .sort();
+    for (const file of untracked) {
+        hash.update(file);
+        hash.update('\0');
+        try {
+            hash.update(readFileSync(join(projectPath, file)));
+        }
+        catch {
+            hash.update('unreadable');
+        }
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function gitOutput(projectPath, args) {
+    try {
+        const output = execFileSync('git', args, {
+            cwd: projectPath,
+            encoding: 'utf-8',
+            timeout: 5_000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        if (Buffer.isBuffer(output)) {
+            return output.toString('utf-8');
+        }
+        return typeof output === 'string' ? output : String(output);
+    }
+    catch {
+        return '';
+    }
+}
 //# sourceMappingURL=validate-lint.js.map

package/dist/tools/validate.js

@@ -72,7 +72,10 @@ export async function handleValidate(args, server) {
     const implementationQualityScore = calcQualityScore(result.qualityIssues);
     const auditedFiles = [...new Set(result.qualityIssues.map((i) => i.file))];
     const { conventionViolations, regressionDetected } = await scanProjectConventions(projectId, projectPath);
-    const lintCheck = runLintCheck(projectPath, knowledge.lintCommand ?? null);
+    const lintCheck = runLintCheck(projectPath, knowledge.lintCommand ?? null, {
+        projectId,
+        specId,
+    });
     const assuranceGates = runAssuranceGates(projectPath);
     const minimalityReport = await buildMinimalityReport({
         projectPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.10.7",
+  "version": "4.10.8",
   "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.10.7",
-    "@planu/core-darwin-x64": "4.10.7",
-    "@planu/core-linux-arm64-gnu": "4.10.7",
-    "@planu/core-linux-arm64-musl": "4.10.7",
-    "@planu/core-linux-x64-gnu": "4.10.7",
-    "@planu/core-linux-x64-musl": "4.10.7",
-    "@planu/core-win32-arm64-msvc": "4.10.7",
-    "@planu/core-win32-x64-msvc": "4.10.7"
+    "@planu/core-darwin-arm64": "4.10.8",
+    "@planu/core-darwin-x64": "4.10.8",
+    "@planu/core-linux-arm64-gnu": "4.10.8",
+    "@planu/core-linux-arm64-musl": "4.10.8",
+    "@planu/core-linux-x64-gnu": "4.10.8",
+    "@planu/core-linux-x64-musl": "4.10.8",
+    "@planu/core-win32-arm64-msvc": "4.10.8",
+    "@planu/core-win32-x64-msvc": "4.10.8"
   },
   "engines": {
     "node": ">=24.0.0"

package/planu-native.json

@@ -1,7 +1,7 @@
 {
   "name": "dev.planu.native",
   "displayName": "Planu Native Lightweight Surface",
-  "version": "4.10.7",
+  "version": "4.10.8",
   "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.10.7",
+  "version": "4.10.8",
   "icon": "assets/plugin/icon.svg",
   "command": [
     "npx",