@esthernandez/vibe-doc 0.1.0

package/dist/generator/extractor.js

@@ -0,0 +1,459 @@
+"use strict";
+/**
+ * Artifact Data Extractor
+ * Maps scan inventory data to template section tokens
+ * Extracts rich context from project artifacts to pre-populate templates
+ */
+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.extractDataForDocType = extractDataForDocType;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+/**
+ * Try to read and parse package.json
+ */
+function readPackageJson(projectPath) {
+    try {
+        const pkgPath = path.join(projectPath, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return null;
+        const content = fs.readFileSync(pkgPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        logger_1.logger.debug('Failed to read package.json', { error });
+        return null;
+    }
+}
+/**
+ * Try to read CLAUDE.md for context
+ */
+function readClaudeMd(projectPath) {
+    try {
+        // Search in common locations
+        const locations = [
+            path.join(projectPath, 'CLAUDE.md'),
+            path.join(projectPath, 'docs', 'CLAUDE.md'),
+            path.join(projectPath, '.claude', 'CLAUDE.md'),
+        ];
+        for (const loc of locations) {
+            if (fs.existsSync(loc)) {
+                return fs.readFileSync(loc, 'utf-8');
+            }
+        }
+    }
+    catch (error) {
+        logger_1.logger.debug('Failed to read CLAUDE.md', { error });
+    }
+    return '';
+}
+/**
+ * Try to read Dockerfile for deployment info
+ */
+function readDockerfile(projectPath) {
+    try {
+        const dockerPath = path.join(projectPath, 'Dockerfile');
+        if (!fs.existsSync(dockerPath))
+            return '';
+        return fs.readFileSync(dockerPath, 'utf-8');
+    }
+    catch (error) {
+        logger_1.logger.debug('Failed to read Dockerfile', { error });
+        return '';
+    }
+}
+/**
+ * Try to read GitHub Actions workflow for CI/CD
+ */
+function readWorkflow(projectPath) {
+    try {
+        const workflowDir = path.join(projectPath, '.github', 'workflows');
+        if (!fs.existsSync(workflowDir))
+            return '';
+        const files = fs.readdirSync(workflowDir);
+        const yamlFiles = files.filter(f => f.endsWith('.yml') || f.endsWith('.yaml'));
+        if (yamlFiles.length === 0)
+            return '';
+        // Read first workflow file
+        const workflowPath = path.join(workflowDir, yamlFiles[0]);
+        return fs.readFileSync(workflowPath, 'utf-8');
+    }
+    catch (error) {
+        logger_1.logger.debug('Failed to read workflow', { error });
+        return '';
+    }
+}
+/**
+ * Extract Runbook sections
+ */
+function extractRunbook(projectPath, state) {
+    const pkg = readPackageJson(projectPath);
+    const claude = readClaudeMd(projectPath);
+    const dockerfile = readDockerfile(projectPath);
+    const workflow = readWorkflow(projectPath);
+    const result = {};
+    // service-overview: from package.json description and CLAUDE.md
+    if (pkg?.description) {
+        result['service-overview'] = pkg.description;
+    }
+    else if (claude) {
+        const lines = claude.split('\n').slice(0, 5).join(' ');
+        result['service-overview'] = lines.trim();
+    }
+    // startup-procedure: from package.json scripts
+    if (pkg?.scripts) {
+        const scripts = [];
+        if (pkg.scripts.start)
+            scripts.push(`npm start: ${pkg.scripts.start}`);
+        if (pkg.scripts.dev)
+            scripts.push(`npm dev: ${pkg.scripts.dev}`);
+        if (pkg.scripts['server:start'])
+            scripts.push(`npm server:start: ${pkg.scripts['server:start']}`);
+        if (scripts.length > 0) {
+            result['startup-procedure'] = scripts.join('\n\n');
+        }
+    }
+    // health-checks: look for common patterns in code
+    const hasHealthCheck = state.artifactInventory.categories.sourceCode.files.some(f => /health|liveness|readiness|ping|status/.test(f.toLowerCase()));
+    if (hasHealthCheck) {
+        result['health-checks'] = 'Service includes health check endpoints. Verify via /health or /status endpoints.';
+    }
+    // common-issues: from git patterns (fix/hotfix commits are rare, but we note this)
+    if (state.artifactInventory.gitStats.totalCommits > 10) {
+        result['common-issues'] =
+            `Based on ${state.artifactInventory.gitStats.totalCommits} commits, check git log for frequent fixes: ` +
+                `git log --oneline | grep -E "^(fix|hotfix):" | head -10`;
+    }
+    // rollback-procedure: from CI/CD config
+    if (workflow && workflow.includes('revert')) {
+        result['rollback-procedure'] = 'CI/CD pipeline includes revert capabilities. Check .github/workflows for rollback steps.';
+    }
+    else if (dockerfile || pkg?.scripts?.deploy) {
+        result['rollback-procedure'] = 'Deployment handled via Docker/scripts. Manual rollback: revert deployment, restart service.';
+    }
+    // escalation-path: from CLAUDE.md team context
+    if (claude && claude.includes('on-call')) {
+        const onCallMatch = claude.match(/on[- ]call[:\s]+([^\n]+)/i);
+        if (onCallMatch) {
+            result['escalation-path'] = onCallMatch[1];
+        }
+    }
+    return result;
+}
+/**
+ * Extract ADR sections
+ */
+function extractADR(projectPath, state) {
+    const claude = readClaudeMd(projectPath);
+    const result = {};
+    // context: from CLAUDE.md or architecture notes
+    if (claude) {
+        const contextMatch = claude.match(/^#+\s+(?:Architecture|Context|Background)([\s\S]*?)(?=^#+|$)/m);
+        if (contextMatch) {
+            result['context'] = contextMatch[1].trim().slice(0, 500);
+        }
+        else {
+            result['context'] = claude.slice(0, 300);
+        }
+    }
+    // decision: from architecture docs or CLAUDE.md
+    if (claude && claude.includes('decision')) {
+        const decisionMatch = claude.match(/(?:decision|chose|selected)[:\s]+([^\n]+)/i);
+        if (decisionMatch) {
+            result['decision'] = decisionMatch[1];
+        }
+    }
+    // consequences: from stack composition
+    const languages = state.artifactInventory.gitStats.mainLanguages;
+    if (languages.length > 0) {
+        result['consequences'] =
+            `Technology stack: ${languages.join(', ')}. ` +
+                `Positive: focused ecosystem. ` +
+                `Negative: limited polyglot flexibility.`;
+    }
+    // alternatives: from package.json dependencies (show alternatives not chosen)
+    const pkg = readPackageJson(projectPath);
+    if (pkg?.dependencies) {
+        const keys = Object.keys(pkg.dependencies).slice(0, 3);
+        result['alternatives'] =
+            `Considered alternatives before selecting current stack. ` +
+                `Current primary dependencies: ${keys.join(', ')}`;
+    }
+    return result;
+}
+/**
+ * Extract Deployment Procedure sections
+ */
+function extractDeploymentProcedure(projectPath, state) {
+    const pkg = readPackageJson(projectPath);
+    const dockerfile = readDockerfile(projectPath);
+    const workflow = readWorkflow(projectPath);
+    const result = {};
+    // prerequisites: from package.json engines and Dockerfile
+    const prereqs = [];
+    if (pkg?.engines?.node) {
+        prereqs.push(`Node.js ${pkg.engines.node}`);
+    }
+    if (pkg?.engines?.npm) {
+        prereqs.push(`npm ${pkg.engines.npm}`);
+    }
+    if (dockerfile && dockerfile.includes('FROM')) {
+        const fromMatch = dockerfile.match(/FROM\s+([^\n]+)/);
+        if (fromMatch) {
+            prereqs.push(`Docker base: ${fromMatch[1]}`);
+        }
+    }
+    if (prereqs.length > 0) {
+        result['prerequisites'] = prereqs.join('\n');
+    }
+    // build-process: from package.json scripts
+    if (pkg?.scripts) {
+        const buildScripts = [];
+        if (pkg.scripts.build)
+            buildScripts.push(`1. npm run build: ${pkg.scripts.build}`);
+        if (pkg.scripts.compile)
+            buildScripts.push(`1. npm run compile: ${pkg.scripts.compile}`);
+        if (pkg.scripts['install'])
+            buildScripts.push(`2. npm install dependencies`);
+        if (pkg.scripts.test)
+            buildScripts.push(`3. npm test: ${pkg.scripts.test}`);
+        if (buildScripts.length > 0) {
+            result['build-process'] = buildScripts.join('\n');
+        }
+    }
+    // environment-setup: from .env patterns
+    if (fs.existsSync(path.join(projectPath, '.env.example'))) {
+        result['environment-setup'] = 'See .env.example for required environment variables. Copy to .env and fill in values.';
+    }
+    else if (pkg?.scripts?.setup || pkg?.scripts?.configure) {
+        result['environment-setup'] = `Run: npm run setup (or configure script defined in package.json)`;
+    }
+    // testing-before-deploy: from test scripts
+    if (pkg?.scripts?.test || pkg?.scripts?.['test:ci']) {
+        const testCmd = pkg.scripts['test:ci'] || pkg.scripts.test;
+        result['testing-before-deploy'] = `Run: ${testCmd}`;
+    }
+    // deployment-steps: from workflow
+    if (workflow) {
+        if (workflow.includes('deploy')) {
+            result['deployment-steps'] = 'See .github/workflows for automated deployment steps. Manual: build, test, push Docker image, apply configuration.';
+        }
+    }
+    // post-deployment-checks: from health check patterns
+    if (state.artifactInventory.categories.sourceCode.files.some(f => /health|status|ping/.test(f.toLowerCase()))) {
+        result['post-deployment-checks'] = 'Verify: curl /health endpoint, check logs, monitor key metrics.';
+    }
+    // rollback-procedure: from CI/CD or package scripts
+    if (pkg?.scripts?.rollback) {
+        result['rollback-procedure'] = `Run: npm run rollback`;
+    }
+    else if (workflow && workflow.includes('revert')) {
+        result['rollback-procedure'] = 'Revert the deployment commit and redeploy previous version.';
+    }
+    return result;
+}
+/**
+ * Extract API Spec sections
+ */
+function extractAPISpec(projectPath, state) {
+    const pkg = readPackageJson(projectPath);
+    const result = {};
+    // base-url: from package.json config or common ports
+    if (pkg?.description && /api|server/i.test(pkg.description)) {
+        const port = pkg.scripts?.dev?.match(/:\d+/) ? pkg.scripts.dev.match(/:\d+/)?.[0] : ':3000';
+        result['base-url'] = `http://localhost${port}/api`;
+    }
+    else if (process.env.API_BASE_URL) {
+        result['base-url'] = process.env.API_BASE_URL;
+    }
+    // endpoints: from route file patterns
+    const hasRoutes = state.artifactInventory.categories.sourceCode.files.some(f => /routes?|controllers?|handlers?/.test(f.toLowerCase()));
+    if (hasRoutes) {
+        result['endpoints'] =
+            'API endpoints documented in routes/controllers. ' +
+                'Common patterns: GET /users, POST /users, GET /users/:id, PUT /users/:id, DELETE /users/:id';
+    }
+    // authentication: from common auth patterns
+    const hasAuth = state.artifactInventory.categories.sourceCode.files.some(f => /auth|middleware|jwt|passport/.test(f.toLowerCase()));
+    if (hasAuth) {
+        result['authentication'] =
+            'API uses token-based authentication (JWT). ' +
+                'Include Authorization header: Bearer <token>. ' +
+                'Obtain token from /auth/login endpoint.';
+    }
+    return result;
+}
+/**
+ * Extract Test Plan sections
+ */
+function extractTestPlan(projectPath, state) {
+    const pkg = readPackageJson(projectPath);
+    const result = {};
+    // test-strategy: from test framework detection
+    let testFramework = 'unknown';
+    if (pkg?.devDependencies) {
+        if (pkg.devDependencies.jest)
+            testFramework = 'Jest';
+        else if (pkg.devDependencies.vitest)
+            testFramework = 'Vitest';
+        else if (pkg.devDependencies.mocha)
+            testFramework = 'Mocha';
+        else if (pkg.devDependencies.playwright)
+            testFramework = 'Playwright (E2E)';
+    }
+    if (testFramework !== 'unknown') {
+        result['test-strategy'] =
+            `Testing framework: ${testFramework}. ` +
+                `Run: npm test. ` +
+                `Strategy: Unit tests for business logic, integration tests for APIs, E2E for critical paths.`;
+    }
+    // unit-tests: from test file patterns
+    const testFiles = state.artifactInventory.categories.tests.files.slice(0, 5);
+    if (testFiles.length > 0) {
+        result['unit-tests'] =
+            `Test files found: ${testFiles.length} files. ` +
+                `Pattern: *.test.ts or *.spec.ts. ` +
+                `Run: npm test`;
+    }
+    // coverage-targets: from package.json jest config
+    if (pkg && typeof pkg === 'object' && 'jest' in pkg) {
+        const jestConfig = pkg.jest;
+        if (jestConfig?.collectCoverageFrom) {
+            result['coverage-targets'] =
+                `Coverage target: ${jestConfig.coverageThreshold?.global?.lines || '80'}% lines. ` +
+                    `Critical paths: all API endpoints and core business logic.`;
+        }
+    }
+    else {
+        result['coverage-targets'] = 'Recommended: 80%+ line coverage for critical paths.';
+    }
+    return result;
+}
+/**
+ * Extract Data Model sections
+ */
+function extractDataModel(projectPath, state) {
+    const result = {};
+    // entity-overview: from models/schema files
+    const hasModels = state.artifactInventory.categories.sourceCode.files.some(f => /models?|schema|entities?/.test(f.toLowerCase()));
+    if (hasModels) {
+        result['entity-overview'] =
+            'Project includes data models/entities. Primary entities: User, Account, Transaction, etc. ' +
+                'See models/ or schema/ directory for definitions.';
+    }
+    // table-schemas: from migrations or schema files
+    const hasMigrations = state.artifactInventory.categories.sourceCode.files.some(f => /migrations?|sql|schema/.test(f.toLowerCase()));
+    if (hasMigrations) {
+        result['table-schemas'] =
+            'Database schema defined via migrations. ' +
+                'Check migrations/ directory for CREATE TABLE statements and schema changes.';
+    }
+    return result;
+}
+/**
+ * Extract Threat Model sections
+ */
+function extractThreatModel(projectPath, state) {
+    const claude = readClaudeMd(projectPath);
+    const result = {};
+    // asset-scope: from API and data patterns
+    const hasAPI = state.artifactInventory.categories.architecture.files.length > 0 ||
+        state.artifactInventory.categories.sourceCode.files.some(f => /routes?|controllers?|endpoints?/.test(f.toLowerCase()));
+    const hasData = state.artifactInventory.categories.sourceCode.files.some(f => /database|db|sql|model|schema/.test(f.toLowerCase()));
+    if (hasAPI || hasData) {
+        const assets = [];
+        if (hasAPI)
+            assets.push('API endpoints');
+        if (hasData)
+            assets.push('user data in database');
+        result['asset-scope'] =
+            `Critical assets: ${assets.join(', ')}. ` +
+                `Entry points: HTTP API endpoints, database connections.`;
+    }
+    // mitigations: from auth/validation patterns
+    const hasAuth = state.artifactInventory.categories.sourceCode.files.some(f => /auth|middleware|jwt|passport|validate/.test(f.toLowerCase()));
+    if (hasAuth) {
+        result['mitigations'] =
+            'Implemented: JWT authentication for API access, input validation, ' +
+                'rate limiting, HTTPS enforced. ' +
+                'Recommended: encryption at rest, audit logging, security headers.';
+    }
+    return result;
+}
+/**
+ * Main extraction function - maps doc type to specific extractor
+ */
+function extractDataForDocType(docType, state, projectPath = process.cwd()) {
+    logger_1.logger.info('Extracting data for doc type', { docType });
+    try {
+        let extracted = {};
+        switch (docType) {
+            case 'runbook':
+                extracted = extractRunbook(projectPath, state);
+                break;
+            case 'adr':
+                extracted = extractADR(projectPath, state);
+                break;
+            case 'deployment-procedure':
+                extracted = extractDeploymentProcedure(projectPath, state);
+                break;
+            case 'api-spec':
+                extracted = extractAPISpec(projectPath, state);
+                break;
+            case 'test-plan':
+                extracted = extractTestPlan(projectPath, state);
+                break;
+            case 'data-model':
+                extracted = extractDataModel(projectPath, state);
+                break;
+            case 'threat-model':
+                extracted = extractThreatModel(projectPath, state);
+                break;
+            default:
+                logger_1.logger.warn('Unknown doc type for extraction', { docType });
+                extracted = {};
+        }
+        logger_1.logger.debug('Data extraction complete', {
+            docType,
+            sectionsExtracted: Object.keys(extracted).length,
+        });
+        return extracted;
+    }
+    catch (error) {
+        logger_1.logger.error('Extraction failed', { docType, error });
+        return {};
+    }
+}

package/dist/generator/index.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Generator Orchestrator Module
+ * Orchestrates the document generation pipeline
+ */
+import { RenderData } from '../templates';
+import { VibedocState } from '../state/schema';
+/**
+ * Result of a document generation
+ */
+export interface GenerationResult {
+    paths: string[];
+    docType: string;
+    version: number;
+}
+/**
+ * Generate a document in one or more formats
+ * @param docType - Type of document (e.g., 'adr', 'runbook')
+ * @param projectPath - Root path of the project
+ * @param state - Current vibe-doc state
+ * @param renderData - Data to render into the template
+ * @param format - Format(s) to generate: 'md', 'docx', or 'both'
+ * @returns GenerationResult with paths and version number
+ */
+export declare function generateDocument(docType: string, projectPath: string, state: VibedocState, renderData: RenderData, format?: 'md' | 'docx' | 'both'): Promise<GenerationResult>;
+//# sourceMappingURL=index.d.ts.map

package/dist/generator/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/generator/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAgB,UAAU,EAAkB,MAAM,cAAc,CAAC;AAIxE,OAAO,EAAE,YAAY,EAAgB,MAAM,iBAAiB,CAAC;AAG7D;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,YAAY,EACnB,UAAU,EAAE,UAAU,EACtB,MAAM,GAAE,IAAI,GAAG,MAAM,GAAG,MAAe,GACtC,OAAO,CAAC,gBAAgB,CAAC,CA+F3B"}

package/dist/generator/index.js

@@ -0,0 +1,106 @@
+"use strict";
+/**
+ * Generator Orchestrator Module
+ * Orchestrates the document generation pipeline
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDocument = generateDocument;
+const templates_1 = require("../templates");
+const markdown_writer_1 = require("./markdown-writer");
+const docx_writer_1 = require("./docx-writer");
+const versioning_1 = require("../versioning");
+const logger_1 = require("../utils/logger");
+/**
+ * Generate a document in one or more formats
+ * @param docType - Type of document (e.g., 'adr', 'runbook')
+ * @param projectPath - Root path of the project
+ * @param state - Current vibe-doc state
+ * @param renderData - Data to render into the template
+ * @param format - Format(s) to generate: 'md', 'docx', or 'both'
+ * @returns GenerationResult with paths and version number
+ */
+async function generateDocument(docType, projectPath, state, renderData, format = 'both') {
+    logger_1.logger.info('Starting document generation', { docType, format });
+    try {
+        // Load template
+        const template = (0, templates_1.loadTemplate)(docType);
+        logger_1.logger.debug('Template loaded', { docType });
+        // Render template
+        const rendered = (0, templates_1.renderTemplate)(template, renderData);
+        logger_1.logger.debug('Template rendered', { docType, length: rendered.length });
+        // Archive current version if exists
+        const nextVersion = (0, versioning_1.getNextVersion)(state, docType);
+        const archived = (0, versioning_1.archiveCurrentVersion)(projectPath, docType, state);
+        if (archived) {
+            logger_1.logger.info('Previous version archived', { docType, version: archived.version });
+            state.history.push(archived);
+        }
+        // Prepare metadata
+        const metadata = {
+            generatedAt: new Date().toISOString(),
+            classification: renderData.metadata.classification,
+            sourceArtifacts: renderData.metadata.sourceArtifacts,
+            confidenceSummary: {
+                high: 0,
+                medium: 0,
+                low: 0,
+            },
+        };
+        // Count confidence levels from rendered output
+        // Look for confidence tags in the rendered output
+        const highMatch = rendered.match(/high/gi);
+        const mediumMatch = rendered.match(/medium/gi);
+        const lowMatch = rendered.match(/low/gi);
+        metadata.confidenceSummary.high = highMatch ? highMatch.length : 0;
+        metadata.confidenceSummary.medium = mediumMatch ? mediumMatch.length : 0;
+        metadata.confidenceSummary.low = lowMatch ? lowMatch.length : 0;
+        const paths = [];
+        // Write markdown
+        if (format === 'md' || format === 'both') {
+            const mdPath = (0, markdown_writer_1.writeMarkdown)(rendered, docType, projectPath, metadata);
+            paths.push(mdPath);
+            logger_1.logger.info('Markdown document generated', { docType, path: mdPath });
+        }
+        // Write DOCX
+        if (format === 'docx' || format === 'both') {
+            const docxPath = await (0, docx_writer_1.writeDocx)(rendered, docType, projectPath, metadata);
+            paths.push(docxPath);
+            logger_1.logger.info('DOCX document generated', { docType, path: docxPath });
+        }
+        // Update state with generated doc entry
+        const generatedDoc = {
+            docType,
+            generatedAt: new Date().toISOString(),
+            paths,
+            sourceArtifacts: renderData.metadata.sourceArtifacts.toString().split(','),
+            confidenceSections: {
+                high: metadata.confidenceSummary.high,
+                medium: metadata.confidenceSummary.medium,
+                low: metadata.confidenceSummary.low,
+            },
+            stateHash: '', // TODO: compute state hash if needed
+        };
+        // Replace or add generated doc entry
+        const existingIndex = state.generatedDocs.findIndex((doc) => doc.docType === docType);
+        if (existingIndex >= 0) {
+            state.generatedDocs[existingIndex] = generatedDoc;
+        }
+        else {
+            state.generatedDocs.push(generatedDoc);
+        }
+        logger_1.logger.info('Document generation complete', {
+            docType,
+            version: nextVersion,
+            formats: format,
+        });
+        return {
+            paths,
+            docType,
+            version: nextVersion,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error('Document generation failed', { docType, error });
+        throw error;
+    }
+}

package/dist/generator/markdown-writer.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Markdown Writer Module
+ * Writes rendered content to .md files with metadata headers
+ */
+/**
+ * Metadata for the generated document
+ */
+export interface DocMetadata {
+    generatedAt: string;
+    classification: string;
+    sourceArtifacts: number;
+    confidenceSummary: {
+        high: number;
+        medium: number;
+        low: number;
+    };
+}
+/**
+ * Write rendered content to a markdown file with metadata header
+ * @param renderedContent - The rendered markdown content
+ * @param docType - Type of document (e.g., 'adr', 'runbook')
+ * @param projectPath - Root path of the project
+ * @param metadata - Document metadata
+ * @returns Full path to the written file
+ */
+export declare function writeMarkdown(renderedContent: string, docType: string, projectPath: string, metadata: DocMetadata): string;
+//# sourceMappingURL=markdown-writer.d.ts.map

package/dist/generator/markdown-writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdown-writer.d.ts","sourceRoot":"","sources":["../../src/generator/markdown-writer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,iBAAiB,EAAE;QACjB,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,CAAC;QACf,GAAG,EAAE,MAAM,CAAC;KACb,CAAC;CACH;AAED;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAC3B,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,WAAW,GACpB,MAAM,CAyBR"}