@planu/cli 4.1.3 → 4.2.0

package/dist/engine/onboarding/new-project-resolver.js

@@ -0,0 +1,265 @@
+// engine/onboarding/new-project-resolver.ts — SPEC-1021 safe new-project onboarding
+import { mkdir } from 'node:fs/promises';
+import path, { resolve } from 'node:path';
+import { findDocsEntry, loadDocsRegistry } from '../web-fetcher/registry-loader.js';
+const NONE_LABELS = new Set(['none', 'no framework', 'ninguno', 'sin framework', 'n/a']);
+const UNSURE_LABELS = new Set(['not sure', 'unsure', 'no estoy seguro', 'not-sure']);
+function answer(input, key) {
+    const value = input.clarificationAnswers?.[key] ?? input.clarificationAnswers?.[key.toLowerCase()];
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+function valueOrAnswer(explicit, input, key) {
+    if (typeof explicit === 'string' && explicit.trim().length > 0) {
+        return explicit.trim();
+    }
+    return answer(input, key);
+}
+function normalizeNullableTech(value) {
+    if (value === null) {
+        return null;
+    }
+    const trimmed = value?.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    const lower = trimmed.toLowerCase();
+    if (NONE_LABELS.has(lower)) {
+        return null;
+    }
+    if (UNSURE_LABELS.has(lower)) {
+        return undefined;
+    }
+    return trimmed;
+}
+export function slugifyAppName(input) {
+    return input
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, '-')
+        .replace(/[-.]{2,}/g, '-')
+        .replace(/^[-.]+|[-.]+$/g, '');
+}
+export function validateAppSlug(slug) {
+    if (!slug) {
+        return 'App folder is required.';
+    }
+    if (slug === '.' || slug === '..' || slug.includes('/') || slug.includes('\\')) {
+        return 'App folder must be a simple folder name, not a path.';
+    }
+    if (slug.includes('..')) {
+        return 'App folder cannot contain path traversal.';
+    }
+    return null;
+}
+function isWinPath(value) {
+    return /^[a-zA-Z]:[\\/]/.test(value) || value.startsWith('\\\\');
+}
+export function resolveNewProjectPath(parentWorkspacePath, appSlug) {
+    const slugError = validateAppSlug(appSlug);
+    if (slugError) {
+        throw new Error(slugError);
+    }
+    if (isWinPath(parentWorkspacePath)) {
+        return path.win32.normalize(path.win32.join(parentWorkspacePath, appSlug));
+    }
+    return resolve(parentWorkspacePath, appSlug);
+}
+function buildQuestion(header, question, recommended, alternate, fallback) {
+    return {
+        header,
+        question,
+        multiSelect: false,
+        options: [
+            { label: `${recommended} (Recommended)`, description: `Use "${recommended}".` },
+            { label: alternate, description: `Use "${alternate}".` },
+            { label: fallback, description: `Use "${fallback}" or provide another value.` },
+        ],
+    };
+}
+function buildRequiredQuestions(input, resolved) {
+    const suggestedSlug = slugifyAppName(input.appName ?? input.description).slice(0, 48) || 'new-app';
+    const specs = [
+        [
+            !resolved.parentWorkspacePath,
+            buildQuestion('Parent', 'Which parent workspace should contain the new app folder?', process.cwd(), input.projectPath ?? './', 'Custom path'),
+        ],
+        [
+            !resolved.appSlug,
+            buildQuestion('App Folder', 'What should the new app folder be called?', suggestedSlug, 'api', 'Custom folder'),
+        ],
+        [
+            !resolved.projectType,
+            buildQuestion('Project Type', 'What type of project are you creating?', 'api', 'web app', 'Custom type'),
+        ],
+        [
+            !resolved.platform,
+            buildQuestion('Platform', 'Where will this project run?', 'server', 'web', 'Custom platform'),
+        ],
+        [
+            !resolved.languageAnswered,
+            buildQuestion('Language', 'Which programming language should this project use?', 'Not sure', 'Use project/team default', 'Custom language'),
+        ],
+        [
+            !resolved.frameworkAnswered,
+            buildQuestion('Framework', 'Which framework should this project use?', 'Not sure', 'No framework', 'Custom framework'),
+        ],
+    ];
+    return specs.filter(([missing]) => missing).map(([, question]) => question);
+}
+function buildCreateDirectoryQuestion() {
+    return {
+        header: 'Create Dir',
+        question: 'May Planu create the project folder if it does not exist?',
+        multiSelect: false,
+        options: [
+            { label: 'yes (Recommended)', description: 'Create only the resolved app folder.' },
+            { label: 'no', description: 'Do not create folders; I will create it myself.' },
+            { label: 'already exists', description: 'The project folder already exists.' },
+        ],
+    };
+}
+export function buildNewProjectQuestions(input, resolved) {
+    const questions = buildRequiredQuestions(input, resolved);
+    if (!resolved.createDirectoryAnswered) {
+        questions.push(buildCreateDirectoryQuestion());
+    }
+    return questions;
+}
+async function verifyDocs(names) {
+    const registry = await loadDocsRegistry();
+    return names
+        .filter((name) => name.trim().length > 0)
+        .map((name) => {
+        const entry = findDocsEntry(name, registry);
+        if (entry) {
+            return { name, url: entry.base, status: 'verified' };
+        }
+        return {
+            name,
+            url: '',
+            status: 'unverified',
+            reason: 'No official docs registry entry found.',
+        };
+    });
+}
+function collectResolvedFields(input) {
+    const parentWorkspacePath = valueOrAnswer(input.parentWorkspacePath, input, 'Parent') ??
+        valueOrAnswer(input.projectPath, input, 'Parent');
+    const appName = valueOrAnswer(input.appName, input, 'App Folder');
+    const appSlug = valueOrAnswer(input.appSlug, input, 'App Folder') ??
+        (appName ? slugifyAppName(appName) : undefined);
+    const projectType = valueOrAnswer(input.projectType, input, 'Project Type');
+    const platform = valueOrAnswer(input.platform, input, 'Platform');
+    const rawLanguage = valueOrAnswer(input.language, input, 'Language');
+    const rawFramework = input.framework === null ? null : valueOrAnswer(input.framework, input, 'Framework');
+    const rawDatabase = input.database === null ? null : valueOrAnswer(input.database, input, 'Database');
+    const language = normalizeNullableTech(rawLanguage);
+    const framework = normalizeNullableTech(rawFramework);
+    const database = normalizeNullableTech(rawDatabase);
+    const createDirAnswer = answer(input, 'Create Dir')?.toLowerCase();
+    const languageAnswered = rawLanguage !== undefined;
+    const frameworkAnswered = rawFramework !== undefined;
+    const createDirectoryAnswered = input.createDirectory !== undefined || createDirAnswer !== undefined;
+    const createDirectory = input.createDirectory === true ||
+        createDirAnswer === 'yes' ||
+        createDirAnswer === 'yes (recommended)' ||
+        createDirAnswer === 'already exists';
+    const errors = appSlug ? [validateAppSlug(appSlug)].filter((e) => Boolean(e)) : [];
+    const resolvedProjectPath = parentWorkspacePath && appSlug && errors.length === 0
+        ? resolveNewProjectPath(parentWorkspacePath, appSlug)
+        : undefined;
+    return {
+        parentWorkspacePath,
+        appName,
+        appSlug,
+        projectType,
+        platform,
+        language: language ?? undefined,
+        framework,
+        database,
+        languageAnswered,
+        frameworkAnswered,
+        createDirectoryAnswered,
+        createDirectory,
+        resolvedProjectPath,
+        errors,
+    };
+}
+function isReady(fields) {
+    return Boolean(fields.parentWorkspacePath &&
+        fields.appSlug &&
+        fields.projectType &&
+        fields.platform &&
+        fields.languageAnswered &&
+        fields.frameworkAnswered &&
+        fields.createDirectoryAnswered &&
+        fields.createDirectory &&
+        fields.resolvedProjectPath &&
+        fields.errors.length === 0);
+}
+async function buildTechnologyContract(input, fields) {
+    const resolvedProjectPath = fields.resolvedProjectPath;
+    if (!resolvedProjectPath) {
+        throw new Error('Resolved project path is required to build a technology contract.');
+    }
+    const docNames = [fields.language, fields.framework, fields.database].filter((name) => typeof name === 'string' && name.length > 0);
+    const officialDocs = await verifyDocs(docNames);
+    return {
+        mode: 'new_project',
+        projectPath: resolvedProjectPath,
+        parentWorkspacePath: fields.parentWorkspacePath,
+        appName: fields.appName,
+        appSlug: fields.appSlug,
+        projectType: fields.projectType,
+        platform: fields.platform,
+        language: fields.language,
+        framework: fields.framework ?? null,
+        database: fields.database ?? null,
+        source: 'user-confirmed',
+        evidence: [
+            `User requested a new project: ${input.description}`,
+            `Resolved project folder: ${resolvedProjectPath}`,
+        ],
+        officialDocs,
+        verifiedAt: new Date().toISOString(),
+    };
+}
+export async function resolveNewProjectOnboarding(input) {
+    const fields = collectResolvedFields(input);
+    if (!isReady(fields)) {
+        return {
+            ready: false,
+            parentWorkspacePath: fields.parentWorkspacePath,
+            resolvedProjectPath: fields.resolvedProjectPath,
+            appSlug: fields.appSlug,
+            questions: buildNewProjectQuestions(input, {
+                parentWorkspacePath: fields.parentWorkspacePath,
+                appSlug: fields.appSlug,
+                projectType: fields.projectType,
+                platform: fields.platform,
+                language: fields.language,
+                framework: fields.framework,
+                languageAnswered: fields.languageAnswered,
+                frameworkAnswered: fields.frameworkAnswered,
+                createDirectoryAnswered: fields.createDirectoryAnswered,
+            }),
+            errors: fields.errors,
+        };
+    }
+    const resolvedProjectPath = fields.resolvedProjectPath;
+    if (!resolvedProjectPath) {
+        throw new Error('Resolved project path is required before directory creation.');
+    }
+    await mkdir(resolvedProjectPath, { recursive: true });
+    const contract = await buildTechnologyContract(input, fields);
+    return {
+        ready: true,
+        parentWorkspacePath: fields.parentWorkspacePath,
+        resolvedProjectPath: fields.resolvedProjectPath,
+        appSlug: fields.appSlug,
+        questions: [],
+        contract,
+        errors: fields.errors,
+    };
+}
+//# sourceMappingURL=new-project-resolver.js.map

package/dist/engine/reviewer-tokens/signer.js

@@ -1,8 +1,8 @@
 // engine/reviewer-tokens/signer.ts — HMAC-SHA256 sign/verify for reviewer tokens (SPEC-722)
-import { createHmac, randomBytes } from 'node:crypto';
+import { randomBytes } from 'node:crypto';
 import { readFile, writeFile, mkdir, appendFile } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
-import { isNativeActive, fastHmacSign, fastHmacVerify } from '../core-bridge.js';
+import { fastHmacSign, fastHmacVerify } from '../core-bridge.js';
 const SECRET_FILENAME = '.planu-secret';
 const GITIGNORE_ENTRY = '.planu-secret\n';
 let cachedSecret = null;
@@ -55,29 +55,11 @@ export function canonicalJson(obj) {
 }
 /** Compute HMAC-SHA256 over `data` using `secret`. Returns hex digest. */
 export function hmacSign(secret, data) {
-    if (isNativeActive()) {
-        const sig = fastHmacSign(secret, data);
-        if (sig) {
-            return sig;
-        }
-    }
-    return createHmac('sha256', secret).update(data).digest('hex');
+    return fastHmacSign(secret, data);
 }
 /** Verify a previously computed HMAC-SHA256 signature. Constant-time compare via crypto. */
 export function hmacVerify(secret, data, signature) {
-    if (isNativeActive()) {
-        return fastHmacVerify(secret, data, signature);
-    }
-    const expected = hmacSign(secret, data);
-    // Constant-time comparison to prevent timing attacks.
-    if (expected.length !== signature.length) {
-        return false;
-    }
-    let mismatch = 0;
-    for (let i = 0; i < expected.length; i++) {
-        mismatch |= expected.charCodeAt(i) ^ signature.charCodeAt(i);
-    }
-    return mismatch === 0;
+    return fastHmacVerify(secret, data, signature);
 }
 /** Reset cached secret (test helper only — not exported from index). */
 export function _resetSecretCache() {

package/dist/engine/scan-project/module-discoverer.js

@@ -212,16 +212,14 @@ async function detectMonorepo(projectPath) {
     if (isNativeActive()) {
         // Rust: optimized directory resolution for monorepo patterns
         const pkgJsonPaths = fastFindFilesByName(projectPath, ['package.json']);
-        if (pkgJsonPaths) {
-            // Filter directories that match the workspace globs (simplified heuristic)
-            const dirs = pkgJsonPaths
-                .map((p) => dirname(p))
-                .map((p) => relative(projectPath, p))
-                .filter((rel) => rel !== '' && !isIgnored(rel.split('/')[0] ?? ''));
-            // In a real implementation we would match against workspaceGlobs exactly,
-            // but for speed we take all dirs with package.json that aren't ignored.
-            resolved.push(...dirs);
-        }
+        // Filter directories that match the workspace globs (simplified heuristic).
+        const dirs = pkgJsonPaths
+            .map((p) => dirname(p))
+            .map((p) => relative(projectPath, p))
+            .filter((rel) => rel !== '' && !isIgnored(rel.split('/')[0] ?? ''));
+        // In a real implementation we would match against workspaceGlobs exactly,
+        // but for speed we take all dirs with package.json that aren't ignored.
+        resolved.push(...dirs);
     }
     if (resolved.length === 0) {
         for (const pattern of workspaceGlobs) {
@@ -258,7 +256,7 @@ async function detectMonorepo(projectPath) {
 async function detectPackageBased(projectPath) {
     if (isNativeActive()) {
         const manifests = fastFindFilesByName(projectPath, PACKAGE_MANIFESTS);
-        if (manifests && manifests.length > 0) {
+        if (manifests.length > 0) {
             const modules = [];
             const seen = new Set();
             for (const m of manifests) {

package/dist/engine/spec-migrator/strict-planu-cleanup.js

@@ -171,7 +171,8 @@ export async function validateStrictPlanuLayout(projectPath) {
     for (const entry of entries) {
         const full = join(planuDir, entry);
         const isDir = await pathIsDirectory(full);
-        if ((isDir && !isCanonicalPlanuRootDir(entry)) || (!isDir && !isCanonicalPlanuRootFile(entry))) {
+        if ((isDir && !isCanonicalPlanuRootDir(entry)) ||
+            (!isDir && !isCanonicalPlanuRootFile(entry))) {
             offenders.push(relative(projectPath, full));
         }
     }

package/dist/engine/validator/analyzer.js

@@ -7,7 +7,7 @@ import { glob } from 'glob';
 import { z } from 'zod';
 const BROAD_SCAN_IGNORE = ['node_modules/**', 'dist/**', 'build/**', '.git/**'];
 const BROAD_SCAN_MAX = 300;
-import { isNativeActive, fastReadFiles } from '../core-bridge.js';
+import { fastReadFiles } from '../core-bridge.js';
 /**
  * Build a file-contents cache for a broader search across the project.
  * Caps at BROAD_SCAN_MAX files to bound I/O on large repos.
@@ -21,18 +21,21 @@ async function buildBroadCache(projectPath) {
             ignore: BROAD_SCAN_IGNORE,
             maxDepth: 5,
         });
-        if (isNativeActive()) {
-            const results = fastReadFiles(files.map((f) => join(projectPath, f)));
-            if (results) {
-                for (const res of results) {
-                    cache.set(relative(projectPath, res.path), res.content);
-                }
-                return cache;
-            }
+        const cappedFiles = files.slice(0, BROAD_SCAN_MAX);
+        const absoluteFiles = cappedFiles.map((f) => join(projectPath, f));
+        const results = fastReadFiles(absoluteFiles);
+        const loaded = new Set();
+        for (const res of results) {
+            cache.set(relative(projectPath, res.path), res.content);
+            loaded.add(res.path);
         }
-        await Promise.all(files.slice(0, BROAD_SCAN_MAX).map(async (file) => {
+        await Promise.all(cappedFiles.map(async (file, index) => {
+            const absPath = absoluteFiles[index];
+            if (!absPath || loaded.has(absPath)) {
+                return;
+            }
             try {
-                const content = await readFile(join(projectPath, file), 'utf-8');
+                const content = await readFile(absPath, 'utf-8');
                 cache.set(file, content);
             }
             catch {

package/dist/engine/validator/deep-code-checker.js

@@ -115,12 +115,13 @@ async function resolveFiles(scopeGlob, projectPath, exclude) {
         return [];
     }
 }
+// ─── Checkers ─────────────────────────────────────────────────────────────────
+import { isNativeActive, fastFindPatterns } from '../core-bridge.js';
 function buildRegex(pattern) {
     try {
         return new RegExp(pattern, 'g');
     }
     catch {
-        // If pattern is not a valid regex, escape it
         try {
             const escaped = RegExp.escape(pattern);
             return new RegExp(escaped, 'g');
@@ -130,8 +131,6 @@ function buildRegex(pattern) {
         }
     }
 }
-// ─── Checkers ─────────────────────────────────────────────────────────────────
-import { isNativeActive, fastFindPatterns } from '../core-bridge.js';
 /**
  * Search for a regex pattern in files matching the scope glob.
  * For grep_absent: passed when matchCount === 0.
@@ -140,11 +139,8 @@ import { isNativeActive, fastFindPatterns } from '../core-bridge.js';
 export async function grepCheck(config, projectPath, checkType) {
     const evidence = [];
     if (isNativeActive()) {
-        // Rust: optimized parallel search
         const results = fastFindPatterns(projectPath, [config.pattern], [], config.exclude ? [config.exclude] : []);
-        if (results) {
-            evidence.push(...results.map((r) => `${relative(projectPath, r.path)}:${r.line}`));
-        }
+        evidence.push(...results.map((r) => `${relative(projectPath, r.path)}:${r.line}`));
     }
     else {
         const files = await resolveFiles(config.scope, projectPath, config.exclude);
@@ -159,7 +155,7 @@ export async function grepCheck(config, projectPath, checkType) {
                         const line = lines[i];
                         if (line !== undefined && regex.test(line)) {
                             evidence.push(`${file}:${i + 1}`);
-                            regex.lastIndex = 0; // reset for global flag
+                            regex.lastIndex = 0;
                         }
                     }
                 }

package/dist/storage/base-store.js

@@ -3,9 +3,8 @@
 import { readFile, mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
-import { createHash } from 'node:crypto';
 import { writeJsonSafe } from '../engine/safety/atomic-writer.js';
-import { fastHashProjectPath, isNativeActive } from '../engine/core-bridge.js';
+import { fastHashProjectPath } from '../engine/core-bridge.js';
 /**
  * Runtime-safe JSON.parse with typed fallback.
  *
@@ -37,10 +36,7 @@ export function safeJsonParse(raw, fallback) {
  * Hash a project path into a deterministic projectId using SHA-256.
  */
 export function hashProjectPath(projectPath) {
-    if (isNativeActive()) {
-        return fastHashProjectPath(projectPath);
-    }
-    return createHash('sha256').update(projectPath).digest('hex').slice(0, 16);
+    return fastHashProjectPath(projectPath).slice(0, 16);
 }
 /**
  * Ensure the parent directory for a file path exists.

package/dist/storage/gaps-log.js

@@ -7,7 +7,7 @@
 import { createHash, randomUUID } from 'node:crypto';
 import { appendFile, readFile, mkdir } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
-import { isNativeActive, fastAppendGapEntry, fastVerifyGapsChain } from '../engine/core-bridge.js';
+import { fastAppendGapEntry, fastVerifyGapsChain } from '../engine/core-bridge.js';
 import { projectDataDir } from './base-store.js';
 // ---------------------------------------------------------------------------
 // Path helper
@@ -53,26 +53,22 @@ async function doAppend(filePath, input) {
     const affectedSpecs = input.affectedSpecs && input.affectedSpecs.length > 0 ? input.affectedSpecs : [input.specId];
     const id = randomUUID();
     const timestamp = new Date().toISOString();
-    if (isNativeActive()) {
-        const sha = fastAppendGapEntry(filePath, id, timestamp, input.specId, input.description, severity, affectedSpecs);
-        if (sha) {
-            // We don't have the prevSha readily available here without re-reading,
-            // but the GapEntry returned is primarily for the tool response.
-            // If needed we can read the file tail in TS too.
-            return {
-                id,
-                timestamp,
-                specId: input.specId,
-                description: input.description,
-                severity,
-                affectedSpecs,
-                prevSha: '', // not needed for response
-                sha,
-            };
-        }
+    const bridgeSha = fastAppendGapEntry(filePath, id, timestamp, input.specId, input.description, severity, affectedSpecs);
+    if (typeof bridgeSha === 'string' && bridgeSha.length > 0) {
+        // The append path owns prevSha lookup internally. The response only needs
+        // the persisted entry identity and final sha.
+        return {
+            id,
+            timestamp,
+            specId: input.specId,
+            description: input.description,
+            severity,
+            affectedSpecs,
+            prevSha: '',
+            sha: bridgeSha,
+        };
     }
     await mkdir(dirname(filePath), { recursive: true });
-    // Read last entry's sha to chain
     const lines = await readJsonlLines(filePath);
     let prevSha = '';
     if (lines.length > 0) {
@@ -138,16 +134,22 @@ export async function readGapsLog(projectId) {
  * Verify the hash chain of the gaps log for a given project.
  * Returns validation result with the index of the first broken entry (if any).
  */
-export async function verifyGapsLogChain(projectId) {
+export function verifyGapsLogChain(projectId) {
     const filePath = gapsLogPath(projectId);
-    if (isNativeActive()) {
-        const res = fastVerifyGapsChain(filePath);
-        return {
-            valid: res.valid,
-            totalEntries: res.totalEntries,
-            brokenAt: res.brokenAt,
-        };
+    const bridgeResult = fastVerifyGapsChain(filePath);
+    if (isGapsLogChainResult(bridgeResult)) {
+        return Promise.resolve({
+            valid: bridgeResult.valid,
+            totalEntries: bridgeResult.totalEntries,
+            brokenAt: bridgeResult.brokenAt,
+        });
     }
+    return verifyGapsLogChainFallback(filePath);
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+async function verifyGapsLogChainFallback(filePath) {
     const lines = await readJsonlLines(filePath);
     if (lines.length === 0) {
         return { valid: true, totalEntries: 0, brokenAt: null };
@@ -165,11 +167,9 @@ export async function verifyGapsLogChain(projectId) {
         catch {
             return { valid: false, totalEntries: lines.length, brokenAt: i };
         }
-        // Check prevSha chain
         if (entry.prevSha !== prevSha) {
             return { valid: false, totalEntries: lines.length, brokenAt: i };
         }
-        // Verify sha
         const { sha, ...rest } = entry;
         const expectedSha = computeGapEntrySha(rest);
         if (sha !== expectedSha) {
@@ -179,9 +179,15 @@ export async function verifyGapsLogChain(projectId) {
     }
     return { valid: true, totalEntries: lines.length, brokenAt: null };
 }
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
+function isGapsLogChainResult(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const candidate = value;
+    return (typeof candidate.valid === 'boolean' &&
+        typeof candidate.totalEntries === 'number' &&
+        (typeof candidate.brokenAt === 'number' || candidate.brokenAt === null));
+}
 async function readJsonlLines(filePath) {
     let raw;
     try {

package/dist/storage/index.d.ts

@@ -19,5 +19,6 @@ export * as conventionBaselineStore from './convention-baseline.js';
 export * as lessonsStore from './lessons-store.js';
 export * as actualsStore from './actuals-store.js';
 export * as approvalStore from './approval-store.js';
+export * as technologySelectionStore from './technology-selection-store.js';
 export * from './skill-registry-storage.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/storage/index.js

@@ -20,5 +20,6 @@ export * as conventionBaselineStore from './convention-baseline.js';
 export * as lessonsStore from './lessons-store.js';
 export * as actualsStore from './actuals-store.js';
 export * as approvalStore from './approval-store.js';
+export * as technologySelectionStore from './technology-selection-store.js';
 export * from './skill-registry-storage.js';
 //# sourceMappingURL=index.js.map

package/dist/storage/technology-selection-store.d.ts

@@ -0,0 +1,5 @@
+import type { TechnologySelectionContract } from '../types/index.js';
+export declare const TECHNOLOGY_SELECTION_RELATIVE_PATH = ".planu/technology-selection.json";
+export declare function readTechnologySelectionContract(projectPath: string): Promise<TechnologySelectionContract | null>;
+export declare function writeTechnologySelectionContract(projectPath: string, contract: TechnologySelectionContract): Promise<void>;
+//# sourceMappingURL=technology-selection-store.d.ts.map

package/dist/storage/technology-selection-store.js

@@ -0,0 +1,42 @@
+// storage/technology-selection-store.ts — SPEC-1021 project-local technology contract
+import { mkdir, readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { writeJsonSafe } from '../engine/safety/atomic-writer.js';
+import { safeJsonParse } from './base-store.js';
+import { withFileLock } from './file-mutex.js';
+export const TECHNOLOGY_SELECTION_RELATIVE_PATH = '.planu/technology-selection.json';
+function contractPath(projectPath) {
+    return join(projectPath, TECHNOLOGY_SELECTION_RELATIVE_PATH);
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === 'string');
+}
+function isTechnologySelectionContract(value) {
+    if (value === null || typeof value !== 'object') {
+        return false;
+    }
+    const rec = value;
+    return ((rec.mode === 'existing_project' || rec.mode === 'new_project') &&
+        typeof rec.projectPath === 'string' &&
+        (rec.source === 'detected' ||
+            rec.source === 'user-confirmed' ||
+            rec.source === 'suggested-confirmed') &&
+        isStringArray(rec.evidence) &&
+        Array.isArray(rec.officialDocs));
+}
+export async function readTechnologySelectionContract(projectPath) {
+    try {
+        const raw = await readFile(contractPath(projectPath), 'utf-8');
+        const parsed = safeJsonParse(raw, null);
+        return isTechnologySelectionContract(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function writeTechnologySelectionContract(projectPath, contract) {
+    const filePath = contractPath(projectPath);
+    await mkdir(dirname(filePath), { recursive: true });
+    await withFileLock(filePath, () => writeJsonSafe(filePath, contract));
+}
+//# sourceMappingURL=technology-selection-store.js.map