@esthernandez/vibe-doc 0.1.0

package/dist/templates/registry.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * Remote Template Registry Module
+ * Handles checking for and downloading remote template updates
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkForUpdates = checkForUpdates;
+exports.downloadTemplate = downloadTemplate;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const logger_1 = require("../utils/logger");
+/**
+ * Check for template updates by fetching the manifest
+ * Falls back gracefully when offline
+ */
+async function checkForUpdates(manifestUrl, cacheDir) {
+    try {
+        logger_1.logger.debug('Checking for template updates', { manifestUrl });
+        const manifest = await fetchManifest(manifestUrl);
+        const updates = await compareWithCache(manifest.templates, cacheDir);
+        return {
+            hasUpdates: updates.length > 0,
+            availableUpdates: updates,
+            timestamp: manifest.timestamp,
+        };
+    }
+    catch (error) {
+        logger_1.logger.warn('Failed to check for updates, using cached templates', {
+            error: String(error),
+        });
+        return {
+            hasUpdates: false,
+            availableUpdates: [],
+            timestamp: new Date().toISOString(),
+        };
+    }
+}
+/**
+ * Download a template and cache it
+ */
+async function downloadTemplate(docType, url, cacheDir) {
+    try {
+        logger_1.logger.debug('Downloading template', { docType, url });
+        const content = await fetchTemplate(url);
+        const templatesDir = path.join(cacheDir, 'templates');
+        // Ensure templates directory exists
+        fs.mkdirSync(templatesDir, { recursive: true });
+        const cachePath = path.join(templatesDir, `${docType}.md`);
+        fs.writeFileSync(cachePath, content, 'utf-8');
+        logger_1.logger.info('Template downloaded and cached', { docType, path: cachePath });
+    }
+    catch (error) {
+        logger_1.logger.error('Failed to download template', { docType, error: String(error) });
+        throw new Error(`Failed to download template for ${docType}: ${String(error)}`);
+    }
+}
+/**
+ * Fetch a manifest from a remote URL with timeout
+ */
+async function fetchManifest(manifestUrl) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+    try {
+        const response = await fetch(manifestUrl, {
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch manifest: ${response.status} ${response.statusText}`);
+        }
+        return (await response.json());
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Fetch template content from a remote URL with timeout
+ */
+async function fetchTemplate(url) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 10000);
+    try {
+        const response = await fetch(url, {
+            signal: controller.signal,
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch template: ${response.status} ${response.statusText}`);
+        }
+        return await response.text();
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+/**
+ * Compare remote templates with cached versions
+ * Returns list of templates with updates available
+ */
+async function compareWithCache(remoteTemplates, cacheDir) {
+    const updates = [];
+    for (const remoteTemplate of remoteTemplates) {
+        const cachePath = path.join(cacheDir, 'templates', `${remoteTemplate.docType}.md`);
+        // Check if cached version exists
+        if (!fs.existsSync(cachePath)) {
+            updates.push({
+                docType: remoteTemplate.docType,
+                url: remoteTemplate.url,
+                hash: remoteTemplate.hash,
+                version: remoteTemplate.version,
+            });
+            continue;
+        }
+        // Compare hashes
+        const cachedContent = fs.readFileSync(cachePath, 'utf-8');
+        const cachedHash = hashContent(cachedContent);
+        if (cachedHash !== remoteTemplate.hash) {
+            updates.push({
+                docType: remoteTemplate.docType,
+                url: remoteTemplate.url,
+                hash: remoteTemplate.hash,
+                version: remoteTemplate.version,
+            });
+        }
+    }
+    return updates;
+}
+/**
+ * Simple hash function for content comparison
+ * Not for security, just for change detection
+ */
+function hashContent(content) {
+    let hash = 0;
+    for (let i = 0; i < content.length; i++) {
+        const char = content.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash; // Convert to 32-bit integer
+    }
+    return Math.abs(hash).toString(16);
+}

package/dist/templates/renderer.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Template Renderer Module
+ * Renders templates with extracted and user-provided data
+ */
+/**
+ * Data provided to the renderer
+ */
+export interface RenderData {
+    extracted: Record<string, string>;
+    user: Record<string, string>;
+    metadata: {
+        docType: string;
+        generatedAt: string;
+        classification: string;
+        sourceArtifacts: number;
+    };
+}
+/**
+ * Render a template by replacing tokens with data
+ * - {{extracted.<section-name>}} - auto-extracted data
+ * - {{user.<section-name>}} - user-provided data
+ * Marks empty sections with guidance comments
+ * Tags confidence levels per section
+ */
+export declare function renderTemplate(template: string, data: RenderData): string;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/templates/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/templates/renderer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAClC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,QAAQ,EAAE;QACR,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,cAAc,EAAE,MAAM,CAAC;QACvB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;CACH;AAaD;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,MAAM,CAwFzE"}

package/dist/templates/renderer.js

@@ -0,0 +1,145 @@
+"use strict";
+/**
+ * Template Renderer Module
+ * Renders templates with extracted and user-provided data
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = renderTemplate;
+const logger_1 = require("../utils/logger");
+/**
+ * Render a template by replacing tokens with data
+ * - {{extracted.<section-name>}} - auto-extracted data
+ * - {{user.<section-name>}} - user-provided data
+ * Marks empty sections with guidance comments
+ * Tags confidence levels per section
+ */
+function renderTemplate(template, data) {
+    let rendered = template;
+    const confidenceLevels = [];
+    // Extract all token patterns
+    const tokenPattern = /\{\{(extracted|user)\.([a-z0-9\-]+)\}\}/g;
+    const tokens = new Map();
+    let match;
+    while ((match = tokenPattern.exec(template)) !== null) {
+        const [fullToken, scope, sectionName] = match;
+        tokens.set(fullToken, sectionName);
+    }
+    // Replace tokens and track confidence
+    for (const [token, sectionName] of tokens.entries()) {
+        const [, scope] = token.match(/\{\{(extracted|user)/) || [];
+        const source = scope;
+        const extractedValue = data.extracted[sectionName]?.trim() || '';
+        const userValue = data.user[sectionName]?.trim() || '';
+        // Prefer user-provided data over extracted
+        let replacement;
+        let confidence;
+        let dataSource;
+        if (scope === 'user') {
+            if (userValue) {
+                replacement = userValue;
+                confidence = 'high';
+                dataSource = 'user';
+            }
+            else if (extractedValue) {
+                // User section can show extracted data as fallback with medium confidence
+                replacement = extractedValue;
+                confidence = 'medium';
+                dataSource = 'extracted';
+            }
+            else {
+                replacement = '';
+                confidence = 'low';
+                dataSource = 'empty';
+            }
+        }
+        else {
+            // extracted scope
+            if (extractedValue) {
+                replacement = extractedValue;
+                confidence = 'high';
+                dataSource = 'extracted';
+            }
+            else {
+                replacement = '';
+                confidence = 'low';
+                dataSource = 'empty';
+            }
+        }
+        rendered = rendered.replace(token, replacement);
+        confidenceLevels.push({ section: sectionName, confidence, source: dataSource });
+        logger_1.logger.debug('Rendered token', {
+            sectionName,
+            scope,
+            confidence,
+            hasData: !!replacement,
+        });
+    }
+    // Mark empty sections with guidance comments
+    const guidancePattern = /<!-- NEEDS INPUT: ([^-]*) -->/g;
+    let guidanceIndex = 0;
+    rendered = rendered.replace(guidancePattern, (match, guidance) => {
+        if (guidanceIndex < confidenceLevels.length) {
+            const { confidence } = confidenceLevels[guidanceIndex];
+            if (confidence === 'low') {
+                // Keep the guidance comment for empty sections
+                guidanceIndex++;
+                return match;
+            }
+        }
+        guidanceIndex++;
+        // Remove guidance comments for sections with data
+        return '';
+    });
+    // Add confidence metadata as a comment at the top
+    const confidenceSummary = generateConfidenceSummary(confidenceLevels);
+    rendered = addMetadataComment(rendered, data.metadata, confidenceSummary);
+    return rendered;
+}
+/**
+ * Generate a summary of confidence levels per section
+ */
+function generateConfidenceSummary(levels) {
+    const summary = {};
+    for (const { section, confidence } of levels) {
+        summary[section] = confidence;
+    }
+    return summary;
+}
+/**
+ * Add metadata comment to the rendered template
+ */
+function addMetadataComment(template, metadata, confidenceSummary) {
+    const frontmatterMatch = template.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontmatterMatch) {
+        logger_1.logger.warn('No frontmatter found in template');
+        return template;
+    }
+    const frontmatterEnd = frontmatterMatch[0].length;
+    const confidenceComment = generateConfidenceComment(metadata, confidenceSummary);
+    return (template.slice(0, frontmatterEnd) +
+        '\n' +
+        confidenceComment +
+        '\n' +
+        template.slice(frontmatterEnd));
+}
+/**
+ * Generate a markdown comment with metadata and confidence levels
+ */
+function generateConfidenceComment(metadata, confidenceSummary) {
+    const highConfidence = Object.entries(confidenceSummary)
+        .filter(([, level]) => level === 'high')
+        .map(([section]) => section);
+    const lowConfidence = Object.entries(confidenceSummary)
+        .filter(([, level]) => level === 'low')
+        .map(([section]) => section);
+    const lines = [
+        '<!--',
+        `Generated: ${metadata.generatedAt}`,
+        `Classification: ${metadata.classification}`,
+        `Source artifacts: ${metadata.sourceArtifacts}`,
+        `High confidence sections: ${highConfidence.length} - ${highConfidence.join(', ') || 'none'}`,
+        `Needs input: ${lowConfidence.length} - ${lowConfidence.join(', ') || 'none'}`,
+        '-->',
+    ];
+    return lines.join('\n');
+}

package/dist/utils/language-detect.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Language Detection Utility
+ * Detects programming languages based on package configuration files
+ */
+export interface DetectedLanguage {
+    name: string;
+    confidence: number;
+}
+/**
+ * Detects programming languages from a list of package config file paths
+ * Returns array of detected languages with confidence scores
+ */
+export declare function detectLanguages(packageConfigPaths: string[]): DetectedLanguage[];
+//# sourceMappingURL=language-detect.d.ts.map

package/dist/utils/language-detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"language-detect.d.ts","sourceRoot":"","sources":["../../src/utils/language-detect.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,kBAAkB,EAAE,MAAM,EAAE,GAC3B,gBAAgB,EAAE,CA0DpB"}

package/dist/utils/language-detect.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Language Detection Utility
+ * Detects programming languages based on package configuration files
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLanguages = detectLanguages;
+/**
+ * Detects programming languages from a list of package config file paths
+ * Returns array of detected languages with confidence scores
+ */
+function detectLanguages(packageConfigPaths) {
+    const languageMap = new Map();
+    for (const filePath of packageConfigPaths) {
+        const fileName = filePath.split('/').pop() || '';
+        // Node.js/TypeScript
+        if (fileName === 'package.json') {
+            languageMap.set('TypeScript/JavaScript', (languageMap.get('TypeScript/JavaScript') || 0) + 1);
+        }
+        // Python
+        if (fileName === 'pyproject.toml' || fileName === 'setup.py') {
+            languageMap.set('Python', (languageMap.get('Python') || 0) + 1);
+        }
+        // Rust
+        if (fileName === 'Cargo.toml') {
+            languageMap.set('Rust', (languageMap.get('Rust') || 0) + 1);
+        }
+        // Go
+        if (fileName === 'go.mod') {
+            languageMap.set('Go', (languageMap.get('Go') || 0) + 1);
+        }
+        // Java/Kotlin
+        if (fileName === 'pom.xml') {
+            languageMap.set('Java/Kotlin', (languageMap.get('Java/Kotlin') || 0) + 1);
+        }
+        if (fileName === 'build.gradle' || fileName === 'build.gradle.kts') {
+            languageMap.set('Java/Kotlin', (languageMap.get('Java/Kotlin') || 0) + 1);
+        }
+        // C# / .NET
+        if (fileName === 'project.csproj' || fileName.endsWith('.csproj')) {
+            languageMap.set('C#/.NET', (languageMap.get('C#/.NET') || 0) + 1);
+        }
+        // Ruby
+        if (fileName === 'Gemfile') {
+            languageMap.set('Ruby', (languageMap.get('Ruby') || 0) + 1);
+        }
+        // PHP
+        if (fileName === 'composer.json') {
+            languageMap.set('PHP', (languageMap.get('PHP') || 0) + 1);
+        }
+    }
+    // Convert to array and sort by count (confidence)
+    const languages = Array.from(languageMap.entries()).map(([name, count]) => ({
+        name,
+        confidence: Math.min(count / packageConfigPaths.length, 1),
+    }));
+    return languages.sort((a, b) => b.confidence - a.confidence);
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Structured Logger
+ * Simple logging utility with info, warn, error, and debug levels
+ */
+declare class Logger {
+    private isDev;
+    private formatTimestamp;
+    private format;
+    info(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    debug(message: string, data?: unknown): void;
+}
+export declare const logger: Logger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,cAAM,MAAM;IACV,OAAO,CAAC,KAAK,CAA0C;IAEvD,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,MAAM;IAMd,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI3C,IAAI,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI3C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;IAI5C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,IAAI;CAK7C;AAED,eAAO,MAAM,MAAM,QAAe,CAAC"}

package/dist/utils/logger.js

@@ -0,0 +1,35 @@
+"use strict";
+/**
+ * Structured Logger
+ * Simple logging utility with info, warn, error, and debug levels
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+class Logger {
+    constructor() {
+        this.isDev = process.env.NODE_ENV === 'development';
+    }
+    formatTimestamp() {
+        return new Date().toISOString();
+    }
+    format(level, message, data) {
+        const timestamp = this.formatTimestamp();
+        const dataStr = data ? ` ${JSON.stringify(data)}` : '';
+        return `[${timestamp}] [${level.toUpperCase()}] ${message}${dataStr}`;
+    }
+    info(message, data) {
+        console.log(this.format('info', message, data));
+    }
+    warn(message, data) {
+        console.warn(this.format('warn', message, data));
+    }
+    error(message, data) {
+        console.error(this.format('error', message, data));
+    }
+    debug(message, data) {
+        if (this.isDev) {
+            console.debug(this.format('debug', message, data));
+        }
+    }
+}
+exports.logger = new Logger();

package/dist/versioning/differ.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Diff Summary Generator
+ * Produces human-readable summaries of changes between document versions
+ */
+export interface DiffSummary {
+    sectionsAdded: string[];
+    sectionsRemoved: string[];
+    sectionsChanged: string[];
+    linesAdded: number;
+    linesRemoved: number;
+    summary: string;
+}
+/**
+ * Generate a diff summary between two document versions
+ * @param oldContent - Previous version content
+ * @param newContent - New version content
+ * @returns DiffSummary with changes and statistics
+ */
+export declare function generateDiffSummary(oldContent: string, newContent: string): DiffSummary;
+//# sourceMappingURL=differ.d.ts.map

package/dist/versioning/differ.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"differ.d.ts","sourceRoot":"","sources":["../../src/versioning/differ.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,MAAM,WAAW,WAAW;IAC1B,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,WAAW,CAqDvF"}

package/dist/versioning/differ.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Diff Summary Generator
+ * Produces human-readable summaries of changes between document versions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDiffSummary = generateDiffSummary;
+const Diff = __importStar(require("diff"));
+/**
+ * Generate a diff summary between two document versions
+ * @param oldContent - Previous version content
+ * @param newContent - New version content
+ * @returns DiffSummary with changes and statistics
+ */
+function generateDiffSummary(oldContent, newContent) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    // Get line-level changes
+    const changes = Diff.diffLines(oldContent, newContent);
+    // Count additions and removals
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const change of changes) {
+        if (change.added) {
+            linesAdded += change.value.split('\n').filter((l) => l.length > 0).length;
+        }
+        else if (change.removed) {
+            linesRemoved += change.value.split('\n').filter((l) => l.length > 0).length;
+        }
+    }
+    // Extract sections (markdown headers)
+    const oldSections = extractSections(oldLines);
+    const newSections = extractSections(newLines);
+    // Compare sections
+    const sectionsAdded = newSections.filter((s) => !oldSections.includes(s));
+    const sectionsRemoved = oldSections.filter((s) => !newSections.includes(s));
+    const sectionsChanged = findChangedSections(oldContent, newContent, oldSections, newSections);
+    // Build summary
+    const summaryParts = [];
+    if (sectionsAdded.length > 0) {
+        summaryParts.push(`Added ${sectionsAdded.length} section(s)`);
+    }
+    if (sectionsRemoved.length > 0) {
+        summaryParts.push(`Removed ${sectionsRemoved.length} section(s)`);
+    }
+    if (sectionsChanged.length > 0) {
+        summaryParts.push(`Updated ${sectionsChanged.length} section(s)`);
+    }
+    summaryParts.push(`+${linesAdded} -${linesRemoved} lines`);
+    const summary = summaryParts.join(', ');
+    return {
+        sectionsAdded,
+        sectionsRemoved,
+        sectionsChanged,
+        linesAdded,
+        linesRemoved,
+        summary,
+    };
+}
+/**
+ * Extract all markdown headers from content
+ * Matches ## and ### level headers
+ */
+function extractSections(lines) {
+    const sections = [];
+    for (const line of lines) {
+        if (line.match(/^##\s+/) || line.match(/^###\s+/)) {
+            // Extract header text (remove markdown syntax)
+            const text = line.replace(/^#+\s+/, '').trim();
+            if (text.length > 0) {
+                sections.push(text);
+            }
+        }
+    }
+    return sections;
+}
+/**
+ * Find sections that exist in both versions but have changed content
+ * This is a heuristic: we check if section content differs
+ */
+function findChangedSections(oldContent, newContent, oldSections, newSections) {
+    const common = oldSections.filter((s) => newSections.includes(s));
+    const changed = [];
+    for (const section of common) {
+        // Extract content for this section from both versions
+        const oldSectionContent = extractSectionContent(oldContent, section);
+        const newSectionContent = extractSectionContent(newContent, section);
+        // If content differs, it's changed
+        if (oldSectionContent !== newSectionContent) {
+            changed.push(section);
+        }
+    }
+    return changed;
+}
+/**
+ * Extract the content of a specific section from markdown
+ * Returns text from the header until the next header of same or higher level
+ */
+function extractSectionContent(content, sectionTitle) {
+    const lines = content.split('\n');
+    let startIdx = -1;
+    let endIdx = lines.length;
+    // Find the section header
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].includes(sectionTitle)) {
+            startIdx = i;
+            break;
+        }
+    }
+    if (startIdx === -1) {
+        return '';
+    }
+    // Find the next header of same or higher level (## or ###)
+    const headerMatch = lines[startIdx].match(/^(#+)\s+/);
+    const headerLevel = headerMatch ? headerMatch[1].length : 0;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        const nextHeaderMatch = lines[i].match(/^(#+)\s+/);
+        if (nextHeaderMatch) {
+            const nextLevel = nextHeaderMatch[1].length;
+            if (nextLevel <= headerLevel) {
+                endIdx = i;
+                break;
+            }
+        }
+    }
+    return lines.slice(startIdx, endIdx).join('\n');
+}