@esthernandez/vibe-doc 0.1.0

package/dist/gap-analyzer/tier-assigner.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Tier Assigner Module
+ * Assesses gaps based on breadcrumb searches and requirement analysis
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBreadcrumbs = void 0;
+exports.assessGaps = assessGaps;
+const logger_1 = require("../utils/logger");
+/**
+ * Assess documentation gaps based on artifact inventory
+ */
+function assessGaps(requirements, inventory, breadcrumbs) {
+    const gaps = [];
+    const allArtifactText = buildArtifactSearchSpace(inventory);
+    const artifactsScanned = inventory.categories.sourceCode.count +
+        inventory.categories.documentation.count +
+        inventory.categories.configuration.count;
+    for (const req of requirements) {
+        const breadcrumb = breadcrumbs.get(req.docType);
+        if (!breadcrumb) {
+            logger_1.logger.warn('No breadcrumbs for doc type', { docType: req.docType });
+            continue;
+        }
+        const { found, missing } = searchForDocumentationEvidence(breadcrumb, inventory);
+        const gap = {
+            docType: req.docType,
+            tier: req.tier,
+            category: req.category,
+            artifactsScanned,
+            found,
+            missing,
+            rationale: buildGapRationale(req.tier, found, missing),
+        };
+        gaps.push(gap);
+    }
+    return gaps;
+}
+/**
+ * Search for evidence of a documentation type in artifacts
+ */
+function searchForDocumentationEvidence(breadcrumb, inventory) {
+    let found = 0;
+    let missing = 0;
+    // Search in documentation files
+    const docFiles = inventory.categories.documentation.files;
+    const docMatches = docFiles.filter((f) => breadcrumb.keywords.some((kw) => f.toLowerCase().includes(kw))).length;
+    // Search in source code files
+    const sourceFiles = inventory.categories.sourceCode.files;
+    const codeMatches = sourceFiles.filter((f) => breadcrumb.filePatterns.some((pattern) => matchPattern(f, pattern))).length;
+    // Search in config files
+    const configFiles = inventory.categories.configuration.files;
+    const configMatches = configFiles.filter((f) => breadcrumb.filePatterns.some((pattern) => matchPattern(f, pattern))).length;
+    // Calculate total found vs missing
+    found = docMatches + codeMatches + configMatches;
+    const expectedSections = breadcrumb.requiredSections.length;
+    missing = Math.max(0, expectedSections - found);
+    logger_1.logger.debug('Documentation evidence search', {
+        docType: breadcrumb.docType,
+        found,
+        missing,
+        docMatches,
+        codeMatches,
+        configMatches,
+    });
+    return { found, missing };
+}
+/**
+ * Simple glob pattern matcher
+ */
+function matchPattern(filePath, pattern) {
+    const regex = patternToRegex(pattern);
+    return regex.test(filePath.toLowerCase());
+}
+/**
+ * Convert glob pattern to regex
+ */
+function patternToRegex(pattern) {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+    const globRegex = escaped
+        .replace(/\*\*/g, '.*')
+        .replace(/\*/g, '[^/]*')
+        .replace(/\?/g, '.');
+    return new RegExp(`^${globRegex}$`, 'i');
+}
+/**
+ * Build a rationale for the gap
+ */
+function buildGapRationale(tier, found, missing) {
+    const tierLabel = tier.charAt(0).toUpperCase() + tier.slice(1);
+    if (found === 0) {
+        return `${tierLabel}: No evidence found in codebase.`;
+    }
+    if (missing === 0) {
+        return `${tierLabel}: All expected sections found.`;
+    }
+    const missingPercent = Math.round((missing / (found + missing)) * 100);
+    return `${tierLabel}: Found ${found} sections, missing ${missing} (${missingPercent}% incomplete).`;
+}
+/**
+ * Build a searchable text space from all artifacts
+ */
+function buildArtifactSearchSpace(inventory) {
+    const allFiles = [
+        ...inventory.categories.sourceCode.files,
+        ...inventory.categories.documentation.files,
+        ...inventory.categories.configuration.files,
+    ];
+    return allFiles.join('\n').toLowerCase();
+}
+var breadcrumbs_1 = require("./breadcrumbs");
+Object.defineProperty(exports, "getBreadcrumbs", { enumerable: true, get: function () { return breadcrumbs_1.getBreadcrumbs; } });

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

@@ -0,0 +1,15 @@
+/**
+ * DOCX Writer Module
+ * Converts rendered markdown content into professional .docx files
+ */
+import { DocMetadata } from './markdown-writer';
+/**
+ * Write rendered markdown content to a .docx file
+ * @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 Promise resolving to the full path of the written file
+ */
+export declare function writeDocx(renderedContent: string, docType: string, projectPath: string, metadata: DocMetadata): Promise<string>;
+//# sourceMappingURL=docx-writer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"docx-writer.d.ts","sourceRoot":"","sources":["../../src/generator/docx-writer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAoBH,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAOhD;;;;;;;GAOG;AACH,wBAAsB,SAAS,CAC7B,eAAe,EAAE,MAAM,EACvB,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,WAAW,GACpB,OAAO,CAAC,MAAM,CAAC,CA0CjB"}

package/dist/generator/docx-writer.js

@@ -0,0 +1,271 @@
+"use strict";
+/**
+ * DOCX Writer Module
+ * Converts rendered markdown content into professional .docx files
+ */
+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.writeDocx = writeDocx;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const docx_1 = require("docx");
+const logger_1 = require("../utils/logger");
+// Color scheme
+const NAVY = '1B2A4A';
+const STEEL = '3D5A80';
+const MEDIUM_GRAY = '666666';
+/**
+ * Write rendered markdown content to a .docx file
+ * @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 Promise resolving to the full path of the written file
+ */
+async function writeDocx(renderedContent, docType, projectPath, metadata) {
+    // Create docs/generated directory
+    const docsDir = path.join(projectPath, 'docs', 'generated');
+    if (!fs.existsSync(docsDir)) {
+        fs.mkdirSync(docsDir, { recursive: true });
+        logger_1.logger.debug('Created docs/generated directory', { path: docsDir });
+    }
+    // Parse markdown and convert to docx elements
+    const sections = parseMarkdownContent(renderedContent, docType, metadata);
+    // Create document
+    const doc = new docx_1.Document({
+        sections: [
+            {
+                children: sections,
+                footers: {
+                    default: new docx_1.Footer({
+                        children: [
+                            new docx_1.Paragraph({
+                                alignment: docx_1.AlignmentType.CENTER,
+                                children: [new docx_1.TextRun({ children: [docx_1.PageNumber.CURRENT] })],
+                            }),
+                        ],
+                    }),
+                },
+            },
+        ],
+    });
+    // Write to file
+    const buffer = await docx_1.Packer.toBuffer(doc);
+    const outputPath = path.join(docsDir, `${docType}.docx`);
+    fs.writeFileSync(outputPath, buffer);
+    logger_1.logger.info('DOCX written', {
+        docType,
+        path: outputPath,
+        size: buffer.length,
+    });
+    return outputPath;
+}
+/**
+ * Parse markdown content and convert to docx Paragraph and Table objects
+ */
+function parseMarkdownContent(content, docType, metadata) {
+    const sections = [];
+    const lines = content.split('\n');
+    let isFirstH1 = true;
+    // Add metadata header as paragraphs
+    sections.push(new docx_1.Paragraph({
+        text: `Generated by Vibe Doc v0.1.0`,
+        spacing: { line: 240, lineRule: 'auto' },
+    }));
+    sections.push(new docx_1.Paragraph({
+        text: `Date: ${metadata.generatedAt}`,
+    }));
+    sections.push(new docx_1.Paragraph({
+        text: `Classification: ${metadata.classification}`,
+    }));
+    sections.push(new docx_1.Paragraph({
+        text: `Source artifacts: ${metadata.sourceArtifacts} files scanned`,
+    }));
+    sections.push(new docx_1.Paragraph({
+        text: `Confidence: ${metadata.confidenceSummary.high} high, ${metadata.confidenceSummary.medium} medium, ${metadata.confidenceSummary.low} low sections`,
+        spacing: { after: 400 },
+    }));
+    // Parse markdown lines
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        const trimmed = line.trim();
+        // Skip empty lines
+        if (!trimmed) {
+            i++;
+            continue;
+        }
+        // Heading 1
+        if (trimmed.startsWith('# ')) {
+            const text = trimmed.slice(2).trim();
+            const h1Paragraph = new docx_1.Paragraph({
+                children: [
+                    new docx_1.TextRun({
+                        text,
+                        bold: true,
+                        size: 32, // 16pt (in twips)
+                        color: NAVY,
+                    }),
+                ],
+                spacing: { before: isFirstH1 ? 240 : 0, after: 120 },
+                pageBreakBefore: !isFirstH1,
+            });
+            sections.push(h1Paragraph);
+            isFirstH1 = false;
+            i++;
+            continue;
+        }
+        // Heading 2
+        if (trimmed.startsWith('## ')) {
+            const text = trimmed.slice(3).trim();
+            sections.push(new docx_1.Paragraph({
+                children: [
+                    new docx_1.TextRun({
+                        text,
+                        bold: true,
+                        size: 28, // 14pt (in twips)
+                        color: STEEL,
+                    }),
+                ],
+                spacing: { before: 200, after: 100 },
+            }));
+            i++;
+            continue;
+        }
+        // Heading 3
+        if (trimmed.startsWith('### ')) {
+            const text = trimmed.slice(4).trim();
+            sections.push(new docx_1.Paragraph({
+                children: [
+                    new docx_1.TextRun({
+                        text,
+                        bold: true,
+                        size: 24, // 12pt (in twips)
+                        color: MEDIUM_GRAY,
+                    }),
+                ],
+                spacing: { before: 160, after: 80 },
+            }));
+            i++;
+            continue;
+        }
+        // Bullet list
+        if (trimmed.startsWith('- ')) {
+            const bulletItems = [];
+            while (i < lines.length && lines[i].trim().startsWith('- ')) {
+                bulletItems.push(lines[i].trim().slice(2).trim());
+                i++;
+            }
+            sections.push(...bulletItems.map((item) => new docx_1.Paragraph({
+                text: item,
+                bullet: {
+                    level: 0,
+                },
+                spacing: { line: 240 },
+            })));
+            continue;
+        }
+        // Code block (triple backticks)
+        if (trimmed.startsWith('```')) {
+            i++; // Skip opening backticks
+            const codeLines = [];
+            while (i < lines.length && !lines[i].trim().startsWith('```')) {
+                codeLines.push(lines[i]);
+                i++;
+            }
+            i++; // Skip closing backticks
+            sections.push(new docx_1.Paragraph({
+                text: codeLines.join('\n'),
+                spacing: { before: 120, after: 120 },
+                border: {
+                    top: { color: 'CCCCCC', space: 1, style: docx_1.BorderStyle.SINGLE, size: 6 },
+                    bottom: { color: 'CCCCCC', space: 1, style: docx_1.BorderStyle.SINGLE, size: 6 },
+                    left: { color: 'CCCCCC', space: 1, style: docx_1.BorderStyle.SINGLE, size: 6 },
+                    right: { color: 'CCCCCC', space: 1, style: docx_1.BorderStyle.SINGLE, size: 6 },
+                },
+            }));
+            continue;
+        }
+        // Table (simple pipe-separated)
+        if (trimmed.startsWith('|')) {
+            const tableLines = [];
+            while (i < lines.length && lines[i].trim().startsWith('|')) {
+                tableLines.push(lines[i].trim());
+                i++;
+            }
+            if (tableLines.length > 0) {
+                const table = parseMarkdownTable(tableLines);
+                sections.push(table);
+            }
+            continue;
+        }
+        // Regular paragraph
+        if (trimmed) {
+            sections.push(new docx_1.Paragraph({
+                text: trimmed,
+                spacing: { line: 240, after: 80 },
+            }));
+            i++;
+            continue;
+        }
+        i++;
+    }
+    return sections;
+}
+/**
+ * Parse a markdown table and convert to docx Table
+ */
+function parseMarkdownTable(tableLines) {
+    const rows = [];
+    for (const line of tableLines) {
+        const cells = line
+            .split('|')
+            .map((cell) => cell.trim())
+            .filter((cell) => cell.length > 0);
+        rows.push(new docx_1.TableRow({
+            children: cells.map((cellText) => new docx_1.TableCell({
+                children: [
+                    new docx_1.Paragraph({
+                        text: cellText,
+                    }),
+                ],
+            })),
+        }));
+    }
+    return new docx_1.Table({
+        rows,
+        width: { size: 100, type: docx_1.WidthType.PERCENTAGE },
+    });
+}

package/dist/generator/extractor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Artifact Data Extractor
+ * Maps scan inventory data to template section tokens
+ * Extracts rich context from project artifacts to pre-populate templates
+ */
+import { VibedocState } from '../state/schema';
+/**
+ * Main extraction function - maps doc type to specific extractor
+ */
+export declare function extractDataForDocType(docType: string, state: VibedocState, projectPath?: string): Record<string, string>;
+//# sourceMappingURL=extractor.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extractor.d.ts","sourceRoot":"","sources":["../../src/generator/extractor.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAib/C;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,YAAY,EACnB,WAAW,GAAE,MAAsB,GAClC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA2CxB"}