@planu/cli 4.1.3 → 4.2.0

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+## [4.2.0] - 2026-05-21
+
+**Tarball SHA-256:** `d036f3d5f73279fc0a12935995f899950fdf06afe454bba49da748183e07f477`
+
+### Features
+- feat(onboarding): add new project technology contract
+
+### Bug Fixes
+- fix(release): sync native package versions
+
+
+## [4.1.4] - 2026-05-21
+
+### Bug Fixes
+- Centralize Rust-first hot-path fallback behavior in `core-bridge` so callers use native acceleration when available and TypeScript fallbacks consistently when unavailable.
+- Keep crash scanning, broad validation reads, gaps log verification, HMAC signing, duplicate detection, and layer scanning resilient when native reads return partial results or test doubles expose older nullable bridge behavior.
+- Lock published native optional dependencies across macOS and Linux architectures in `pnpm` so release dependency checks remain cross-platform stable.
+
+### Tests
+- Re-run the full suite with 31,275 passing tests and 5 skipped tests.
+
+
 ## [4.1.3] - 2026-05-21
 
 ### Bug Fixes
@@ -3834,4 +3856,4 @@ Format: [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) · Versioning:
 - Mermaid diagram generation (architecture, sequence, state machine, ER, data flow)
 - Multi-language i18n (EN/ES/PT) for generated specs
 - Clean Architecture (hexagonal) — engine, tools, storage, types layers
-- 10,857 tests with ≥95% coverage
+- 10,857 tests with ≥95% coverage

package/dist/engine/code-scanner/layer-scanner.js

@@ -1,7 +1,7 @@
 // src/engine/code-scanner/layer-scanner.ts — Scans the 4 implementation layers (SPEC-441)
-import { readdir, readFile, stat } from 'node:fs/promises';
-import { join, relative, extname, basename } from 'node:path';
-import { isNativeActive, fastFindFilesByExt, fastFindPatterns } from '../core-bridge.js';
+import { readFile, stat } from 'node:fs/promises';
+import { join, relative, basename } from 'node:path';
+import { fastFindFilesByExt, fastReadFiles } from '../core-bridge.js';
 /**
  * Scan a project directory for evidence of spec implementation across 4 layers.
  */
@@ -11,29 +11,18 @@ export async function scanLayers(projectPath, keywords, symbolVariants) {
     const [srcExists, testsExists] = await Promise.all([dirExists(srcDir), dirExists(testsDir)]);
     let srcFiles = [];
     let testFiles = [];
-    if (isNativeActive()) {
-        if (srcExists) {
-            srcFiles = fastFindFilesByExt(srcDir, ['ts', 'js', 'tsx', 'jsx']) ?? [];
-            // Filter out .d.ts natively mapped
-            srcFiles = srcFiles.filter((f) => !f.endsWith('.d.ts'));
-        }
-        if (testsExists) {
-            testFiles = fastFindFilesByExt(testsDir, ['ts', 'js', 'tsx', 'jsx']) ?? [];
-            testFiles = testFiles.filter((f) => !f.endsWith('.d.ts'));
-        }
+    if (srcExists) {
+        srcFiles = fastFindFilesByExt(srcDir, ['ts', 'js', 'tsx', 'jsx']).filter((f) => !f.endsWith('.d.ts'));
     }
-    else {
-        [srcFiles, testFiles] = await Promise.all([
-            srcExists ? collectTsFiles(srcDir) : Promise.resolve([]),
-            testsExists ? collectTsFiles(testsDir) : Promise.resolve([]),
-        ]);
+    if (testsExists) {
+        testFiles = fastFindFilesByExt(testsDir, ['ts', 'js', 'tsx', 'jsx']).filter((f) => !f.endsWith('.d.ts'));
     }
     // Layer 1: files whose names match keywords
     const matchedFiles = srcFiles.filter((f) => keywords.some((kw) => basename(f).toLowerCase().includes(kw)));
     // Layer 2: exported symbols in matched files (and register/index files)
     const registerFiles = srcFiles.filter((f) => /register.*\.ts$|index\.ts$/.test(f));
     const filesToScanForSymbols = [...new Set([...matchedFiles, ...registerFiles])];
-    const symbols = await findSymbols(filesToScanForSymbols, symbolVariants, projectPath);
+    const symbols = findSymbols(filesToScanForSymbols, symbolVariants);
     // Layer 3: test files matching keywords
     const matchedTests = testFiles.filter((f) => keywords.some((kw) => basename(f).toLowerCase().includes(kw)));
     // Layer 4: registrations in license-plans.json and register-*.ts files
@@ -48,78 +37,22 @@ export async function scanLayers(projectPath, keywords, symbolVariants) {
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
-async function collectTsFiles(dir) {
-    const results = [];
-    try {
-        await walkDir(dir, results);
-    }
-    catch {
-        // Directory not accessible — return empty
-    }
-    return results;
-}
-async function walkDir(dir, out) {
-    let entries;
-    try {
-        entries = await readdir(dir);
-    }
-    catch {
-        return;
-    }
-    await Promise.all(entries.map(async (entry) => {
-        const full = join(dir, entry);
-        try {
-            const s = await stat(full);
-            if (s.isDirectory()) {
-                await walkDir(full, out);
-            }
-            else if (extname(entry) === '.ts' && !entry.endsWith('.d.ts')) {
-                out.push(full);
-            }
-        }
-        catch {
-            // skip
-        }
-    }));
-}
-async function findSymbols(files, variants, projectPath) {
+function findSymbols(files, variants) {
     const found = new Set();
-    if (isNativeActive() && files.length > 0) {
-        const EXPORT_RE = '^export\\s+(?:async\\s+)?(?:function|class|const|type|interface)\\s+(\\w+)';
-        const matches = fastFindPatterns(projectPath, [EXPORT_RE], [], []);
-        if (matches) {
-            const allowedPaths = new Set(files);
-            for (const m of matches) {
-                if (allowedPaths.has(m.path)) {
-                    // Rust fastFindPatterns returns the whole matched string.
-                    // Extract the group 1 (symbol name)
-                    const execMatch = new RegExp(EXPORT_RE).exec(m.content);
-                    const name = execMatch?.[1] ?? '';
-                    if (variants.some((v) => name.toLowerCase().includes(v.toLowerCase()))) {
-                        found.add(name);
-                    }
+    if (files.length > 0) {
+        const EXPORT_RE = /^export\s+(?:async\s+)?(?:function|class|const|type|interface)\s+(\w+)/gm;
+        for (const file of fastReadFiles(files)) {
+            let match;
+            while ((match = EXPORT_RE.exec(file.content)) !== null) {
+                const name = match[1] ?? '';
+                if (variants.some((v) => name.toLowerCase().includes(v.toLowerCase()))) {
+                    found.add(name);
                 }
             }
-            return [...found];
+            EXPORT_RE.lastIndex = 0;
         }
+        return [...found];
     }
-    const EXPORT_RE_NODE = /^export\s+(?:async\s+)?(?:function|class|const|type|interface)\s+(\w+)/gm;
-    await Promise.all(files.map(async (f) => {
-        let content;
-        try {
-            content = await readFile(f, 'utf8');
-        }
-        catch {
-            return;
-        }
-        let match;
-        while ((match = EXPORT_RE_NODE.exec(content)) !== null) {
-            const name = match[1] ?? '';
-            if (variants.some((v) => name.toLowerCase().includes(v.toLowerCase()))) {
-                found.add(name);
-            }
-        }
-    }));
     return [...found];
 }
 async function findRegistrations(projectPath, srcFiles, keywords) {
@@ -141,40 +74,20 @@ async function findRegistrations(projectPath, srcFiles, keywords) {
     }
     // Check register-*.ts files for registerTool calls matching keywords
     const registerFiles = srcFiles.filter((f) => /register.*\.ts$/.test(f));
-    if (isNativeActive() && registerFiles.length > 0) {
-        const REGISTER_RE = 'registerTool\\s*\\(\\s*[\'"]([^\'"]+)[\'"]';
-        const matches = fastFindPatterns(projectPath, [REGISTER_RE], [], []);
-        if (matches) {
-            const allowedPaths = new Set(registerFiles);
-            for (const m of matches) {
-                if (allowedPaths.has(m.path)) {
-                    const execMatch = new RegExp(REGISTER_RE).exec(m.content);
-                    const toolName = execMatch?.[1] ?? '';
-                    if (keywords.some((kw) => toolName.includes(kw))) {
-                        found.add(`registered:${toolName}`);
-                    }
+    if (registerFiles.length > 0) {
+        const REGISTER_RE = /registerTool\s*\(\s*['"]([^'"]+)['"]/g;
+        for (const file of fastReadFiles(registerFiles)) {
+            let match;
+            while ((match = REGISTER_RE.exec(file.content)) !== null) {
+                const toolName = match[1] ?? '';
+                if (keywords.some((kw) => toolName.includes(kw))) {
+                    found.add(`registered:${toolName}`);
                 }
             }
-            return [...found];
+            REGISTER_RE.lastIndex = 0;
         }
+        return [...found];
     }
-    const REGISTER_RE_NODE = /registerTool\s*\(\s*['"]([^'"]+)['"]/g;
-    await Promise.all(registerFiles.map(async (f) => {
-        let content;
-        try {
-            content = await readFile(f, 'utf8');
-        }
-        catch {
-            return;
-        }
-        let match;
-        while ((match = REGISTER_RE_NODE.exec(content)) !== null) {
-            const toolName = match[1] ?? '';
-            if (keywords.some((kw) => toolName.includes(kw))) {
-                found.add(`registered:${toolName}`);
-            }
-        }
-    }));
     return [...found];
 }
 async function dirExists(p) {

package/dist/engine/core-bridge.d.ts

@@ -12,12 +12,12 @@ export declare function fastScanAndHashFiles(rootPath: string): FileHash[];
 export declare function fastScanProjectMetadata(rootPath: string): FileMetadata[];
 export declare function fastScanSpecAnnotations(rootPath: string): SpecAnnotation[];
 export declare function fastCheckAcCoverage(filePaths: string[], keywords: string[]): string[];
-export declare function fastDetectDriftParallel(rootPath: string, keywords: string[]): DriftResult | null;
-export declare function fastFindDuplicateBlocks(paths: string[], minLines: number): DuplicateRawBlockRs[] | null;
-export declare function fastFindPatterns(rootPath: string, patterns: string[], extensions?: string[], exclude?: string[]): FastGrepMatch[] | null;
-export declare function fastFindFilesByName(rootPath: string, names: string[]): string[] | null;
-export declare function fastFindFilesByExt(rootPath: string, extensions: string[]): string[] | null;
-export declare function fastReadFiles(paths: string[]): FileContent[] | null;
+export declare function fastDetectDriftParallel(rootPath: string, keywords: string[]): DriftResult;
+export declare function fastFindDuplicateBlocks(paths: string[], minLines: number): DuplicateRawBlockRs[];
+export declare function fastFindPatterns(rootPath: string, patterns: string[], extensions?: string[], exclude?: string[]): FastGrepMatch[];
+export declare function fastFindFilesByName(rootPath: string, names: string[]): string[];
+export declare function fastFindFilesByExt(rootPath: string, extensions: string[]): string[];
+export declare function fastReadFiles(paths: string[]): FileContent[];
 export declare function fastScanSpecs(rootPath: string): SpecBriefRs[] | null;
 export declare function fastVerifyGapsChain(filePath: string): GapsLogChainResultRs;
 export declare function fastAppendGapEntry(filePath: string, id: string, timestamp: string, specId: string, description: string, severity: string, affectedSpecs: string[]): string;

package/dist/engine/crash-shield/index.js

@@ -7,7 +7,7 @@ import { goDetector } from './detectors/go-detector.js';
 import { rustDetector } from './detectors/rust-detector.js';
 import { javaDetector } from './detectors/java-detector.js';
 import { frameworkDetector } from './detectors/framework-detector.js';
-import { isNativeActive, fastReadFiles } from '../core-bridge.js';
+import { fastReadFiles } from '../core-bridge.js';
 export { fixCrashRisks } from './auto-fixer/index.js';
 const ALL_DETECTORS = [
     typescriptDetector,
@@ -17,7 +17,6 @@ const ALL_DETECTORS = [
     javaDetector,
     frameworkDetector,
 ];
-const FILE_SCAN_TIMEOUT_MS = 1000;
 /**
  * Scans a project for crash risks and returns a SafetyReport.
  * @param projectPath - absolute path to the project root
@@ -39,80 +38,44 @@ export async function scanCrashRisks(projectPath, stackHint) {
 }
 async function scanFiles(files, detectedStack) {
     const applicableDetectors = selectDetectors(detectedStack);
-    if (isNativeActive()) {
-        const fileContents = fastReadFiles(files);
-        if (fileContents) {
-            const results = fileContents.map(({ path, content }) => {
-                const fileDetectors = applicableDetectors.filter((d) => d.fileExtensions.some((ext) => path.endsWith(ext)));
-                const risks = [];
-                for (const detector of fileDetectors) {
-                    try {
-                        const found = detector.detect(path, content);
-                        risks.push(...found);
-                    }
-                    catch {
-                        // Detector error: skip silently
-                    }
-                }
-                return risks;
-            });
-            return results.flat();
+    const fileContents = fastReadFiles(files);
+    const seen = new Set(fileContents.map((file) => file.path));
+    const results = fileContents.map(({ path, content }) => detectRisksInContent(path, content, applicableDetectors));
+    const unreadByBridge = files.filter((file) => !seen.has(file));
+    const fallbackResults = await Promise.all(unreadByBridge.map(async (file) => {
+        try {
+            const content = await readFile(file, 'utf-8');
+            return detectRisksInContent(file, content, applicableDetectors);
         }
-    }
-    const results = await Promise.all(files.map((file) => scanSingleFile(file, applicableDetectors)));
-    return results.flat();
-}
-function selectDetectors(detectedStack) {
-    if (detectedStack.length === 0) {
-        return ALL_DETECTORS;
-    }
-    return ALL_DETECTORS.filter((detector) => {
-        if (detector.language === 'multi') {
-            return true;
+        catch {
+            return [];
         }
-        return detectedStack.includes(detector.language);
-    });
+    }));
+    return [...results, ...fallbackResults].flat();
 }
-async function scanSingleFile(file, detectors) {
-    const applicableDetectors = detectors.filter((d) => d.fileExtensions.some((ext) => file.endsWith(ext)));
-    if (applicableDetectors.length === 0) {
-        return [];
-    }
-    let content;
-    try {
-        content = await withTimeout(readFile(file, 'utf-8'), FILE_SCAN_TIMEOUT_MS, file);
-    }
-    catch {
-        return [];
-    }
+function detectRisksInContent(path, content, applicableDetectors) {
+    const fileDetectors = applicableDetectors.filter((d) => d.fileExtensions.some((ext) => path.endsWith(ext)));
     const risks = [];
-    for (const detector of applicableDetectors) {
+    for (const detector of fileDetectors) {
         try {
-            const found = detector.detect(file, content);
+            const found = detector.detect(path, content);
             risks.push(...found);
         }
         catch {
-            /* c8 ignore next */
             // Detector error: skip silently
         }
     }
     return risks;
 }
-async function withTimeout(promise, ms, file) {
-    return new Promise((resolve, reject) => {
-        /* c8 ignore next 3 */
-        const timer = setTimeout(() => {
-            reject(new Error(`Scan timeout for file: ${file}`));
-        }, ms);
-        promise.then((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        }, 
-        /* c8 ignore next 4 */
-        (err) => {
-            clearTimeout(timer);
-            reject(err instanceof Error ? err : new Error(String(err)));
-        });
+function selectDetectors(detectedStack) {
+    if (detectedStack.length === 0) {
+        return ALL_DETECTORS;
+    }
+    return ALL_DETECTORS.filter((detector) => {
+        if (detector.language === 'multi') {
+            return true;
+        }
+        return detectedStack.includes(detector.language);
     });
 }
 //# sourceMappingURL=index.js.map

package/dist/engine/detect-duplication.js

@@ -10,24 +10,6 @@ const LANGUAGE_EXTENSIONS = {
     typescript: ['.ts', '.tsx'],
     javascript: ['.js', '.jsx', '.mjs', '.cjs'],
 };
-/**
- * Normalize a single line: remove inline comments, trim, lowercase.
- */
-function normalizeLine(line) {
-    let trimmed = line;
-    // Remove single-line comments (but not URLs like http://)
-    const commentIdx = trimmed.indexOf('//');
-    if (commentIdx >= 0) {
-        trimmed = trimmed.slice(0, commentIdx);
-    }
-    return trimmed.trim().toLowerCase();
-}
-/**
- * Remove multi-line comment blocks from source text.
- */
-function stripMultilineComments(text) {
-    return text.replace(/\/\*[\s\S]*?\*\//g, '');
-}
 /**
  * Build glob patterns for the requested languages.
  */
@@ -46,6 +28,24 @@ function buildIgnorePatterns(userExclude) {
     const user = userExclude ?? [];
     return [...DEFAULT_EXCLUDE, ...user];
 }
+/**
+ * Normalize a single line: remove inline comments, trim, lowercase.
+ */
+function normalizeLine(line) {
+    let trimmed = line;
+    // Remove single-line comments (but not URLs like http://)
+    const commentIdx = trimmed.indexOf('//');
+    if (commentIdx >= 0) {
+        trimmed = trimmed.slice(0, commentIdx);
+    }
+    return trimmed.trim().toLowerCase();
+}
+/**
+ * Remove multi-line comment blocks from source text.
+ */
+function stripMultilineComments(text) {
+    return text.replace(/\/\*[\s\S]*?\*\//g, '');
+}
 /**
  * Hash an array of normalized lines using SHA-256 (first 16 chars for speed).
  */
@@ -153,7 +153,47 @@ function buildSuggestion(cluster) {
     }
     return `Extract ${String(lineCount)} lines from ${first.path}:${String(first.startLine)} and ${second.path}:${String(second.startLine)} into shared utility`;
 }
-import { isNativeActive, fastFindDuplicateBlocks } from './core-bridge.js';
+import { fastFindDuplicateBlocks } from './core-bridge.js';
+async function detectDuplicateBlocksFallback(uniqueFiles, minLines) {
+    const hashMap = new Map();
+    for (const filePath of uniqueFiles) {
+        let content;
+        try {
+            content = await readFile(filePath, 'utf-8');
+        }
+        catch {
+            continue;
+        }
+        content = stripMultilineComments(content);
+        const rawLines = content.split('\n');
+        const blocks = extractBlocks(filePath, rawLines, minLines);
+        for (const block of blocks) {
+            const h = hashLines(block.lines);
+            const existing = hashMap.get(h) ?? [];
+            existing.push(block);
+            hashMap.set(h, existing);
+        }
+    }
+    const rawClusters = [];
+    for (const [h, locations] of hashMap.entries()) {
+        if (locations.length >= 2) {
+            rawClusters.push({ hash: h, locations });
+        }
+    }
+    return rawClusters;
+}
+function isDuplicateRawBlockArray(value) {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    return value.every((item) => {
+        if (typeof item !== 'object' || item === null) {
+            return false;
+        }
+        const candidate = item;
+        return typeof candidate.hash === 'string' && Array.isArray(candidate.locations);
+    });
+}
 /**
  * Detect code duplication across project files.
  */
@@ -173,40 +213,10 @@ export async function detectDuplication(input) {
     }
     // Deduplicate file list
     const uniqueFiles = [...new Set(allFiles)];
-    let rawClusters = [];
-    if (isNativeActive()) {
-        const nativeBlocks = fastFindDuplicateBlocks(uniqueFiles, minLines);
-        if (nativeBlocks) {
-            rawClusters = nativeBlocks;
-        }
-    }
-    else {
-        const hashMap = new Map();
-        for (const filePath of uniqueFiles) {
-            let content;
-            try {
-                content = await readFile(filePath, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            content = stripMultilineComments(content);
-            const rawLines = content.split('\n');
-            const blocks = extractBlocks(filePath, rawLines, minLines);
-            for (const block of blocks) {
-                const h = hashLines(block.lines);
-                const existing = hashMap.get(h) ?? [];
-                existing.push(block);
-                hashMap.set(h, existing);
-            }
-        }
-        // Find collisions (same hash, different files or different locations)
-        for (const [h, locations] of hashMap.entries()) {
-            if (locations.length >= 2) {
-                rawClusters.push({ hash: h, locations });
-            }
-        }
-    }
+    const bridgeResult = fastFindDuplicateBlocks(uniqueFiles, minLines);
+    const rawClusters = isDuplicateRawBlockArray(bridgeResult)
+        ? bridgeResult
+        : await detectDuplicateBlocksFallback(uniqueFiles, minLines);
     // Group locations into clusters, merging per-file overlaps
     const clusters = [];
     let clusterId = 0;

package/dist/engine/drift-monitor.js

@@ -281,7 +281,7 @@ async function computeAcCoverageScore(criteria, filePaths) {
         }
         const rootPath = path.dirname(firstFile); // Use first file's dir as heuristic
         const result = fastDetectDriftParallel(rootPath, [...allTerms]);
-        foundTerms = new Set(result?.foundKeywords ?? []);
+        foundTerms = new Set(result.foundKeywords);
     }
     else {
         // Fallback: Read all implementation files once

package/dist/engine/onboarding/new-project-resolver.d.ts

@@ -0,0 +1,7 @@
+import type { InteractiveQuestion, NewProjectOnboardingInput, NewProjectQuestionState, NewProjectResolution } from '../../types/index.js';
+export declare function slugifyAppName(input: string): string;
+export declare function validateAppSlug(slug: string): string | null;
+export declare function resolveNewProjectPath(parentWorkspacePath: string, appSlug: string): string;
+export declare function buildNewProjectQuestions(input: NewProjectOnboardingInput, resolved: NewProjectQuestionState): InteractiveQuestion[];
+export declare function resolveNewProjectOnboarding(input: NewProjectOnboardingInput): Promise<NewProjectResolution>;
+//# sourceMappingURL=new-project-resolver.d.ts.map