@planu/cli 4.1.1 → 4.1.3

package/dist/tools/heal-planu-root.js

@@ -1,144 +0,0 @@
-// tools/heal-planu-root.ts — SPEC-745
-// heal_planu_root tool with 3-tier policy: auto-fix / propose-only / never-touch
-import { z } from 'zod';
-import { readdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { safeTracked } from './safe-handler.js';
-import { readDoNotHealList } from '../engine/heal/markers.js';
-import { classifyFile } from '../engine/heal/policy.js';
-import { backupFile } from '../engine/heal/backup.js';
-import { atomicWriteFile } from '../engine/safety/atomic-write-file.js';
-import { writeHealProposal } from '../engine/heal/proposal-writer.js';
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export async function healPlanuRoot(opts) {
-    const { projectRoot, dryRun = false } = opts;
-    const planuDir = join(projectRoot, 'planu');
-    const allowlist = readDoNotHealList(projectRoot);
-    // Collect candidate files from planu/ root (non-recursive for safety)
-    const candidateFiles = [];
-    if (existsSync(planuDir)) {
-        try {
-            const entries = readdirSync(planuDir, { withFileTypes: true });
-            for (const e of entries) {
-                if (e.isFile() && (e.name.endsWith('.json') || e.name.endsWith('.jsonl'))) {
-                    candidateFiles.push(join(planuDir, e.name));
-                }
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    const results = [];
-    const skipped = [];
-    const now = Date.now();
-    for (const filePath of candidateFiles) {
-        const policy = classifyFile(filePath, allowlist);
-        if (policy.tier === 3) {
-            if (policy.reason === 'clean') {
-                continue; // not a candidate
-            }
-            skipped.push({ path: filePath, reason: policy.reason });
-            results.push({ path: filePath, tier: 3, action: 'skipped', reason: policy.reason });
-            continue;
-        }
-        if (policy.tier === 1 && policy.repairedContent !== undefined) {
-            if (!dryRun) {
-                // Backup BEFORE write
-                const backupPath = await backupFile(filePath, now);
-                await atomicWriteFile(filePath, policy.repairedContent);
-                results.push({
-                    path: filePath,
-                    tier: 1,
-                    action: 'auto-fixed',
-                    backup: backupPath,
-                    reason: policy.reason,
-                });
-            }
-            else {
-                results.push({
-                    path: filePath,
-                    tier: 1,
-                    action: 'auto-fixed',
-                    reason: `[dryRun] ${policy.reason}`,
-                });
-            }
-            continue;
-        }
-        if (policy.tier === 2 && policy.proposedContent !== undefined) {
-            if (!dryRun) {
-                const proposalPath = await writeHealProposal(filePath, {
-                    originalPath: filePath,
-                    proposedContent: policy.proposedContent,
-                    violations: policy.violations ?? [],
-                    generatedAt: new Date().toISOString(),
-                }, now);
-                results.push({
-                    path: filePath,
-                    tier: 2,
-                    action: 'proposal-emitted',
-                    proposalPath,
-                    reason: policy.reason,
-                });
-            }
-            else {
-                results.push({
-                    path: filePath,
-                    tier: 2,
-                    action: 'proposal-emitted',
-                    reason: `[dryRun] ${policy.reason}`,
-                });
-            }
-        }
-    }
-    return { scanned: candidateFiles.length, results, skipped };
-}
-// ---------------------------------------------------------------------------
-// MCP registration
-// ---------------------------------------------------------------------------
-export function registerHealPlanuRootTool(server) {
-    server.registerTool('heal_planu_root', {
-        description: 'Run a 3-tier heal pass over planu/ config files. ' +
-            'Tier-1 (auto-fix): invalid JSON syntax is repaired atomically with a .bak backup. ' +
-            'Tier-2 (propose-only): out-of-range values generate a .heal-proposal.<ts>.json for human review. ' +
-            'Tier-3 (never-touch): files with `// custom` header or in .planu-do-not-heal are skipped. ' +
-            'Use dryRun=true to preview without writing.',
-        inputSchema: {
-            projectPath: z.string().min(1).max(4096).describe('Absolute path to project root.'),
-            dryRun: z
-                .boolean()
-                .optional()
-                .describe('Preview mode — reports what would be done without writing. Default: false.'),
-        },
-    }, safeTracked('heal_planu_root', async (args) => {
-        const { projectPath, dryRun } = args;
-        const result = await healPlanuRoot({ projectRoot: projectPath, dryRun });
-        const autoFixed = result.results.filter((r) => r.action === 'auto-fixed').length;
-        const proposals = result.results.filter((r) => r.action === 'proposal-emitted').length;
-        const skippedCount = result.results.filter((r) => r.action === 'skipped').length;
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: [
-                        `# Heal Planu Root${dryRun ? ' (dry run)' : ''}`,
-                        ``,
-                        `**Scanned**: ${result.scanned} files`,
-                        `**Auto-fixed (tier-1)**: ${autoFixed}`,
-                        `**Proposals emitted (tier-2)**: ${proposals}`,
-                        `**Skipped (tier-3)**: ${skippedCount}`,
-                        ``,
-                        result.results.length > 0
-                            ? result.results
-                                .map((r) => `- [tier-${r.tier}] ${r.action}: \`${r.path}\`${r.backup ? ` → backup: \`${r.backup}\`` : ''}${r.proposalPath ? ` → proposal: \`${r.proposalPath}\`` : ''}${r.reason ? ` (${r.reason})` : ''}`)
-                                .join('\n')
-                            : '_No issues found._',
-                    ].join('\n'),
-                },
-            ],
-        };
-    }));
-}
-//# sourceMappingURL=heal-planu-root.js.map

package/dist/tools/opencode-host-adapter.d.ts

@@ -1,3 +0,0 @@
-import type { OpenCodeAdapterInput, ToolResult } from '../types/index.js';
-export declare function handleOpenCodeHostAdapter(args: OpenCodeAdapterInput): Promise<ToolResult>;
-//# sourceMappingURL=opencode-host-adapter.d.ts.map

package/dist/tools/opencode-host-adapter.js

@@ -1,33 +0,0 @@
-// src/tools/opencode-host-adapter.ts — SPEC-966 tool handler
-import { runOpenCodeAdapter } from '../engine/opencode/adapter.js';
-export async function handleOpenCodeHostAdapter(args) {
-    const result = await runOpenCodeAdapter(args);
-    const lines = [];
-    lines.push(`# OpenCode Host Adapter — ${result.detected ? '✅ Detected' : '❌ Not Detected'}`);
-    lines.push('');
-    lines.push(`**Markers found:** ${result.markers.join(', ') || 'none'}`);
-    if (result.configPath) {
-        lines.push(`**Config path:** ${result.configPath}`);
-    }
-    lines.push('');
-    if (result.scaffoldedFiles) {
-        lines.push('## Scaffolded Files');
-        for (const file of result.scaffoldedFiles) {
-            lines.push(`- ${file}`);
-        }
-        lines.push('');
-    }
-    if (result.coachRules) {
-        lines.push('## Coach Rules');
-        for (const rule of result.coachRules) {
-            lines.push(`- ${rule}`);
-        }
-        lines.push('');
-    }
-    return {
-        content: [{ type: 'text', text: lines.join('\n') }],
-        structuredContent: result,
-        isError: false,
-    };
-}
-//# sourceMappingURL=opencode-host-adapter.js.map

package/dist/tools/plan-team-distribution.d.ts

@@ -1,3 +0,0 @@
-import type { PlanTeamDistributionInput, ToolResult } from '../types/index.js';
-export declare function handlePlanTeamDistribution(params: PlanTeamDistributionInput): Promise<ToolResult>;
-//# sourceMappingURL=plan-team-distribution.d.ts.map

package/dist/tools/plan-team-distribution.js

@@ -1,71 +0,0 @@
-// tools/plan-team-distribution.ts — Expose planTeamDistribution as MCP tool (SPEC-091)
-// Loads specs, extracts file ownership from each spec.md, and delegates to the engine.
-import { readFile } from 'node:fs/promises';
-import { specStore } from '../storage/index.js';
-import { planTeamDistribution } from '../engine/team-planner/index.js';
-const FILE_PATTERN = /\b([\w./-]+\.(?:ts|tsx|js|jsx|py|go|rs|java|rb|cs|json|yaml|yml|vue|svelte))\b/g;
-function extractFilesFromContent(content) {
-    const found = new Set();
-    for (const line of content.split('\n')) {
-        if (line.trimStart().startsWith('#')) {
-            continue;
-        }
-        FILE_PATTERN.lastIndex = 0;
-        let match;
-        while ((match = FILE_PATTERN.exec(line)) !== null) {
-            const raw = match[1];
-            if (raw && raw.length >= 5) {
-                found.add(raw);
-            }
-        }
-    }
-    return [...found];
-}
-async function readSpecFiles(specPath) {
-    try {
-        const content = await readFile(specPath, 'utf-8');
-        return extractFilesFromContent(content);
-    }
-    catch {
-        return [];
-    }
-}
-export async function handlePlanTeamDistribution(params) {
-    const { projectId, specIds, template } = params;
-    if (specIds.length === 0) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: 'specIds must contain at least one spec ID. Provide the specs to distribute across the team.',
-                },
-            ],
-            isError: true,
-        };
-    }
-    const specs = [];
-    const fileOwnership = {};
-    for (const specId of specIds) {
-        const spec = await specStore.getSpec(projectId, specId);
-        if (!spec) {
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Spec '${specId}' not found in project '${projectId}'. Check the spec ID.`,
-                    },
-                ],
-                isError: true,
-            };
-        }
-        specs.push({ id: spec.id, title: spec.title });
-        fileOwnership[spec.id] = await readSpecFiles(spec.specPath);
-    }
-    const templateRef = template !== undefined && template.length > 0 ? { id: template, name: template } : undefined;
-    const plan = planTeamDistribution(specs, fileOwnership, templateRef);
-    return {
-        content: [{ type: 'text', text: JSON.stringify(plan, null, 2) }],
-        structuredContent: { plan },
-    };
-}
-//# sourceMappingURL=plan-team-distribution.js.map

package/dist/tools/reconcile-status-json.d.ts

@@ -1,4 +0,0 @@
-import type { ToolResult } from '../types/index.js';
-import type { ReconcileStatusJsonInput } from '../types/workspace-overview.js';
-export declare function handleReconcileStatusJson(params: ReconcileStatusJsonInput): Promise<ToolResult>;
-//# sourceMappingURL=reconcile-status-json.d.ts.map

package/dist/tools/reconcile-status-json.js

@@ -1,209 +0,0 @@
-// tools/reconcile-status-json.ts — SPEC-753: reconcile_status_json tool
-//
-// Reconciles status.json spec statuses with actual spec.md frontmatter values.
-// Source-of-truth rule: 'frontmatter-wins' | 'status-wins' | 'newest-wins'.
-import { join } from 'node:path';
-import { readFile, readdir, writeFile, mkdir } from 'node:fs/promises';
-import { resolveProjectPath } from '../storage/path-resolver.js';
-import { hashProjectPath } from '../storage/base-store.js';
-import { withStatusLock } from '../storage/status-store/file-lock.js';
-// ---------------------------------------------------------------------------
-// Frontmatter parser helpers (local, not exported — types in types/workspace-overview.ts)
-// ---------------------------------------------------------------------------
-function parseFrontmatter(content) {
-    const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
-    if (!match?.[1]) {
-        return null;
-    }
-    const block = match[1];
-    const result = {};
-    for (const line of block.split('\n')) {
-        const colonIdx = line.indexOf(':');
-        if (colonIdx === -1) {
-            continue;
-        }
-        const key = line.slice(0, colonIdx).trim();
-        const val = line
-            .slice(colonIdx + 1)
-            .trim()
-            .replace(/^["']|["']$/g, '');
-        if (key) {
-            result[key] = val;
-        }
-    }
-    if (!result.id || !result.status) {
-        return null;
-    }
-    return {
-        id: result.id,
-        status: result.status,
-        updated: result.updated,
-    };
-}
-async function readStatusJson(statusPath) {
-    try {
-        const raw = await readFile(statusPath, 'utf-8');
-        const parsed = JSON.parse(raw);
-        if (typeof parsed === 'object' && parsed !== null) {
-            return parsed;
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Build a map of specId → status from recentChanges in status.json.
- */
-function buildStatusJsonSpecMap(content) {
-    const map = new Map();
-    if (Array.isArray(content.recentChanges)) {
-        for (const change of content.recentChanges) {
-            if (change.specId && change.to) {
-                map.set(change.specId, change.to);
-            }
-        }
-    }
-    return map;
-}
-function resolveConflict(_specId, statusJsonStatus, frontmatterStatus, _statusJsonUpdatedAt, source) {
-    const sjStatus = statusJsonStatus ?? 'unknown';
-    if (sjStatus === frontmatterStatus) {
-        return { resolved: frontmatterStatus, changed: false };
-    }
-    let resolved;
-    if (source === 'frontmatter-wins') {
-        resolved = frontmatterStatus;
-    }
-    else if (source === 'status-wins') {
-        resolved = sjStatus !== 'unknown' ? sjStatus : frontmatterStatus;
-    }
-    else {
-        // newest-wins: frontmatter is considered most recent edit
-        resolved = frontmatterStatus;
-    }
-    return { resolved, changed: true };
-}
-// ---------------------------------------------------------------------------
-// Main handler
-// ---------------------------------------------------------------------------
-export async function handleReconcileStatusJson(params) {
-    const { source = 'frontmatter-wins', dryRun = true } = params;
-    const { projectPath } = await resolveProjectPath(params.projectPath);
-    const projectId = hashProjectPath(projectPath);
-    const specsDir = join(projectPath, 'planu', 'specs');
-    const statusPath = join(projectPath, 'planu', 'status.json');
-    const statusContent = await readStatusJson(statusPath);
-    const statusJsonMap = statusContent
-        ? buildStatusJsonSpecMap(statusContent)
-        : new Map();
-    const statusJsonUpdatedAt = statusContent?.updatedAt;
-    const conflicts = [];
-    let specDirs = [];
-    try {
-        specDirs = await readdir(specsDir);
-    }
-    catch {
-        // No specs dir
-    }
-    for (const dir of specDirs) {
-        const specPath = join(specsDir, dir, 'spec.md');
-        let content;
-        try {
-            content = await readFile(specPath, 'utf-8');
-        }
-        catch {
-            continue;
-        }
-        const fm = parseFrontmatter(content);
-        if (!fm) {
-            continue;
-        }
-        const sjStatus = statusJsonMap.get(fm.id);
-        const { resolved, changed } = resolveConflict(fm.id, sjStatus, fm.status, statusJsonUpdatedAt, source);
-        if (changed) {
-            conflicts.push({
-                specId: fm.id,
-                statusJson: sjStatus ?? 'not-in-recentChanges',
-                frontmatter: fm.status,
-                resolved,
-            });
-        }
-    }
-    if (!dryRun && conflicts.length > 0 && statusContent) {
-        await withStatusLock(statusPath, async () => {
-            const { specStore } = await import('../storage/index.js');
-            const allSpecs = await specStore.listSpecs(projectId);
-            const correctedMap = new Map();
-            for (const c of conflicts) {
-                correctedMap.set(c.specId, c.resolved);
-            }
-            const newByStatus = {};
-            for (const spec of allSpecs) {
-                const correctedStatus = correctedMap.get(spec.id) ?? spec.status;
-                newByStatus[correctedStatus] = (newByStatus[correctedStatus] ?? 0) + 1;
-            }
-            const updated = {
-                ...statusContent,
-                byStatus: newByStatus,
-                totalSpecs: allSpecs.length,
-                updatedAt: new Date().toISOString(),
-            };
-            await mkdir(join(projectPath, 'planu'), { recursive: true });
-            await writeFile(statusPath, JSON.stringify(updated, null, 2), 'utf-8');
-        });
-        // Log corrections to transition-log.jsonl
-        try {
-            const { appendTransitionEvent } = await import('../storage/transition-log.js');
-            for (const conflict of conflicts) {
-                await appendTransitionEvent({
-                    projectId,
-                    specId: conflict.specId,
-                    eventType: 'status_reconciled',
-                    from: conflict.statusJson,
-                    to: conflict.resolved,
-                    actor: 'reconcile_status_json',
-                    reason: `source: ${source}`,
-                    sessionId: 'reconcile',
-                });
-            }
-        }
-        catch {
-            // Non-fatal
-        }
-    }
-    const result = {
-        corrected: conflicts.length,
-        dryRun,
-        source,
-        conflicts,
-        message: dryRun
-            ? `Dry run: found ${String(conflicts.length)} discrepancies. Set dryRun=false to apply.`
-            : `Applied ${String(conflicts.length)} corrections with source '${source}'.`,
-    };
-    const lines = [
-        `# reconcile_status_json${dryRun ? ' (dry run)' : ''}`,
-        ``,
-        `**Source:** ${source}`,
-        `**Discrepancies found:** ${String(conflicts.length)}`,
-        `**Applied:** ${dryRun ? 'No (dryRun=true)' : 'Yes'}`,
-        ``,
-    ];
-    if (conflicts.length > 0) {
-        lines.push(`## Conflicts`);
-        lines.push(`| Spec | status.json | frontmatter | resolved |`);
-        lines.push(`|------|------------|-------------|----------|`);
-        for (const c of conflicts) {
-            lines.push(`| ${c.specId} | ${c.statusJson} | ${c.frontmatter} | **${c.resolved}** |`);
-        }
-    }
-    else {
-        lines.push(`No discrepancies found — status.json is in sync with frontmatters.`);
-    }
-    return {
-        content: [{ type: 'text', text: lines.join('\n') }],
-        structuredContent: result,
-    };
-}
-//# sourceMappingURL=reconcile-status-json.js.map

package/dist/tools/register-all-tools.d.ts

@@ -1,8 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-/**
- * Registers all MCP tools onto the server instance.
- * Previously split across registerCoreTools / registerExtendedTools /
- * registerLatestSpecTools / registerIntegrationTools in index.ts.
- */
-export declare function registerAllTools(s: McpServer): void;
-//# sourceMappingURL=register-all-tools.d.ts.map