@planu/cli 4.14.1 → 5.1.1

package/dist/engine/session-safeguard/checkpoint-runner.js

@@ -1,70 +0,0 @@
-import { detectUnpushedCommits } from './unpushed-detector.js';
-import { flushBuffer } from './learnings-buffer.js';
-import { safeAutopush } from './autopush.js';
-const WARN_UNPUSHED_HOURS = 2;
-/** Regenerate session-context.md (fire-and-forget, best-effort). */
-async function regenerateSessionContext(projectPath) {
-    try {
-        const { generateSessionContext } = await import('../session-context-generator.js');
-        const { resolveProjectIdOrAutoDetect } = await import('../../tools/resolve-project-id.js');
-        const resolved = await resolveProjectIdOrAutoDetect({ projectPath });
-        if (!resolved.ok) {
-            return false;
-        }
-        await generateSessionContext(projectPath, resolved.projectId);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/** Build the human-readable summary line for checkpoint output. */
-function buildHumanSummary(sessionContextRefreshed, learningsFlushed, unpushed, pushed) {
-    const parts = [];
-    if (sessionContextRefreshed) {
-        parts.push('session-context.md refreshed');
-    }
-    if (learningsFlushed > 0) {
-        parts.push(`${String(learningsFlushed)} learning(s) flushed to MEMORY.md`);
-    }
-    if (pushed !== undefined) {
-        if (pushed.pushed) {
-            parts.push(`autopush: ${String(pushed.commitsPushed)} commit(s) pushed to ${pushed.ref}`);
-        }
-        else {
-            parts.push(`autopush skipped (${pushed.reason})`);
-        }
-    }
-    else if (unpushed && unpushed.oldestAgeHours >= WARN_UNPUSHED_HOURS) {
-        parts.push(`WARNING: ${String(unpushed.count)} commit(s) unpushed for ${String(unpushed.oldestAgeHours)}h on branch ${unpushed.branch}. Run git push or enable autopush.`);
-    }
-    return parts.length > 0 ? parts.join('; ') : 'Checkpoint complete — nothing to do.';
-}
-/** Run a full session checkpoint: regen context, flush buffer, detect/push unpushed. */
-export async function runCheckpoint(options) {
-    const { projectPath, dryRun = false, autopush = false, autopushBranches } = options;
-    // This runner backs the explicit checkpoint tool, so refresh even when the
-    // file mtime is recent: package releases can change semantic state instantly.
-    const sessionContextRefreshed = dryRun ? false : await regenerateSessionContext(projectPath);
-    // Flush learnings buffer
-    let learningsFlushed = 0;
-    if (!dryRun) {
-        learningsFlushed = await flushBuffer(projectPath).catch(() => 0);
-    }
-    // Detect unpushed commits
-    const unpushedCommits = await detectUnpushedCommits(projectPath);
-    // Autopush if configured
-    let pushed;
-    if (autopush && !dryRun) {
-        pushed = await safeAutopush(projectPath, autopushBranches);
-    }
-    const humanSummary = buildHumanSummary(sessionContextRefreshed, learningsFlushed, unpushedCommits, pushed);
-    return {
-        sessionContextRefreshed,
-        learningsFlushed,
-        unpushedCommits,
-        ...(pushed !== undefined ? { pushed } : {}),
-        humanSummary,
-    };
-}
-//# sourceMappingURL=checkpoint-runner.js.map

package/dist/engine/session-safeguard/learnings-buffer.d.ts

@@ -1,15 +0,0 @@
-import type { LearningsBuffer, LearningEntry } from '../../types/index.js';
-/** Read the learnings buffer for a project (best-effort, returns empty on miss). */
-export declare function readBuffer(projectPath: string): Promise<LearningsBuffer>;
-/**
- * Append an entry under the shared transactional lease authority.
- */
-export declare function appendToBuffer(projectPath: string, entry: LearningEntry): Promise<void>;
-/**
- * Flush all entries in the learnings buffer to MEMORY.md.
- * Appends under an existing section or creates a new one.
- * Clears the buffer after successful write.
- * Returns the number of entries flushed.
- */
-export declare function flushBuffer(projectPath: string): Promise<number>;
-//# sourceMappingURL=learnings-buffer.d.ts.map

package/dist/engine/session-safeguard/learnings-buffer.js

@@ -1,91 +0,0 @@
-// engine/session-safeguard/learnings-buffer.ts — SPEC-585: Append/flush learnings buffer
-import { readFile, mkdir } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import { hashProjectPath, projectDataDir } from '../../storage/base-store.js';
-import { acquireLock, releaseLock } from '../safety/file-mutex.js';
-import { atomicWriteFile } from '../safety/atomic-write-file.js';
-import { assertNoObsoleteFileLock } from '../safety/obsolete-lock-guard.js';
-const BUFFER_VERSION = 1;
-const LOCK_TIMEOUT_MS = 10_000;
-function bufferPath(projectPath) {
-    const hash = hashProjectPath(projectPath);
-    return join(projectDataDir(hash), 'learnings-buffer.json');
-}
-function claudeMemoryPath(projectPath) {
-    const projectKey = projectPath.replaceAll('\\', '-').replaceAll('/', '-');
-    return join(homedir(), '.claude', 'projects', projectKey, 'memory', 'MEMORY.md');
-}
-function emptyBuffer() {
-    return { version: BUFFER_VERSION, entries: [] };
-}
-/** Read the learnings buffer for a project (best-effort, returns empty on miss). */
-export async function readBuffer(projectPath) {
-    try {
-        const raw = await readFile(bufferPath(projectPath), 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return emptyBuffer();
-    }
-}
-/** Write the buffer to disk, creating parent dirs as needed. */
-async function writeBuffer(projectPath, buffer) {
-    const path = bufferPath(projectPath);
-    await mkdir(join(path, '..'), { recursive: true });
-    await atomicWriteFile(path, JSON.stringify(buffer, null, 2));
-}
-async function withBufferLock(projectPath, operation) {
-    await assertNoObsoleteFileLock(`${bufferPath(projectPath)}.lock`, 'learnings buffer');
-    const handle = await acquireLock(bufferPath(projectPath), LOCK_TIMEOUT_MS);
-    try {
-        return await operation();
-    }
-    finally {
-        await releaseLock(handle);
-    }
-}
-/**
- * Append an entry under the shared transactional lease authority.
- */
-export async function appendToBuffer(projectPath, entry) {
-    await withBufferLock(projectPath, async () => {
-        const buffer = await readBuffer(projectPath);
-        buffer.entries.push(entry);
-        await writeBuffer(projectPath, buffer);
-    });
-}
-/** Build the markdown bullet for an entry to append to MEMORY.md. */
-function entryToMarkdown(entry) {
-    const label = `[${entry.category}/${entry.source}]`;
-    return `- ${label} ${entry.content} _(${entry.timestamp.slice(0, 10)})_`;
-}
-/**
- * Flush all entries in the learnings buffer to MEMORY.md.
- * Appends under an existing section or creates a new one.
- * Clears the buffer after successful write.
- * Returns the number of entries flushed.
- */
-export async function flushBuffer(projectPath) {
-    return withBufferLock(projectPath, async () => {
-        const buffer = await readBuffer(projectPath);
-        if (buffer.entries.length === 0) {
-            return 0;
-        }
-        const memoryPath = claudeMemoryPath(projectPath);
-        let existing = '';
-        try {
-            existing = await readFile(memoryPath, 'utf-8');
-        }
-        catch {
-            /* file may not exist */
-        }
-        const bullets = buffer.entries.map(entryToMarkdown).join('\n');
-        const section = `\n\n## Session Learnings (auto-flushed ${new Date().toISOString().slice(0, 10)})\n\n${bullets}\n`;
-        await mkdir(join(memoryPath, '..'), { recursive: true });
-        await atomicWriteFile(memoryPath, existing + section);
-        await writeBuffer(projectPath, emptyBuffer());
-        return buffer.entries.length;
-    });
-}
-//# sourceMappingURL=learnings-buffer.js.map

package/dist/engine/session-safeguard/precompaction-drain.d.ts

@@ -1,10 +0,0 @@
-import type { PrecompactionDrainReport, PrecompactionDrainOptions } from '../../types/claude-code-runtime.js';
-/**
- * Drain learnings buffer to MEMORY.md fragments, autopush unpushed commits,
- * and write session-context.md — all before context compaction completes.
- *
- * Every operation is best-effort: a failure in one step does not prevent
- * the others from running. The drain report captures all outcomes.
- */
-export declare function runPrecompactionDrain(projectPath: string, options?: PrecompactionDrainOptions): Promise<PrecompactionDrainReport>;
-//# sourceMappingURL=precompaction-drain.d.ts.map

package/dist/engine/session-safeguard/precompaction-drain.js

@@ -1,82 +0,0 @@
-// engine/session-safeguard/precompaction-drain.ts — SPEC-587
-// Runs when PreCompaction fires: drains learnings buffer, autopushes commits,
-// writes session-context.md — all before context compaction completes.
-import { flushBuffer } from './learnings-buffer.js';
-import { safeAutopush } from './autopush.js';
-/**
- * Regenerate session-context.md (best-effort, resolves projectId automatically).
- * Returns true when successfully written.
- */
-async function writeSessionContext(projectPath) {
-    try {
-        const { generateSessionContext } = await import('../session-context-generator.js');
-        const { resolveProjectIdOrAutoDetect } = await import('../../tools/resolve-project-id.js');
-        const resolved = await resolveProjectIdOrAutoDetect({ projectPath });
-        if (!resolved.ok) {
-            return false;
-        }
-        await generateSessionContext(projectPath, resolved.projectId);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Drain learnings buffer to MEMORY.md fragments, autopush unpushed commits,
- * and write session-context.md — all before context compaction completes.
- *
- * Every operation is best-effort: a failure in one step does not prevent
- * the others from running. The drain report captures all outcomes.
- */
-export async function runPrecompactionDrain(projectPath, options = {}) {
-    const { dryRun = false, autopushBranches } = options;
-    // 1. Drain learnings buffer to MEMORY.md fragments
-    let learningsFlushed = 0;
-    if (!dryRun) {
-        learningsFlushed = await flushBuffer(projectPath).catch(() => 0);
-    }
-    // 2. Autopush unpushed commits (best-effort)
-    let autopushResult;
-    if (!dryRun) {
-        const result = await safeAutopush(projectPath, autopushBranches).catch((err) => {
-            const msg = err instanceof Error ? err.message : String(err);
-            return { pushed: false, reason: msg };
-        });
-        autopushResult = result.pushed
-            ? { pushed: true, ref: result.ref, commitsPushed: result.commitsPushed }
-            : { pushed: false, reason: result.reason };
-    }
-    else {
-        autopushResult = { pushed: false, reason: 'dry-run' };
-    }
-    // 3. Write session-context.md
-    let sessionContextWritten = false;
-    if (!dryRun) {
-        sessionContextWritten = await writeSessionContext(projectPath);
-    }
-    // Build human summary
-    const parts = [];
-    if (learningsFlushed > 0) {
-        parts.push(`${String(learningsFlushed)} learning(s) flushed to MEMORY.md`);
-    }
-    if (autopushResult.pushed) {
-        parts.push(`autopush: ${String(autopushResult.commitsPushed)} commit(s) pushed to ${autopushResult.ref}`);
-    }
-    else {
-        parts.push(`autopush skipped (${autopushResult.reason})`);
-    }
-    if (sessionContextWritten) {
-        parts.push('session-context.md written');
-    }
-    const humanSummary = parts.length > 0
-        ? `PreCompaction drain: ${parts.join('; ')}`
-        : 'PreCompaction drain: nothing to do';
-    return {
-        learningsFlushed,
-        sessionContextWritten,
-        autopushResult,
-        humanSummary,
-    };
-}
-//# sourceMappingURL=precompaction-drain.js.map

package/dist/engine/session-safeguard/unpushed-detector.d.ts

@@ -1,7 +0,0 @@
-import type { UnpushedCommitInfo } from '../../types/index.js';
-/**
- * Detect unpushed commits on the current branch.
- * Returns null when not a git repo, detached HEAD, or no upstream configured.
- */
-export declare function detectUnpushedCommits(projectPath: string): Promise<UnpushedCommitInfo | null>;
-//# sourceMappingURL=unpushed-detector.d.ts.map

package/dist/engine/session-safeguard/unpushed-detector.js

@@ -1,59 +0,0 @@
-// engine/session-safeguard/unpushed-detector.ts — SPEC-585: Detect unpushed commits with age
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-const execFileAsync = promisify(execFile);
-const MS_PER_HOUR = 3_600_000;
-/** Return the current branch name or null if not in a git repo / detached HEAD. */
-async function getBranch(projectPath) {
-    try {
-        const { stdout } = await execFileAsync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
-            cwd: projectPath,
-        });
-        const branch = stdout.trim();
-        return branch && branch !== 'HEAD' ? branch : null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * List unpushed commits as Unix timestamps (author date, seconds).
- * Returns empty array when no upstream or no commits ahead.
- */
-async function getUnpushedTimestamps(projectPath, branch) {
-    try {
-        const { stdout } = await execFileAsync('git', ['log', `origin/${branch}..HEAD`, '--format=%at'], { cwd: projectPath });
-        return stdout
-            .trim()
-            .split('\n')
-            .filter(Boolean)
-            .map((line) => parseInt(line, 10))
-            .filter((n) => !isNaN(n));
-    }
-    catch {
-        return [];
-    }
-}
-/**
- * Detect unpushed commits on the current branch.
- * Returns null when not a git repo, detached HEAD, or no upstream configured.
- */
-export async function detectUnpushedCommits(projectPath) {
-    const branch = await getBranch(projectPath);
-    if (!branch) {
-        return null;
-    }
-    const timestamps = await getUnpushedTimestamps(projectPath, branch);
-    if (timestamps.length === 0) {
-        return null;
-    }
-    const nowMs = Date.now();
-    const oldestTimestampMs = Math.min(...timestamps) * 1000;
-    const oldestAgeHours = Math.round((nowMs - oldestTimestampMs) / MS_PER_HOUR);
-    return {
-        count: timestamps.length,
-        branch,
-        oldestAgeHours,
-    };
-}
-//# sourceMappingURL=unpushed-detector.js.map

package/dist/engine/spec-changelog/core.d.ts

@@ -1,16 +0,0 @@
-import type { SpecChangelogEntry, SpecChangelogData, AppendChangelogOptions, ReadChangelogOptions } from '../../types/index.js';
-/** Format a single changelog entry as Markdown. */
-export declare function formatEntry(entry: SpecChangelogEntry, specId: string): string;
-/** Parse the timestamp from the first entry in a CHANGELOG.md content. */
-export declare function parseFirstEntryTimestamp(content: string): string | null;
-/** Parse changelog entries from a CHANGELOG.md content string. */
-export declare function parseChangelogEntries(content: string, specId: string): SpecChangelogEntry[];
-/** Read the CHANGELOG.md for a spec directory. Returns null if not found. */
-export declare function readChangelog(options: ReadChangelogOptions): Promise<SpecChangelogData | null>;
-/** Read only the timestamp of the last (most recent) changelog entry. Optimized for list_specs. */
-export declare function readLastModifiedTimestamp(specDir: string): Promise<string | null>;
-/** Append a new entry to the CHANGELOG.md for a spec. Creates the file if it doesn't exist. */
-export declare function appendChangelogEntry(options: AppendChangelogOptions): Promise<boolean>;
-/** Format a relative date string (e.g. "hace 2 dias") for a timestamp. */
-export declare function formatRelativeDate(timestamp: string): string;
-//# sourceMappingURL=core.d.ts.map

package/dist/engine/spec-changelog/core.js

@@ -1,176 +0,0 @@
-// engine/spec-changelog/core.ts — Changelog entry creation and persistence
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-const CHANGELOG_FILENAME = 'CHANGELOG.md';
-const CHANGELOG_VERSION_COMMENT = '<!-- changelog-version: 1 -->';
-/** Format a single changelog entry as Markdown. */
-export function formatEntry(entry, specId) {
-    const lines = [];
-    lines.push(`## ${entry.timestamp} — ${entry.type}`);
-    lines.push('');
-    lines.push(`**Tool**: ${entry.triggeredBy}`);
-    lines.push(`**Descripcion**: ${entry.description}`);
-    lines.push('');
-    if (entry.before !== undefined && entry.after !== undefined) {
-        if (entry.type === 'status_changed') {
-            lines.push(`**Antes**: ${entry.before.status} | **Despues**: ${entry.after.status}`);
-            lines.push(`**Progreso**: ${entry.before.completedCount}/${entry.before.criteriaCount} → ${entry.after.completedCount}/${entry.after.criteriaCount}`);
-        }
-        else {
-            lines.push(`**Criterios antes**: ${entry.before.criteriaCount} | **Criterios despues**: ${entry.after.criteriaCount}`);
-            if (entry.type === 'progress_updated') {
-                lines.push(`**Progreso**: ${entry.before.completedCount}/${entry.before.criteriaCount} → ${entry.after.completedCount}/${entry.after.criteriaCount}`);
-            }
-        }
-        lines.push('');
-    }
-    if (entry.diff !== undefined) {
-        const { added, removed, modified } = entry.diff;
-        const hasCriteriaChanges = added.length > 0 || removed.length > 0 || modified.length > 0;
-        if (hasCriteriaChanges) {
-            lines.push('### Criterios modificados');
-            for (const item of added) {
-                lines.push(`\u2795 ${item}`);
-            }
-            for (const item of removed) {
-                lines.push(`\u2796 ${item}`);
-            }
-            for (const item of modified) {
-                lines.push(`\u270f\ufe0f ${item.after} (antes: ${item.before})`);
-            }
-            lines.push('');
-        }
-    }
-    lines.push('---');
-    lines.push('');
-    void specId; // referenced in header externally
-    return lines.join('\n');
-}
-/** Build the full CHANGELOG.md header for a spec. */
-function buildHeader(specId, specTitle) {
-    const title = specTitle ? `${specId}: ${specTitle}` : specId;
-    return [CHANGELOG_VERSION_COMMENT, '', `# Changelog — ${title}`, '', ''].join('\n');
-}
-/** Parse the timestamp from the first entry in a CHANGELOG.md content. */
-export function parseFirstEntryTimestamp(content) {
-    // Matches lines like: ## 2026-03-04T14:23:00Z — reconciled
-    const match = /^## (\d{4}-\d{2}-\d{2}T[\d:.]+Z) —/m.exec(content);
-    return match?.[1] ?? null;
-}
-/** Parse changelog entries from a CHANGELOG.md content string. */
-export function parseChangelogEntries(content, specId) {
-    const entries = [];
-    // Split on section headers: ## <timestamp> — <type>
-    const sectionRegex = /^## (\d{4}-\d{2}-\d{2}T[\d:.]+Z) — (\w+)/gm;
-    const matches = [...content.matchAll(sectionRegex)];
-    for (const match of matches) {
-        const timestamp = match[1];
-        const type = match[2];
-        if (timestamp === undefined || type === undefined) {
-            continue;
-        }
-        const sectionStart = match.index;
-        const nextIdx = matches.indexOf(match) + 1;
-        const nextMatch = nextIdx < matches.length ? matches[nextIdx] : undefined;
-        const sectionEnd = nextMatch?.index ?? content.length;
-        const sectionContent = content.slice(sectionStart, sectionEnd);
-        // Extract tool name
-        const toolMatch = /\*\*Tool\*\*: (.+)/.exec(sectionContent);
-        const triggeredBy = toolMatch?.[1]?.trim() ?? 'unknown';
-        // Extract description
-        const descMatch = /\*\*Descripcion\*\*: (.+)/.exec(sectionContent);
-        const description = descMatch?.[1]?.trim() ?? '';
-        entries.push({
-            timestamp,
-            type: type,
-            description,
-            triggeredBy,
-        });
-    }
-    void specId;
-    return entries;
-}
-/** Read the CHANGELOG.md for a spec directory. Returns null if not found. */
-export async function readChangelog(options) {
-    const { specDir, specId } = options;
-    const filePath = join(specDir, CHANGELOG_FILENAME);
-    try {
-        const content = await readFile(filePath, 'utf-8');
-        const entries = parseChangelogEntries(content, specId);
-        return { specId, entries };
-    }
-    catch {
-        return null;
-    }
-}
-/** Read only the timestamp of the last (most recent) changelog entry. Optimized for list_specs. */
-export async function readLastModifiedTimestamp(specDir) {
-    const filePath = join(specDir, CHANGELOG_FILENAME);
-    try {
-        const content = await readFile(filePath, 'utf-8');
-        return parseFirstEntryTimestamp(content);
-    }
-    catch {
-        return null;
-    }
-}
-/** Append a new entry to the CHANGELOG.md for a spec. Creates the file if it doesn't exist. */
-export async function appendChangelogEntry(options) {
-    const { specDir, specId, entry } = options;
-    const filePath = join(specDir, CHANGELOG_FILENAME);
-    try {
-        let existingContent = '';
-        let hasHeader = false;
-        try {
-            existingContent = await readFile(filePath, 'utf-8');
-            hasHeader = existingContent.includes(CHANGELOG_VERSION_COMMENT);
-        }
-        catch {
-            // File doesn't exist yet — will create fresh
-        }
-        const entryMarkdown = formatEntry(entry, specId);
-        let newContent;
-        if (!hasHeader) {
-            newContent = buildHeader(specId) + entryMarkdown + existingContent;
-        }
-        else {
-            // Insert after the header block (after the # Changelog line)
-            const insertAfterPattern = /^# Changelog[^\n]*\n\n/m;
-            const match = insertAfterPattern.exec(existingContent);
-            if (match) {
-                const insertAt = match.index + match[0].length;
-                newContent =
-                    existingContent.slice(0, insertAt) + entryMarkdown + existingContent.slice(insertAt);
-            }
-            else {
-                // Fallback: append after existing content
-                newContent = existingContent + entryMarkdown;
-            }
-        }
-        await writeFile(filePath, newContent, 'utf-8');
-        return true;
-    }
-    catch (error) {
-        console.error(`[spec-changelog] Failed to write CHANGELOG.md for ${specId}:`, error);
-        return false;
-    }
-}
-/** Format a relative date string (e.g. "hace 2 dias") for a timestamp. */
-export function formatRelativeDate(timestamp) {
-    const date = new Date(timestamp);
-    const now = new Date();
-    const diffMs = now.getTime() - date.getTime();
-    const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
-    if (diffDays === 0) {
-        return 'hoy';
-    }
-    if (diffDays === 1) {
-        return 'hace 1 dia';
-    }
-    if (diffDays <= 30) {
-        return `hace ${diffDays} dias`;
-    }
-    // Older than 30 days: return ISO date portion
-    return timestamp.slice(0, 10);
-}
-//# sourceMappingURL=core.js.map

package/dist/engine/spec-changelog/diff.d.ts

@@ -1,18 +0,0 @@
-import type { CriteriaDiff } from '../../types/index.js';
-/** Normalize a criteria text for comparison (trim, collapse whitespace). */
-export declare function normalizeCriteriaText(text: string): string;
-/**
- * Compute a simple similarity score (0–1) between two strings.
- * Uses character bigram overlap.
- */
-export declare function similarityScore(a: string, b: string): number;
-/**
- * Compute semantic diff between two sets of criteria texts.
- * Returns added, removed, and modified criteria.
- */
-export declare function computeCriteriaDiff(before: string[], after: string[]): CriteriaDiff;
-/**
- * Returns true if the diff contains any actual changes.
- */
-export declare function hasDiffChanges(diff: CriteriaDiff): boolean;
-//# sourceMappingURL=diff.d.ts.map

package/dist/engine/spec-changelog/diff.js

@@ -1,121 +0,0 @@
-// engine/spec-changelog/diff.ts — Semantic diff calculation for spec criteria
-/** Normalize a criteria text for comparison (trim, collapse whitespace). */
-export function normalizeCriteriaText(text) {
-    return text
-        .replace(/^#+\s+/, '') // remove markdown headers
-        .replace(/\*\*/g, '') // remove bold markers
-        .replace(/\s+/g, ' ') // collapse whitespace
-        .trim()
-        .toLowerCase();
-}
-/**
- * Compute a simple similarity score (0–1) between two strings.
- * Uses character bigram overlap.
- */
-export function similarityScore(a, b) {
-    if (a.length === 0 && b.length === 0) {
-        return 0;
-    }
-    if (a === b) {
-        return 1;
-    }
-    if (a.length === 0 || b.length === 0) {
-        return 0;
-    }
-    const buildBigrams = (str) => {
-        const bigrams = new Set();
-        for (let i = 0; i < str.length - 1; i++) {
-            bigrams.add(str.slice(i, i + 2));
-        }
-        return bigrams;
-    };
-    const bigramsA = buildBigrams(a);
-    const bigramsB = buildBigrams(b);
-    let intersection = 0;
-    for (const bigram of bigramsA) {
-        if (bigramsB.has(bigram)) {
-            intersection++;
-        }
-    }
-    const total = bigramsA.size + bigramsB.size;
-    // Single-char strings produce no bigrams — fall back to exact match
-    if (total === 0) {
-        return a === b ? 1 : 0;
-    }
-    return (2 * intersection) / total;
-}
-/**
- * Compute semantic diff between two sets of criteria texts.
- * Returns added, removed, and modified criteria.
- */
-export function computeCriteriaDiff(before, after) {
-    const normalizedBefore = before.map(normalizeCriteriaText);
-    const normalizedAfter = after.map(normalizeCriteriaText);
-    const SIMILARITY_THRESHOLD = 0.6;
-    const matchedBeforeIndices = new Set();
-    const matchedAfterIndices = new Set();
-    const modified = [];
-    // Find modifications: pairs with high similarity but not identical
-    for (let i = 0; i < normalizedBefore.length; i++) {
-        const nb = normalizedBefore[i];
-        /* v8 ignore next 2 — noUncheckedIndexedAccess guard; array built with .map() so never undefined */
-        if (nb === undefined) {
-            continue;
-        }
-        let bestScore = 0;
-        let bestJ = -1;
-        for (let j = 0; j < normalizedAfter.length; j++) {
-            if (matchedAfterIndices.has(j)) {
-                continue;
-            }
-            const na = normalizedAfter[j];
-            /* v8 ignore next 2 — noUncheckedIndexedAccess guard; array built with .map() so never undefined */
-            if (na === undefined) {
-                continue;
-            }
-            const score = similarityScore(nb, na);
-            if (score > bestScore) {
-                bestScore = score;
-                bestJ = j;
-            }
-        }
-        if (bestScore >= SIMILARITY_THRESHOLD && bestJ !== -1) {
-            matchedBeforeIndices.add(i);
-            matchedAfterIndices.add(bestJ);
-            const beforeText = before[i];
-            const afterText = after[bestJ];
-            // Only report as modified if texts actually differ
-            if (beforeText !== undefined && afterText !== undefined && beforeText !== afterText) {
-                modified.push({ before: beforeText, after: afterText });
-            }
-        }
-    }
-    // Removed: unmatched before items
-    const removed = [];
-    for (let i = 0; i < before.length; i++) {
-        if (!matchedBeforeIndices.has(i)) {
-            const text = before[i];
-            if (text !== undefined) {
-                removed.push(text);
-            }
-        }
-    }
-    // Added: unmatched after items
-    const added = [];
-    for (let j = 0; j < after.length; j++) {
-        if (!matchedAfterIndices.has(j)) {
-            const text = after[j];
-            if (text !== undefined) {
-                added.push(text);
-            }
-        }
-    }
-    return { added, removed, modified };
-}
-/**
- * Returns true if the diff contains any actual changes.
- */
-export function hasDiffChanges(diff) {
-    return diff.added.length > 0 || diff.removed.length > 0 || diff.modified.length > 0;
-}
-//# sourceMappingURL=diff.js.map

package/dist/engine/spec-changelog/index.d.ts

@@ -1,3 +0,0 @@
-export * from './core.js';
-export * from './diff.js';
-//# sourceMappingURL=index.d.ts.map