@planu/cli 4.3.9 → 4.3.10

package/dist/engine/pr-description-generator.js

@@ -1,3 +1,6 @@
+function technicalSectionRef(spec) {
+    return `${spec.specPath}#technical`;
+}
 // ---------------------------------------------------------------------------
 // Title generation
 // ---------------------------------------------------------------------------
@@ -46,7 +49,7 @@ function buildGithubMarkdown(spec, audience, includeChecklist) {
     sections.push('');
     sections.push(`## Changes`);
     sections.push(`- Spec: \`${spec.specPath}\``);
-    sections.push(`- Technical: \`${spec.technicalPath}\``);
+    sections.push(`- Technical design: \`${technicalSectionRef(spec)}\``);
     if (spec.tags.length > 0) {
         sections.push(`- Tags: ${spec.tags.join(', ')}`);
     }
@@ -86,7 +89,7 @@ function buildGitlabMarkdown(spec, audience, includeChecklist) {
     sections.push(`Required by Planu spec ${spec.id}. Risk level: **${spec.risk}**. Difficulty: **${spec.difficulty}/5**.`);
     sections.push('');
     sections.push(`## How`);
-    sections.push(`See technical spec at \`${spec.technicalPath}\` for implementation details.`);
+    sections.push(`See \`${technicalSectionRef(spec)}\` for implementation details.`);
     if (spec.tags.length > 0) {
         sections.push(`Tags: ${spec.tags.join(', ')}`);
     }

package/dist/engine/validator/checklist.js

@@ -29,7 +29,7 @@ function buildCompletenessItems(spec) {
         },
         {
             id: 'cl-comp-2',
-            question: 'Is the technical design documented in FICHA-TECNICA?',
+            question: 'Is the technical design documented in spec.md under ## Technical?',
             category: 'completeness',
             answer: spec.technicalPath ? 'pending' : 'no',
             autoChecked: false,

package/dist/resources/process.js

@@ -39,7 +39,7 @@ function getSddProcess() {
                 id: 'creating-spec',
                 name: '3. Create Spec',
                 tools: ['create_spec', 'reverse_engineer', 'estimate'],
-                description: 'Create a full SDD spec (HU.md + FICHA-TECNICA.md) from requirements or ' +
+                description: 'Create a full SDD spec.md from requirements or ' +
                     'reverse-engineer from existing code. Estimate effort, cost, and tokens.',
             },
             {

package/dist/resources/templates.js

@@ -11,7 +11,7 @@ function getBuiltInTemplates() {
         {
             id: 'feature',
             name: 'Feature Spec',
-            description: 'Full feature specification with HU.md and FICHA-TECNICA.md',
+            description: 'Full feature specification using unified spec.md sections',
             type: 'feature',
             sections: [
                 'metadata',

package/dist/types/index.d.ts

@@ -228,7 +228,6 @@ export * from './spec-from-issue.js';
 export * from './plan-mode.js';
 export * from './self-healing.js';
 export * from './deploy.js';
-export * from './legacy.js';
 export * from './multi-agent-review.js';
 export * from './delete-first.js';
 export * from './auto-checkpoint.js';

package/dist/types/index.js

@@ -225,7 +225,6 @@ export * from './spec-from-issue.js';
 export * from './plan-mode.js';
 export * from './self-healing.js';
 export * from './deploy.js';
-export * from './legacy.js';
 export * from './multi-agent-review.js';
 export * from './delete-first.js';
 export * from './auto-checkpoint.js';

package/dist/types/spec-format.d.ts

@@ -32,7 +32,7 @@ export interface LeanSpecInput {
     /** SPEC-481: Acceptance criteria format. Defaults to 'checkbox'. */
     acFormat?: 'checkbox' | 'bdd';
 }
-/** A file entry in the lean technical.md. */
+/** A file entry in the unified spec.md Technical section. */
 export interface LeanFileEntry {
     path: string;
     status: 'pending' | 'done';
@@ -102,7 +102,7 @@ export interface ReplaceSectionResult {
     replaced: boolean;
     appended: boolean;
 }
-/** Input for lean technical.md generation. */
+/** Input for lean spec.md Technical section generation. */
 export interface LeanTechnicalInput {
     specId: string;
     filesToCreate?: LeanFileEntry[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@planu/cli",
-  "version": "4.3.9",
+  "version": "4.3.10",
   "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",
@@ -32,14 +32,14 @@
     "packageName": "@planu/core"
   },
   "optionalDependencies": {
-    "@planu/core-darwin-arm64": "4.3.9",
-    "@planu/core-darwin-x64": "4.3.9",
-    "@planu/core-linux-arm64-gnu": "4.3.9",
-    "@planu/core-linux-arm64-musl": "4.3.9",
-    "@planu/core-linux-x64-gnu": "4.3.9",
-    "@planu/core-linux-x64-musl": "4.3.9",
-    "@planu/core-win32-arm64-msvc": "4.3.9",
-    "@planu/core-win32-x64-msvc": "4.3.9"
+    "@planu/core-darwin-arm64": "4.3.10",
+    "@planu/core-darwin-x64": "4.3.10",
+    "@planu/core-linux-arm64-gnu": "4.3.10",
+    "@planu/core-linux-arm64-musl": "4.3.10",
+    "@planu/core-linux-x64-gnu": "4.3.10",
+    "@planu/core-linux-x64-musl": "4.3.10",
+    "@planu/core-win32-arm64-msvc": "4.3.10",
+    "@planu/core-win32-x64-msvc": "4.3.10"
   },
   "engines": {
     "node": ">=24.0.0"

package/dist/engine/context-intelligence/index.d.ts

@@ -1,7 +0,0 @@
-export { PlanuContextGraphProvider, createContextGraphProvider } from './context-graph-provider.js';
-export { getSensitivePathRefusal, collectPreservedFragments, verifyPreservedFragments, shouldBypassLeanMode, } from './compression-guards.js';
-export { compressSafeContext } from './safe-context-compressor.js';
-export { evaluateContextModes, summarizeContextEval } from './eval-harness.js';
-export { emptyImpactMap, estimateImpactBudget, mergeImpactMaps } from './impact-map.js';
-export type { ContextEvalCase, ContextEvalMode, ContextEvalResult, ContextGraphInput, ContextGraphProvider, ContextImpactEdge, ContextImpactFile, ContextImpactMap, ContextImpactSymbol, SafeCompressionResult, SafeContextCompressionInput, } from '../../types/context-intelligence.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/engine/context-intelligence/index.js

@@ -1,6 +0,0 @@
-export { PlanuContextGraphProvider, createContextGraphProvider } from './context-graph-provider.js';
-export { getSensitivePathRefusal, collectPreservedFragments, verifyPreservedFragments, shouldBypassLeanMode, } from './compression-guards.js';
-export { compressSafeContext } from './safe-context-compressor.js';
-export { evaluateContextModes, summarizeContextEval } from './eval-harness.js';
-export { emptyImpactMap, estimateImpactBudget, mergeImpactMaps } from './impact-map.js';
-//# sourceMappingURL=index.js.map

package/dist/engine/legacy/ast-analyzer.d.ts

@@ -1,21 +0,0 @@
-import type { LegacyFunctionInfo, LegacyFileAnalysis } from '../../types/index.js';
-export type { LegacyFunctionInfo, LegacyFileAnalysis };
-/**
- * Checks if the given file extension is a supported TypeScript/JavaScript file.
- */
-export declare function isSupportedFile(filePath: string): boolean;
-/**
- * Extracts a short snippet of lines around a given line number.
- */
-export declare function extractSnippet(lines: string[], lineIndex: number, context?: number): string;
-/**
- * Parses function names and their line numbers from source code.
- * Uses regex-based detection to avoid external AST dependencies.
- */
-export declare function extractFunctions(content: string): LegacyFunctionInfo[];
-/**
- * Reads and analyzes a TypeScript/JavaScript source file.
- * Returns null if the file is not supported or cannot be read.
- */
-export declare function analyzeFile(filePath: string): Promise<LegacyFileAnalysis | null>;
-//# sourceMappingURL=ast-analyzer.d.ts.map

package/dist/engine/legacy/ast-analyzer.js

@@ -1,113 +0,0 @@
-// Planu — engine/legacy/ast-analyzer.ts
-// Minimal TypeScript/JavaScript AST analyzer using regex-based patterns.
-// No external dependencies beyond Node built-ins.
-import { readFile } from 'node:fs/promises';
-import { extname } from 'node:path';
-// Regex patterns for function detection
-const FUNCTION_PATTERNS = [
-    // export function foo(
-    /^(?:export\s+)?(?:async\s+)?function\s+(\w+)\s*\(([^)]*)\)/m,
-    // const foo = (
-    /(?:export\s+)?(?:const|let)\s+(\w+)\s*=\s*(?:async\s*)?\(([^)]*)\)\s*(?::\s*\S+\s*)?=>/m,
-    // foo(
-    /^(?:export\s+)?(?:async\s+)?(\w+)\s*\(([^)]*)\)\s*(?::\s*\S+\s*)?{/m,
-];
-/**
- * Checks if the given file extension is a supported TypeScript/JavaScript file.
- */
-export function isSupportedFile(filePath) {
-    const ext = extname(filePath).toLowerCase();
-    return ['.ts', '.tsx', '.js', '.jsx', '.mts', '.mjs'].includes(ext);
-}
-/**
- * Extracts a short snippet of lines around a given line number.
- */
-export function extractSnippet(lines, lineIndex, context = 3) {
-    const start = Math.max(0, lineIndex - 1);
-    const end = Math.min(lines.length, lineIndex + context);
-    return lines
-        .slice(start, end)
-        .map((l) => l.trimEnd())
-        .join('\n');
-}
-/**
- * Parses function names and their line numbers from source code.
- * Uses regex-based detection to avoid external AST dependencies.
- */
-export function extractFunctions(content) {
-    const lines = content.split('\n');
-    const functions = [];
-    const seen = new Set();
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i] ?? '';
-        const trimmed = line.trim();
-        // Skip comments and empty lines
-        if (trimmed.startsWith('//') || trimmed.startsWith('*') || trimmed === '') {
-            continue;
-        }
-        for (const pattern of FUNCTION_PATTERNS) {
-            const match = trimmed.match(pattern);
-            if (match) {
-                const name = match[1];
-                const paramsRaw = match[2] ?? '';
-                if (name === undefined || name === '' || seen.has(`${name}:${i}`)) {
-                    break;
-                }
-                seen.add(`${name}:${i}`);
-                const params = paramsRaw
-                    .split(',')
-                    .map((p) => p.trim().split(':')[0]?.trim() ?? '')
-                    .filter((p) => p.length > 0);
-                // Collect function body (up to closing brace or end of arrow fn)
-                const bodyLines = [];
-                let braceCount = 0;
-                let bodyStarted = false;
-                for (let j = i; j < Math.min(lines.length, i + 80); j++) {
-                    const bl = lines[j] ?? '';
-                    bodyLines.push(bl);
-                    for (const ch of bl) {
-                        if (ch === '{') {
-                            braceCount++;
-                            bodyStarted = true;
-                        }
-                        else if (ch === '}') {
-                            braceCount--;
-                        }
-                    }
-                    if (bodyStarted && braceCount === 0) {
-                        break;
-                    }
-                }
-                functions.push({
-                    name,
-                    line: i + 1,
-                    params,
-                    body: bodyLines.join('\n'),
-                    snippet: extractSnippet(lines, i + 1),
-                });
-                break;
-            }
-        }
-    }
-    return functions;
-}
-/**
- * Reads and analyzes a TypeScript/JavaScript source file.
- * Returns null if the file is not supported or cannot be read.
- */
-export async function analyzeFile(filePath) {
-    if (!isSupportedFile(filePath)) {
-        return null;
-    }
-    let content;
-    try {
-        content = await readFile(filePath, 'utf-8');
-    }
-    catch {
-        return null;
-    }
-    const lines = content.split('\n');
-    const functions = extractFunctions(content);
-    return { filePath, functions, lines };
-}
-//# sourceMappingURL=ast-analyzer.js.map

package/dist/engine/legacy/characterization-generator.d.ts

@@ -1,6 +0,0 @@
-import type { CharacterizationResult } from '../../types/index.js';
-/**
- * Generates characterization test stubs for functions in the given files.
- */
-export declare function generateCharacterizationTests(projectPath: string, files?: string[], outputFile?: string): Promise<CharacterizationResult>;
-//# sourceMappingURL=characterization-generator.d.ts.map

package/dist/engine/legacy/characterization-generator.js

@@ -1,146 +0,0 @@
-// Planu — engine/legacy/characterization-generator.ts
-// Generates characterization test stubs for existing functions.
-// The stubs call the function with detected sample inputs and leave
-// `// TODO: assert current output` placeholders for the developer to fill in.
-import { glob } from 'glob';
-import { join, relative, basename } from 'node:path';
-import { analyzeFile } from './ast-analyzer.js';
-// ---------------------------------------------------------------------------
-// Sample input inference
-// ---------------------------------------------------------------------------
-// Keyword groups for sample value inference
-const PATH_KEYWORDS = ['path', 'dir', 'file'];
-const URL_KEYWORDS = ['url', 'endpoint'];
-const ID_KEYWORDS = ['id', 'key'];
-const NUM_KEYWORDS = ['count', 'size', 'limit', 'max', 'min', 'num', 'index'];
-const BOOL_KEYWORDS = ['flag', 'enabled', 'active', 'is', 'has'];
-const ARRAY_KEYWORDS = ['list', 'items', 'arr'];
-const OBJ_KEYWORDS = ['opts', 'options', 'config', 'args'];
-function matchesAny(lower, keywords) {
-    return keywords.some((k) => lower.includes(k));
-}
-/**
- * Infers a plausible sample value for a parameter based on its name/type hints.
- */
-function inferSampleValue(paramName) {
-    const lower = paramName.toLowerCase();
-    if (matchesAny(lower, PATH_KEYWORDS)) {
-        return { name: paramName, value: '"/tmp/sample"', type: 'string' };
-    }
-    if (matchesAny(lower, URL_KEYWORDS)) {
-        return { name: paramName, value: '"https://example.com"', type: 'string' };
-    }
-    if (matchesAny(lower, ID_KEYWORDS)) {
-        return { name: paramName, value: '"test-id-001"', type: 'string' };
-    }
-    if (matchesAny(lower, NUM_KEYWORDS)) {
-        return { name: paramName, value: '10', type: 'number' };
-    }
-    if (matchesAny(lower, BOOL_KEYWORDS)) {
-        return { name: paramName, value: 'true', type: 'boolean' };
-    }
-    if (matchesAny(lower, ARRAY_KEYWORDS)) {
-        return { name: paramName, value: '[]', type: 'unknown[]' };
-    }
-    if (matchesAny(lower, OBJ_KEYWORDS)) {
-        return { name: paramName, value: '{}', type: 'Record<string, unknown>' };
-    }
-    return { name: paramName, value: `"${paramName}-value"`, type: 'string' };
-}
-/**
- * Generates a test stub for a single function.
- */
-function generateTestStub(fn, sourceFile, importPath, testId) {
-    const params = fn.params;
-    const sampleInputs = params.map(inferSampleValue);
-    const paramList = sampleInputs.map((s) => s.value).join(', ');
-    const isAsync = fn.body.includes('await') || fn.body.includes('async');
-    const awaitKeyword = isAsync ? 'await ' : '';
-    const testModifier = isAsync ? 'async ' : '';
-    const stubLines = [
-        `// Characterization test for ${fn.name}`,
-        `// File: ${sourceFile}`,
-        `// Generated by Planu — fill in the expected values.`,
-        ``,
-        `import { ${fn.name} } from '${importPath}';`,
-        ``,
-        `describe('${fn.name} (characterization)', () => {`,
-        `  it('should behave as currently observed', ${testModifier}() => {`,
-        ...sampleInputs.map((s) => `    const ${s.name} = ${s.value}; // ${s.type}`),
-        ``,
-        `    const result = ${awaitKeyword}${fn.name}(${paramList});`,
-        ``,
-        `    // TODO: Replace with actual observed output:`,
-        `    // expect(result).toEqual(/* observed value */);`,
-        `    expect(result).toBeDefined();`,
-        `  });`,
-        `});`,
-    ];
-    const testCode = stubLines.join('\n');
-    return {
-        id: testId,
-        sourceFile,
-        functionName: fn.name,
-        testCode,
-        sampleInputs,
-        developerNote: 'Run the function manually with these inputs, observe the output, then replace the TODO assertion with the actual expected value.',
-    };
-}
-// ---------------------------------------------------------------------------
-// File resolution
-// ---------------------------------------------------------------------------
-async function resolveFiles(projectPath, files) {
-    if (files !== undefined && files.length > 0) {
-        return files;
-    }
-    return glob('src/**/*.{ts,tsx,js,jsx}', {
-        cwd: projectPath,
-        absolute: true,
-        ignore: ['**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*', '**/index.ts'],
-    });
-}
-// ---------------------------------------------------------------------------
-// Main entry point
-// ---------------------------------------------------------------------------
-let testCounter = 0;
-function makeTestId() {
-    testCounter++;
-    return `CT-${String(testCounter).padStart(4, '0')}`;
-}
-/**
- * Generates characterization test stubs for functions in the given files.
- */
-export async function generateCharacterizationTests(projectPath, files, outputFile) {
-    testCounter = 0;
-    const resolvedFiles = await resolveFiles(projectPath, files);
-    const allTests = [];
-    for (const filePath of resolvedFiles) {
-        const absPath = filePath.startsWith('/') ? filePath : join(projectPath, filePath);
-        const analysis = await analyzeFile(absPath);
-        if (analysis === null || analysis.functions.length === 0) {
-            continue;
-        }
-        const relPath = relative(projectPath, absPath);
-        // Convert to a relative import path usable in tests/
-        const importBase = basename(absPath).replace(/\.(ts|tsx|js|jsx)$/, '.js');
-        const importDir = relative(join(projectPath, 'tests'), join(projectPath, relPath.replace(/\/[^/]+$/, '')));
-        const importPath = `${importDir}/${importBase}`;
-        for (const fn of analysis.functions) {
-            // Skip private-looking functions (underscore prefix)
-            if (fn.name.startsWith('_')) {
-                continue;
-            }
-            allTests.push(generateTestStub(fn, relPath, importPath, makeTestId()));
-        }
-    }
-    const defaultOutput = join(projectPath, 'tests', 'characterization', 'characterization.test.ts');
-    const outFile = outputFile ?? defaultOutput;
-    return {
-        projectPath,
-        filesAnalyzed: resolvedFiles.length,
-        tests: allTests,
-        outputFile: outFile,
-        summary: `Analyzed ${resolvedFiles.length} files. Generated ${allTests.length} characterization test stubs.`,
-    };
-}
-//# sourceMappingURL=characterization-generator.js.map

package/dist/engine/legacy/hyrum-scanner.d.ts

@@ -1,6 +0,0 @@
-import type { HyrumScanResult } from '../../types/index.js';
-/**
- * Scans the given files (or project) for Hyrum's Law risks.
- */
-export declare function scanHyrumRisks(projectPath: string, files?: string[]): Promise<HyrumScanResult>;
-//# sourceMappingURL=hyrum-scanner.d.ts.map

package/dist/engine/legacy/hyrum-scanner.js

@@ -1,137 +0,0 @@
-// Planu — engine/legacy/hyrum-scanner.ts
-// Detects Hyrum's Law risks in public API surfaces:
-// observable behaviors that callers may depend on even if undocumented.
-import { glob } from 'glob';
-import { analyzeFile, extractSnippet } from './ast-analyzer.js';
-// ---------------------------------------------------------------------------
-// Risk detection patterns
-// ---------------------------------------------------------------------------
-const RISK_PATTERNS = [
-    {
-        category: 'exception-type',
-        regex: /throw\s+new\s+(\w+Error|Error)\s*\(/,
-        severity: 'high',
-        describe: (m) => `Throws ${m[1] ?? 'Error'} — callers may catch this specific type`,
-    },
-    {
-        category: 'return-shape',
-        regex: /return\s*\{\s*(\w+)\s*:/,
-        severity: 'medium',
-        describe: (m) => `Returns object with key "${m[1] ?? '?'}" — shape may be depended on`,
-    },
-    {
-        category: 'null-vs-undefined',
-        regex: /return\s+(null|undefined)\b/,
-        severity: 'high',
-        describe: (m) => `Returns ${m[1] ?? 'null/undefined'} — callers may distinguish null vs undefined`,
-    },
-    {
-        category: 'ordering-guarantee',
-        regex: /\.sort\s*\(/,
-        severity: 'medium',
-        describe: () => 'Array.sort() used — output ordering may be depended on by callers',
-    },
-    {
-        category: 'error-message-text',
-        regex: /throw\s+new\s+\w+\s*\(\s*[`'"]/,
-        severity: 'medium',
-        describe: () => 'Error with string literal — error message text may be relied upon by callers',
-    },
-    {
-        category: 'implicit-return',
-        regex: /=>\s*[^{(\n][^;\n]*$/m,
-        severity: 'low',
-        describe: () => 'Arrow function with implicit return — return value shape may be an implicit contract',
-    },
-];
-// ---------------------------------------------------------------------------
-// Scanner
-// ---------------------------------------------------------------------------
-let riskCounter = 0;
-function makeRiskId() {
-    riskCounter++;
-    return `HR-${String(riskCounter).padStart(4, '0')}`;
-}
-/**
- * Scans a single file for Hyrum risks.
- */
-async function scanFile(filePath) {
-    const analysis = await analyzeFile(filePath);
-    if (analysis === null) {
-        return [];
-    }
-    const risks = [];
-    for (const fn of analysis.functions) {
-        const bodyLines = fn.body.split('\n');
-        for (const pattern of RISK_PATTERNS) {
-            for (let i = 0; i < bodyLines.length; i++) {
-                const line = bodyLines[i] ?? '';
-                const match = line.match(pattern.regex);
-                if (match) {
-                    const absoluteLine = fn.line + i;
-                    risks.push({
-                        id: makeRiskId(),
-                        category: pattern.category,
-                        file: filePath,
-                        line: absoluteLine,
-                        functionName: fn.name,
-                        description: pattern.describe(match),
-                        severity: pattern.severity,
-                        snippet: extractSnippet(analysis.lines, absoluteLine),
-                    });
-                }
-            }
-        }
-    }
-    return risks;
-}
-/**
- * Resolves the list of files to scan.
- * If `files` is provided, uses that list. Otherwise globs for TS/JS files.
- */
-async function resolveFiles(projectPath, files) {
-    if (files !== undefined && files.length > 0) {
-        return files;
-    }
-    return glob('src/**/*.{ts,tsx,js,jsx}', {
-        cwd: projectPath,
-        absolute: true,
-        ignore: ['**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*'],
-    });
-}
-/**
- * Scans the given files (or project) for Hyrum's Law risks.
- */
-export async function scanHyrumRisks(projectPath, files) {
-    riskCounter = 0;
-    const resolvedFiles = await resolveFiles(projectPath, files);
-    // Process in parallel with a concurrency limit
-    const BATCH = 20;
-    const allRisks = [];
-    for (let i = 0; i < resolvedFiles.length; i += BATCH) {
-        const batch = resolvedFiles.slice(i, i + BATCH);
-        const batchResults = await Promise.all(batch.map((f) => scanFile(f)));
-        for (const r of batchResults) {
-            allRisks.push(...r);
-        }
-    }
-    // Sort by severity then file
-    const severityOrder = { high: 0, medium: 1, low: 2 };
-    allRisks.sort((a, b) => {
-        const sv = severityOrder[a.severity] - severityOrder[b.severity];
-        if (sv !== 0) {
-            return sv;
-        }
-        return a.file.localeCompare(b.file);
-    });
-    const highCount = allRisks.filter((r) => r.severity === 'high').length;
-    const medCount = allRisks.filter((r) => r.severity === 'medium').length;
-    const lowCount = allRisks.filter((r) => r.severity === 'low').length;
-    return {
-        projectPath,
-        filesScanned: resolvedFiles.length,
-        risks: allRisks,
-        summary: `Scanned ${resolvedFiles.length} files. Found ${allRisks.length} Hyrum risks: ${highCount} high, ${medCount} medium, ${lowCount} low.`,
-    };
-}
-//# sourceMappingURL=hyrum-scanner.js.map

package/dist/engine/legacy/safety-net-orchestrator.d.ts

@@ -1,7 +0,0 @@
-import type { SafetyNetPlan } from '../../types/index.js';
-/**
- * Builds a safety-net refactoring plan for the given project and target files.
- * Pure function — returns a plan without executing anything.
- */
-export declare function buildSafetyNetPlan(projectPath: string, targetFiles?: string[], coverageThreshold?: number): Promise<SafetyNetPlan>;
-//# sourceMappingURL=safety-net-orchestrator.d.ts.map

package/dist/engine/legacy/safety-net-orchestrator.js

@@ -1,114 +0,0 @@
-// Planu — engine/legacy/safety-net-orchestrator.ts
-// Pure orchestrator: given a project and target files, produces a sequenced
-// safety-net plan for refactoring. No real execution — returns the plan.
-import { join } from 'node:path';
-import { findSeams } from './seam-finder.js';
-// ---------------------------------------------------------------------------
-// Step builders
-// ---------------------------------------------------------------------------
-function buildStep(order, label, description, estimatedMinutes) {
-    return {
-        order,
-        label,
-        description,
-        status: 'pending',
-        estimatedMinutes,
-    };
-}
-const BASELINE_STEPS = [
-    {
-        label: 'Measure coverage baseline',
-        description: 'Run the test suite with coverage enabled (e.g., `pnpm test:coverage`) and record the current line/branch coverage percentage for the target files.',
-        status: 'pending',
-        estimatedMinutes: 5,
-    },
-    {
-        label: 'Add characterization tests',
-        description: 'Use `characterize_legacy_code` to generate test stubs. Fill in expected values by running the code manually. These tests lock in existing behavior before any refactoring.',
-        status: 'pending',
-        estimatedMinutes: 30,
-    },
-    {
-        label: 'Verify safety net',
-        description: 'Run the test suite again. All characterization tests must pass before proceeding. If any fail, fix the expected values — do not change the production code yet.',
-        status: 'pending',
-        estimatedMinutes: 5,
-    },
-];
-const REFACTOR_STEPS_AFTER_SAFETY_NET = [
-    {
-        label: 'Break seams incrementally',
-        description: 'Use `seams_detector` output to identify injection points. Break one seam at a time. Run tests after each change.',
-        status: 'pending',
-        estimatedMinutes: 60,
-    },
-    {
-        label: 'Validate behavior unchanged',
-        description: 'After each refactor step, run the full test suite. All characterization tests must still pass. If any break, roll back the last change.',
-        status: 'pending',
-        estimatedMinutes: 10,
-    },
-    {
-        label: 'Remove characterization scaffolding',
-        description: 'Once the refactored code has proper unit tests covering the same behaviors, remove the temporary characterization test stubs.',
-        status: 'pending',
-        estimatedMinutes: 15,
-    },
-];
-// ---------------------------------------------------------------------------
-// Refactor steps from seams
-// ---------------------------------------------------------------------------
-function seamToRefactorStep(seam) {
-    const patternMap = {
-        'static-call': 'inject-dependency',
-        'global-env': 'inject-dependency',
-        'inline-new': 'inject-dependency',
-        'module-singleton': 'replace-singleton',
-        'hardcoded-path': 'inject-dependency',
-        'hardcoded-url': 'inject-dependency',
-    };
-    const pattern = patternMap[seam.category] ?? 'introduce-seam';
-    const risk = seam.breakability === 'hard' ? 'high' : seam.breakability === 'moderate' ? 'medium' : 'low';
-    return {
-        file: seam.file,
-        change: `In function \`${seam.functionName}\`: ${seam.suggestion}`,
-        pattern,
-        requiresTest: true,
-        risk,
-    };
-}
-// ---------------------------------------------------------------------------
-// Main orchestrator
-// ---------------------------------------------------------------------------
-/**
- * Builds a safety-net refactoring plan for the given project and target files.
- * Pure function — returns a plan without executing anything.
- */
-export async function buildSafetyNetPlan(projectPath, targetFiles, coverageThreshold = 80) {
-    // Detect seams to populate refactor steps
-    const seamResult = await findSeams(projectPath, targetFiles);
-    // Build ordered steps
-    const steps = [
-        ...BASELINE_STEPS.map((s, i) => buildStep(i + 1, s.label, s.description, s.estimatedMinutes)),
-        ...REFACTOR_STEPS_AFTER_SAFETY_NET.map((s, i) => buildStep(BASELINE_STEPS.length + i + 1, s.label, s.description, s.estimatedMinutes)),
-    ];
-    // Build refactor steps from detected seams (max 20 to keep plan readable)
-    const refactorSteps = seamResult.seams
-        .slice(0, 20)
-        .map((seam) => seamToRefactorStep(seam));
-    const resolvedFiles = targetFiles !== undefined && targetFiles.length > 0
-        ? targetFiles
-        : [`${join(projectPath, 'src')}/**/*.{ts,js}`];
-    const totalMinutes = steps.reduce((sum, s) => sum + s.estimatedMinutes, 0);
-    return {
-        projectPath,
-        targetFiles: resolvedFiles,
-        coverageBaseline: coverageThreshold,
-        steps,
-        refactorSteps,
-        summary: `Safety-net plan: ${steps.length} steps (~${totalMinutes} min total). ` +
-            `${refactorSteps.length} refactor actions identified from ${seamResult.seams.length} seams. ` +
-            `Coverage target: ≥${coverageThreshold}%.`,
-    };
-}
-//# sourceMappingURL=safety-net-orchestrator.js.map

package/dist/engine/legacy/seam-finder.d.ts

@@ -1,6 +0,0 @@
-import type { SeamScanResult } from '../../types/index.js';
-/**
- * Scans the given files (or project) for seams.
- */
-export declare function findSeams(projectPath: string, files?: string[]): Promise<SeamScanResult>;
-//# sourceMappingURL=seam-finder.d.ts.map

package/dist/engine/legacy/seam-finder.js

@@ -1,139 +0,0 @@
-// Planu — engine/legacy/seam-finder.ts
-// Finds dependency break points (seams) in TypeScript/JavaScript files.
-// Patterns: static calls, globals, new() inline, hardcoded paths/URLs.
-import { glob } from 'glob';
-import { analyzeFile } from './ast-analyzer.js';
-const SEAM_PATTERNS = [
-    {
-        category: 'static-call',
-        regex: /\b([A-Z]\w+)\.(\w+)\s*\(/,
-        breakability: 'moderate',
-        describe: (m) => `Static call to ${m[1] ?? '?'}.${m[2] ?? '?'}() — hard to mock/replace`,
-        suggest: () => 'Inject an interface/dependency instead of calling static method directly',
-    },
-    {
-        category: 'global-env',
-        regex: /process\.env\.(\w+)/,
-        breakability: 'easy',
-        describe: (m) => `Direct process.env.${m[1] ?? '?'} access — not injectable`,
-        suggest: (m) => `Extract to a config object or inject \`${m[1] ?? 'CONFIG'}\` via parameter`,
-    },
-    {
-        category: 'inline-new',
-        regex: /=\s*new\s+([A-Z]\w+)\s*\(/,
-        breakability: 'hard',
-        describe: (m) => `Inline \`new ${m[1] ?? '?'}()\` inside function — cannot be replaced`,
-        suggest: (m) => `Inject a factory or pass \`${m[1] ?? 'Dep'}Factory\` as a parameter`,
-    },
-    {
-        category: 'hardcoded-path',
-        regex: /['"`](\/[a-zA-Z0-9_\-/]+\.[a-zA-Z]{1,5})['"`]/,
-        breakability: 'easy',
-        describe: (m) => `Hardcoded file path: ${m[1] ?? '?'}`,
-        suggest: () => 'Move path to a config constant or inject via parameter',
-    },
-    {
-        category: 'hardcoded-url',
-        regex: /['"`](https?:\/\/[^'"`\s]+)['"`]/,
-        breakability: 'easy',
-        describe: (m) => `Hardcoded URL: ${(m[1] ?? '').slice(0, 60)}`,
-        suggest: () => 'Move URL to a config object or environment variable',
-    },
-    {
-        category: 'module-singleton',
-        regex: /^(?:import\s+\{[^}]+\}\s+from|const\s+\w+\s*=\s*require\s*\()/m,
-        breakability: 'moderate',
-        describe: () => 'Module-level singleton import — creates hidden dependency',
-        suggest: () => 'Pass the dependency via constructor or function parameter for testability',
-    },
-];
-// ---------------------------------------------------------------------------
-// Scanner
-// ---------------------------------------------------------------------------
-let seamCounter = 0;
-function makeSeamId() {
-    seamCounter++;
-    return `SM-${String(seamCounter).padStart(4, '0')}`;
-}
-/**
- * Scans a single file for seams.
- */
-async function scanFile(filePath) {
-    const analysis = await analyzeFile(filePath);
-    if (analysis === null) {
-        return [];
-    }
-    const seams = [];
-    for (const fn of analysis.functions) {
-        const bodyLines = fn.body.split('\n');
-        for (const pattern of SEAM_PATTERNS) {
-            for (let i = 0; i < bodyLines.length; i++) {
-                const line = bodyLines[i] ?? '';
-                const match = line.match(pattern.regex);
-                if (match) {
-                    const absoluteLine = fn.line + i;
-                    seams.push({
-                        id: makeSeamId(),
-                        category: pattern.category,
-                        file: filePath,
-                        line: absoluteLine,
-                        functionName: fn.name,
-                        description: pattern.describe(match),
-                        pattern: match[0],
-                        suggestion: pattern.suggest(match),
-                        breakability: pattern.breakability,
-                    });
-                }
-            }
-        }
-    }
-    return seams;
-}
-/**
- * Resolves the list of files to scan.
- */
-async function resolveFiles(projectPath, files) {
-    if (files !== undefined && files.length > 0) {
-        return files;
-    }
-    return glob('src/**/*.{ts,tsx,js,jsx}', {
-        cwd: projectPath,
-        absolute: true,
-        ignore: ['**/node_modules/**', '**/dist/**', '**/*.test.*', '**/*.spec.*'],
-    });
-}
-/**
- * Scans the given files (or project) for seams.
- */
-export async function findSeams(projectPath, files) {
-    seamCounter = 0;
-    const resolvedFiles = await resolveFiles(projectPath, files);
-    const BATCH = 20;
-    const allSeams = [];
-    for (let i = 0; i < resolvedFiles.length; i += BATCH) {
-        const batch = resolvedFiles.slice(i, i + BATCH);
-        const batchResults = await Promise.all(batch.map((f) => scanFile(f)));
-        for (const r of batchResults) {
-            allSeams.push(...r);
-        }
-    }
-    // Sort by breakability (hard first = most valuable to break), then file
-    const breakOrder = { hard: 0, moderate: 1, easy: 2 };
-    allSeams.sort((a, b) => {
-        const bk = breakOrder[a.breakability] - breakOrder[b.breakability];
-        if (bk !== 0) {
-            return bk;
-        }
-        return a.file.localeCompare(b.file);
-    });
-    const hardCount = allSeams.filter((s) => s.breakability === 'hard').length;
-    const modCount = allSeams.filter((s) => s.breakability === 'moderate').length;
-    const easyCount = allSeams.filter((s) => s.breakability === 'easy').length;
-    return {
-        projectPath,
-        filesScanned: resolvedFiles.length,
-        seams: allSeams,
-        summary: `Scanned ${resolvedFiles.length} files. Found ${allSeams.length} seams: ${hardCount} hard, ${modCount} moderate, ${easyCount} easy to break.`,
-    };
-}
-//# sourceMappingURL=seam-finder.js.map

package/dist/tools/legacy/characterize-legacy-code.d.ts

@@ -1,9 +0,0 @@
-import { z } from 'zod';
-import type { ToolResult, CharacterizeLegacyInput } from '../../types/index.js';
-export declare const CharacterizeLegacyCodeInputSchema: {
-    projectPath: z.ZodString;
-    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    outputFile: z.ZodOptional<z.ZodString>;
-};
-export declare function handleCharacterizeLegacyCode(args: CharacterizeLegacyInput): Promise<ToolResult>;
-//# sourceMappingURL=characterize-legacy-code.d.ts.map

package/dist/tools/legacy/characterize-legacy-code.js

@@ -1,63 +0,0 @@
-// Planu — tools/legacy/characterize-legacy-code.ts
-// Tool handler for characterize_legacy_code.
-import { z } from 'zod';
-import { writeFile, mkdir } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { generateCharacterizationTests } from '../../engine/legacy/characterization-generator.js';
-import { compactResult } from '../output-formatter.js';
-// ---------------------------------------------------------------------------
-// Input schema
-// ---------------------------------------------------------------------------
-export const CharacterizeLegacyCodeInputSchema = {
-    projectPath: z.string().max(4096).describe('Absolute path to the project root to analyze'),
-    files: z
-        .array(z.string())
-        .optional()
-        .describe('Optional list of absolute file paths to analyze. If omitted, scans src/**/*.{ts,js}'),
-    outputFile: z
-        .string()
-        .optional()
-        .describe('Absolute path where the generated test file will be written. Defaults to tests/characterization/characterization.test.ts'),
-};
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-export async function handleCharacterizeLegacyCode(args) {
-    const { projectPath, files, outputFile } = args;
-    const result = await generateCharacterizationTests(projectPath, files, outputFile);
-    if (result.tests.length === 0) {
-        return compactResult(`## Characterization Tests\n\nNo functions found to characterize in ${result.filesAnalyzed} file(s).\n\nTip: ensure the target files export named functions.`);
-    }
-    // Write the generated test file
-    const outPath = result.outputFile;
-    const allTestCode = [
-        '// AUTO-GENERATED by Planu characterize_legacy_code',
-        '// Fill in the TODO assertions with observed output values.',
-        '// DO NOT delete these tests until proper unit tests replace them.',
-        '',
-        ...result.tests.map((t) => t.testCode),
-    ].join('\n\n');
-    await mkdir(dirname(outPath), { recursive: true });
-    await writeFile(outPath, allTestCode, 'utf-8');
-    const outRelative = outPath.startsWith(join(projectPath, ''))
-        ? outPath.slice(projectPath.length + 1)
-        : outPath;
-    const lines = [
-        `## Characterization Tests Generated`,
-        ``,
-        `**Files analyzed**: ${result.filesAnalyzed}`,
-        `**Test stubs generated**: ${result.tests.length}`,
-        `**Output**: \`${outRelative}\``,
-        ``,
-        `### Functions characterized`,
-    ];
-    for (const test of result.tests.slice(0, 20)) {
-        lines.push(`- \`${test.functionName}\` in \`${test.sourceFile}\``);
-    }
-    if (result.tests.length > 20) {
-        lines.push(`- _...and ${result.tests.length - 20} more_`);
-    }
-    lines.push(``, `### Next steps`, `1. Open \`${outRelative}\``, `2. Run each function with the sample inputs shown`, `3. Replace \`// TODO: assert current output\` with the observed value`, `4. Run the test suite — all characterization tests must pass before refactoring`);
-    return compactResult(lines.join('\n'));
-}
-//# sourceMappingURL=characterize-legacy-code.js.map

package/dist/tools/legacy/detect-hyrum-risks.d.ts

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-import type { ToolResult, LegacyAnalysisInput } from '../../types/index.js';
-export declare const DetectHyrumRisksInputSchema: {
-    projectPath: z.ZodString;
-    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-};
-export declare function handleDetectHyrumRisks(args: LegacyAnalysisInput): Promise<ToolResult>;
-//# sourceMappingURL=detect-hyrum-risks.d.ts.map

package/dist/tools/legacy/detect-hyrum-risks.js

@@ -1,47 +0,0 @@
-// Planu — tools/legacy/detect-hyrum-risks.ts
-// Tool handler for detect_hyrum_risks.
-import { z } from 'zod';
-import { scanHyrumRisks } from '../../engine/legacy/hyrum-scanner.js';
-import { compactResult, formatTable } from '../output-formatter.js';
-// ---------------------------------------------------------------------------
-// Input schema
-// ---------------------------------------------------------------------------
-export const DetectHyrumRisksInputSchema = {
-    projectPath: z.string().max(4096).describe('Absolute path to the project root to scan'),
-    files: z
-        .array(z.string())
-        .optional()
-        .describe('Optional list of absolute file paths to scan. If omitted, scans src/**/*.{ts,js}'),
-};
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-export async function handleDetectHyrumRisks(args) {
-    const { projectPath, files } = args;
-    const result = await scanHyrumRisks(projectPath, files);
-    if (result.risks.length === 0) {
-        return compactResult(`## Hyrum Risk Scan\n\n${result.summary}\n\nNo observable behavior risks detected.`);
-    }
-    const tableRows = result.risks.slice(0, 30).map((r) => ({
-        ID: r.id,
-        Severity: r.severity,
-        Category: r.category,
-        Function: r.functionName,
-        File: r.file.split('/').slice(-2).join('/'),
-        Description: r.description.slice(0, 80),
-    }));
-    const table = formatTable(tableRows, ['ID', 'Severity', 'Category', 'Function', 'File', 'Description'], `Hyrum Risks (${result.risks.length})`);
-    const highRisks = result.risks.filter((r) => r.severity === 'high');
-    const highSection = highRisks.length > 0
-        ? [
-            ``,
-            `### High-Severity Risks (action required)`,
-            ...highRisks
-                .slice(0, 5)
-                .map((r) => `**${r.id}** \`${r.functionName}\` — ${r.description}\n` +
-                `\`\`\`\n${r.snippet}\n\`\`\``),
-        ].join('\n')
-        : '';
-    return compactResult([`## Hyrum Risk Detection`, ``, result.summary, ``, table, highSection].join('\n'));
-}
-//# sourceMappingURL=detect-hyrum-risks.js.map

package/dist/tools/legacy/refactor-with-safety-net.d.ts

@@ -1,10 +0,0 @@
-import { z } from 'zod';
-import type { ToolResult, RefactorSafetyNetInput } from '../../types/index.js';
-export declare const RefactorWithSafetyNetInputSchema: {
-    projectPath: z.ZodString;
-    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    coverageThreshold: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
-    dryRun: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-};
-export declare function handleRefactorWithSafetyNet(args: RefactorSafetyNetInput): Promise<ToolResult>;
-//# sourceMappingURL=refactor-with-safety-net.d.ts.map

package/dist/tools/legacy/refactor-with-safety-net.js

@@ -1,55 +0,0 @@
-// Planu — tools/legacy/refactor-with-safety-net.ts
-// Tool handler for refactor_with_safety_net.
-import { z } from 'zod';
-import { buildSafetyNetPlan } from '../../engine/legacy/safety-net-orchestrator.js';
-import { compactResult } from '../output-formatter.js';
-// ---------------------------------------------------------------------------
-// Input schema
-// ---------------------------------------------------------------------------
-export const RefactorWithSafetyNetInputSchema = {
-    projectPath: z
-        .string()
-        .max(4096)
-        .describe('Absolute path to the project root to analyze and plan'),
-    files: z
-        .array(z.string())
-        .optional()
-        .describe('Optional list of absolute file paths to target. If omitted, scans src/**/*.{ts,js}'),
-    coverageThreshold: z
-        .number()
-        .min(0)
-        .max(100)
-        .optional()
-        .default(80)
-        .describe('Minimum coverage percentage required before refactoring. Default: 80'),
-    dryRun: z
-        .boolean()
-        .optional()
-        .default(false)
-        .describe('If true, show the plan without executing any changes. Default: false (plan is always returned — this flag is reserved for future execution mode)'),
-};
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-export async function handleRefactorWithSafetyNet(args) {
-    const { projectPath, files, coverageThreshold = 80 } = args;
-    const plan = await buildSafetyNetPlan(projectPath, files, coverageThreshold);
-    const lines = [`## Refactor with Safety Net`, ``, plan.summary, ``, `### Steps`];
-    for (const step of plan.steps) {
-        lines.push(`**${step.order}. ${step.label}** (~${step.estimatedMinutes} min)`);
-        lines.push(`   ${step.description}`);
-    }
-    if (plan.refactorSteps.length > 0) {
-        lines.push(``, `### Identified Refactor Actions`);
-        for (const rs of plan.refactorSteps.slice(0, 15)) {
-            const riskBadge = rs.risk === 'high' ? ' ⚠️ high risk' : rs.risk === 'medium' ? ' medium risk' : '';
-            lines.push(`- **${rs.pattern}**${riskBadge}: ${rs.change}`);
-        }
-        if (plan.refactorSteps.length > 15) {
-            lines.push(`- _...and ${plan.refactorSteps.length - 15} more_`);
-        }
-    }
-    lines.push(``, `### Coverage target`, `≥ ${plan.coverageBaseline}% line coverage required before starting refactoring.`, ``, `### Automated tools`, `- \`characterize_legacy_code\` — generates test stubs (Step 2)`, `- \`seams_detector\` — identifies injection points (Step 4)`, `- \`detect_hyrum_risks\` — flags observable behaviors to preserve`);
-    return compactResult(lines.join('\n'));
-}
-//# sourceMappingURL=refactor-with-safety-net.js.map

package/dist/tools/legacy/seams-detector.d.ts

@@ -1,8 +0,0 @@
-import { z } from 'zod';
-import type { ToolResult, LegacyAnalysisInput } from '../../types/index.js';
-export declare const SeamsDetectorInputSchema: {
-    projectPath: z.ZodString;
-    files: z.ZodOptional<z.ZodArray<z.ZodString>>;
-};
-export declare function handleSeamsDetector(args: LegacyAnalysisInput): Promise<ToolResult>;
-//# sourceMappingURL=seams-detector.d.ts.map

package/dist/tools/legacy/seams-detector.js

@@ -1,47 +0,0 @@
-// Planu — tools/legacy/seams-detector.ts
-// Tool handler for seams_detector.
-import { z } from 'zod';
-import { findSeams } from '../../engine/legacy/seam-finder.js';
-import { compactResult, formatTable } from '../output-formatter.js';
-// ---------------------------------------------------------------------------
-// Input schema
-// ---------------------------------------------------------------------------
-export const SeamsDetectorInputSchema = {
-    projectPath: z.string().max(4096).describe('Absolute path to the project root to scan'),
-    files: z
-        .array(z.string())
-        .optional()
-        .describe('Optional list of absolute file paths to scan. If omitted, scans src/**/*.{ts,js}'),
-};
-// ---------------------------------------------------------------------------
-// Handler
-// ---------------------------------------------------------------------------
-export async function handleSeamsDetector(args) {
-    const { projectPath, files } = args;
-    const result = await findSeams(projectPath, files);
-    if (result.seams.length === 0) {
-        return compactResult(`## Seams Detector\n\n${result.summary}\n\nNo dependency break points detected.`);
-    }
-    const tableRows = result.seams.slice(0, 30).map((s) => ({
-        ID: s.id,
-        Breakability: s.breakability,
-        Category: s.category,
-        Function: s.functionName,
-        File: s.file.split('/').slice(-2).join('/'),
-        Suggestion: s.suggestion.slice(0, 80),
-    }));
-    const table = formatTable(tableRows, ['ID', 'Breakability', 'Category', 'Function', 'File', 'Suggestion'], `Seams Found (${result.seams.length})`);
-    const hardSeams = result.seams.filter((s) => s.breakability === 'hard');
-    const hardSection = hardSeams.length > 0
-        ? [
-            ``,
-            `### Hard-to-Break Seams (high priority)`,
-            ...hardSeams
-                .slice(0, 5)
-                .map((s) => `**${s.id}** \`${s.functionName}\` — ${s.description}\n` +
-                `_Suggestion_: ${s.suggestion}`),
-        ].join('\n')
-        : '';
-    return compactResult([`## Seams Detector`, ``, result.summary, ``, table, hardSection].join('\n'));
-}
-//# sourceMappingURL=seams-detector.js.map

package/dist/types/legacy.d.ts

@@ -1,151 +0,0 @@
-export type HyrumRiskCategory = 'exception-type' | 'return-shape' | 'ordering-guarantee' | 'null-vs-undefined' | 'error-message-text' | 'implicit-return';
-export interface HyrumRisk {
-    /** Unique identifier for the risk */
-    id: string;
-    /** Category of observable behavior risk */
-    category: HyrumRiskCategory;
-    /** File where the risk was detected */
-    file: string;
-    /** Line number (1-based) */
-    line: number;
-    /** Name of the function/method containing the risk */
-    functionName: string;
-    /** Human-readable description of the observable behavior */
-    description: string;
-    /** Severity: high = likely depended on, medium = possibly, low = unlikely */
-    severity: 'high' | 'medium' | 'low';
-    /** Code snippet showing the problematic pattern */
-    snippet: string;
-}
-export interface HyrumScanResult {
-    projectPath: string;
-    filesScanned: number;
-    risks: HyrumRisk[];
-    summary: string;
-}
-export type SeamCategory = 'static-call' | 'global-env' | 'inline-new' | 'hardcoded-path' | 'hardcoded-url' | 'module-singleton';
-export interface Seam {
-    /** Unique identifier for the seam */
-    id: string;
-    /** Category of the seam */
-    category: SeamCategory;
-    /** File where the seam was detected */
-    file: string;
-    /** Line number (1-based) */
-    line: number;
-    /** Name of the enclosing function/method */
-    functionName: string;
-    /** Human-readable description of the seam */
-    description: string;
-    /** The pattern that was matched */
-    pattern: string;
-    /** Suggested refactoring approach */
-    suggestion: string;
-    /** How easy it is to break this seam: easy | moderate | hard */
-    breakability: 'easy' | 'moderate' | 'hard';
-}
-export interface SeamScanResult {
-    projectPath: string;
-    filesScanned: number;
-    seams: Seam[];
-    summary: string;
-}
-export interface SampleInput {
-    /** Parameter name */
-    name: string;
-    /** Suggested sample value (as source code string) */
-    value: string;
-    /** Inferred TypeScript type */
-    type: string;
-}
-export interface CharacterizationTest {
-    /** Unique identifier */
-    id: string;
-    /** File being characterized */
-    sourceFile: string;
-    /** Function/method to characterize */
-    functionName: string;
-    /** Generated test stub code */
-    testCode: string;
-    /** Detected sample inputs for the function */
-    sampleInputs: SampleInput[];
-    /** Note to the developer about filling in expected values */
-    developerNote: string;
-}
-export interface CharacterizationResult {
-    projectPath: string;
-    filesAnalyzed: number;
-    tests: CharacterizationTest[];
-    outputFile: string;
-    summary: string;
-}
-export type SafetyNetStepStatus = 'pending' | 'in-progress' | 'done' | 'skipped' | 'failed';
-export interface SafetyNetStep {
-    /** Step number (1-based) */
-    order: number;
-    /** Short label for the step */
-    label: string;
-    /** Detailed description of what to do */
-    description: string;
-    /** Status of the step */
-    status: SafetyNetStepStatus;
-    /** Estimated effort in minutes */
-    estimatedMinutes: number;
-}
-export interface RefactorStep {
-    /** Target file to refactor */
-    file: string;
-    /** Description of what to change */
-    change: string;
-    /** Pattern: extract-function | inject-dependency | replace-singleton | introduce-seam */
-    pattern: 'extract-function' | 'inject-dependency' | 'replace-singleton' | 'introduce-seam';
-    /** Whether a test must exist before this step */
-    requiresTest: boolean;
-    /** Risk level for this step */
-    risk: 'low' | 'medium' | 'high';
-}
-export interface SafetyNetPlan {
-    projectPath: string;
-    targetFiles: string[];
-    coverageBaseline: number;
-    steps: SafetyNetStep[];
-    refactorSteps: RefactorStep[];
-    summary: string;
-}
-export interface LegacyFunctionInfo {
-    name: string;
-    line: number;
-    params: string[];
-    body: string;
-    snippet: string;
-}
-export interface LegacyFileAnalysis {
-    filePath: string;
-    functions: LegacyFunctionInfo[];
-    lines: string[];
-}
-export interface HyrumRiskPattern {
-    category: HyrumRiskCategory;
-    regex: RegExp;
-    severity: HyrumRisk['severity'];
-    describe: (match: RegExpMatchArray) => string;
-}
-export interface LegacySeamPattern {
-    category: SeamCategory;
-    regex: RegExp;
-    breakability: Seam['breakability'];
-    describe: (match: RegExpMatchArray) => string;
-    suggest: (match: RegExpMatchArray) => string;
-}
-export interface LegacyAnalysisInput {
-    projectPath: string;
-    files?: string[];
-}
-export interface CharacterizeLegacyInput extends LegacyAnalysisInput {
-    outputFile?: string;
-}
-export interface RefactorSafetyNetInput extends LegacyAnalysisInput {
-    coverageThreshold?: number;
-    dryRun?: boolean;
-}
-//# sourceMappingURL=legacy.d.ts.map

package/dist/types/legacy.js

@@ -1,5 +0,0 @@
-// Planu — legacy.ts
-// Types for Legacy Code Specialization (SPEC-480): characterization tests,
-// Hyrum risks, seams detection, and safety-net refactoring.
-export {};
-//# sourceMappingURL=legacy.js.map