skrypt-ai 0.5.0 → 0.6.0

package/dist/qa/fixes.js

@@ -0,0 +1,277 @@
+import { basename } from 'path';
+/**
+ * Convert kebab-case or snake_case filename to Title Case
+ */
+function filenameToTitle(filename) {
+    const name = filename.replace(/\.(mdx?|md)$/, '');
+    return name
+        .split(/[-_]/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/**
+ * Extract the first h1 heading from content
+ */
+function extractFirstH1(content) {
+    const lines = content.split('\n');
+    let inCodeBlock = false;
+    for (const line of lines) {
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            continue;
+        }
+        if (inCodeBlock)
+            continue;
+        const match = line.match(/^#\s+(.+)/);
+        if (match)
+            return match[1].trim();
+    }
+    return null;
+}
+/**
+ * Fix frontmatter issues:
+ * - Add frontmatter with title if none exists
+ * - Add title field if frontmatter exists but has no title
+ */
+export function fixFrontmatter(content, filePath) {
+    const fixes = [];
+    let result = content;
+    const fmMatch = result.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!fmMatch) {
+        // No frontmatter — add it with a title
+        const h1 = extractFirstH1(content);
+        const title = h1 || filenameToTitle(basename(filePath));
+        result = `---\ntitle: "${title}"\n---\n\n${result}`;
+        fixes.push(`added missing frontmatter with title "${title}"`);
+    }
+    else {
+        const fm = fmMatch[1];
+        if (!/^title\s*:/m.test(fm)) {
+            // Frontmatter exists but no title
+            const h1 = extractFirstH1(content);
+            const title = h1 || filenameToTitle(basename(filePath));
+            // Insert title as first field in frontmatter
+            result = result.replace(/^---\s*\n/, `---\ntitle: "${title}"\n`);
+            fixes.push(`added missing title "${title}" to frontmatter`);
+        }
+    }
+    return { content: result, fixes };
+}
+/**
+ * Fix MDX syntax issues:
+ * - Strip Docusaurus @theme imports
+ * - Strip empty <a id="..."></a> anchor tags
+ */
+export function fixMdxSyntax(content) {
+    const fixes = [];
+    const lines = content.split('\n');
+    const outputLines = [];
+    let inCodeBlock = false;
+    let strippedImports = 0;
+    let strippedAnchors = 0;
+    for (const line of lines) {
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            outputLines.push(line);
+            continue;
+        }
+        if (inCodeBlock) {
+            outputLines.push(line);
+            continue;
+        }
+        // Strip @theme imports
+        if (/^import\s+.*from\s+['"]@theme\//.test(line)) {
+            strippedImports++;
+            continue;
+        }
+        // Strip empty anchor tags: <a id="..."></a> or <a name="..."></a>
+        const anchorStripped = line.replace(/<a\s+(?:id|name)\s*=\s*["'][^"']*["']\s*>\s*<\/a>/g, '');
+        if (anchorStripped !== line) {
+            strippedAnchors++;
+            // Only keep the line if it has content after stripping
+            if (anchorStripped.trim()) {
+                outputLines.push(anchorStripped);
+            }
+            continue;
+        }
+        outputLines.push(line);
+    }
+    if (strippedImports > 0) {
+        fixes.push(`stripped ${strippedImports} @theme import${strippedImports > 1 ? 's' : ''}`);
+    }
+    if (strippedAnchors > 0) {
+        fixes.push(`stripped ${strippedAnchors} empty anchor tag${strippedAnchors > 1 ? 's' : ''}`);
+    }
+    return { content: outputLines.join('\n'), fixes };
+}
+/**
+ * Infer language for a code block based on content heuristics.
+ * More specific languages are checked first to avoid false positives
+ * (e.g., Rust's `let mut` matching TypeScript's `let`).
+ */
+function inferLanguage(code) {
+    // Rust indicators (check before TS — `let mut` and `fn` are more specific)
+    if (/\bfn\s+/.test(code) || /\blet\s+mut\b/.test(code) || /\buse\s+\w+::/.test(code)) {
+        return 'rust';
+    }
+    // Go indicators (check before TS — `func` and `package` are unambiguous)
+    if (/\bfunc\s+/.test(code) || /\bpackage\s+/.test(code)) {
+        return 'go';
+    }
+    // Python indicators (`def ` and `class...:` are unambiguous)
+    if (/\bdef\s+\w/.test(code) || /\bclass\s+\w[^{]*:\s*$/m.test(code)) {
+        return 'python';
+    }
+    // TypeScript / JavaScript indicators
+    if (/\b(const|let|import|export|interface|type)\b/.test(code) || /=>/.test(code)) {
+        return 'typescript';
+    }
+    // Bash / shell indicators
+    if (/\$\s/.test(code) || /\b(npm|brew|apt|cd|mkdir|echo|curl|wget)\b/.test(code)) {
+        return 'bash';
+    }
+    // Python import (checked after TS since `import` is ambiguous)
+    if (/^\s*import\s+\w/m.test(code) || /^\s*from\s+\w+\s+import\b/m.test(code)) {
+        return 'python';
+    }
+    return 'text';
+}
+/**
+ * Fix code block issues:
+ * - Infer language for code blocks missing a language specifier
+ * - Close unclosed code blocks at end of file
+ */
+export function fixCodeBlocks(content) {
+    const fixes = [];
+    const lines = content.split('\n');
+    const outputLines = [];
+    let inCodeBlock = false;
+    let inferredCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith('```') && !inCodeBlock) {
+            // Opening code fence
+            inCodeBlock = true;
+            const lang = line.slice(3).trim().split(/\s/)[0] || '';
+            if (!lang) {
+                // Collect lines until closing fence to infer language
+                const codeBlockContent = [];
+                let j = i + 1;
+                while (j < lines.length && !lines[j].startsWith('```')) {
+                    codeBlockContent.push(lines[j]);
+                    j++;
+                }
+                const inferred = inferLanguage(codeBlockContent.join('\n'));
+                outputLines.push('```' + inferred);
+                inferredCount++;
+            }
+            else {
+                outputLines.push(line);
+            }
+        }
+        else if (line.startsWith('```') && inCodeBlock) {
+            // Closing code fence
+            inCodeBlock = false;
+            outputLines.push(line);
+        }
+        else {
+            outputLines.push(line);
+        }
+    }
+    // Close unclosed code block at end of file
+    if (inCodeBlock) {
+        outputLines.push('```');
+        fixes.push('closed unclosed code block at end of file');
+    }
+    if (inferredCount > 0) {
+        fixes.push(`inferred language for ${inferredCount} code block${inferredCount > 1 ? 's' : ''}`);
+    }
+    return { content: outputLines.join('\n'), fixes };
+}
+/**
+ * Fix security issues:
+ * - Strip <script>...</script> tags (outside code blocks)
+ * - Replace javascript: URLs with #
+ * - Strip inline on* event handlers from HTML tags
+ * - Add sandbox attribute to unsandboxed <iframe> tags
+ */
+export function fixSecurity(content) {
+    const fixes = [];
+    const lines = content.split('\n');
+    const outputLines = [];
+    let inCodeBlock = false;
+    let strippedScripts = 0;
+    let fixedUrls = 0;
+    let strippedHandlers = 0;
+    let sandboxedIframes = 0;
+    let inScriptTag = false;
+    for (const line of lines) {
+        if (line.startsWith('```')) {
+            inCodeBlock = !inCodeBlock;
+            outputLines.push(line);
+            continue;
+        }
+        if (inCodeBlock) {
+            outputLines.push(line);
+            continue;
+        }
+        // Handle multi-line script tags
+        if (inScriptTag) {
+            if (/<\/script>/i.test(line)) {
+                inScriptTag = false;
+                strippedScripts++;
+            }
+            // Skip lines inside script tags
+            continue;
+        }
+        // Single-line script tag: <script>...</script>
+        if (/<script[\s>][\s\S]*<\/script>/i.test(line)) {
+            const cleaned = line.replace(/<script[\s>][\s\S]*?<\/script>/gi, '');
+            strippedScripts++;
+            if (cleaned.trim()) {
+                outputLines.push(cleaned);
+            }
+            continue;
+        }
+        // Opening script tag without closing on same line
+        if (/<script[\s>]/i.test(line)) {
+            inScriptTag = true;
+            // Keep any content before the script tag
+            const before = line.replace(/<script[\s>][\s\S]*/i, '').trim();
+            if (before) {
+                outputLines.push(before);
+            }
+            continue;
+        }
+        let processed = line;
+        // Replace javascript: URLs with #
+        if (/href\s*=\s*["']javascript:/i.test(processed)) {
+            processed = processed.replace(/href\s*=\s*["']javascript:[^"']*["']/gi, 'href="#"');
+            fixedUrls++;
+        }
+        // Strip inline on* event handlers
+        if (/\s+on\w+\s*=\s*["']/i.test(processed)) {
+            processed = processed.replace(/\s+on\w+\s*=\s*["'][^"']*["']/gi, '');
+            strippedHandlers++;
+        }
+        // Add sandbox to unsandboxed iframes
+        if (/<iframe\s/i.test(processed) && !/sandbox/i.test(processed)) {
+            processed = processed.replace(/<iframe\s/i, '<iframe sandbox ');
+            sandboxedIframes++;
+        }
+        outputLines.push(processed);
+    }
+    if (strippedScripts > 0) {
+        fixes.push(`stripped ${strippedScripts} <script> tag${strippedScripts > 1 ? 's' : ''}`);
+    }
+    if (fixedUrls > 0) {
+        fixes.push(`replaced ${fixedUrls} javascript: URL${fixedUrls > 1 ? 's' : ''}`);
+    }
+    if (strippedHandlers > 0) {
+        fixes.push(`stripped ${strippedHandlers} inline event handler${strippedHandlers > 1 ? 's' : ''}`);
+    }
+    if (sandboxedIframes > 0) {
+        fixes.push(`sandboxed ${sandboxedIframes} <iframe>${sandboxedIframes > 1 ? 's' : ''}`);
+    }
+    return { content: outputLines.join('\n'), fixes };
+}

package/dist/qa/index.d.ts

@@ -0,0 +1,29 @@
+import type { QAReport } from './types.js';
+export type { QAReport, QACheckResult, QAIssue } from './types.js';
+export type { Severity } from './types.js';
+/**
+ * Run embedded QA on a docs output directory.
+ * Returns a report with all issues found.
+ */
+export declare function runQA(outputDir: string): QAReport;
+/**
+ * Print QA report to stdout
+ */
+export declare function printQAReport(report: QAReport): void;
+export interface FixReport {
+    filesFixed: number;
+    totalFixes: number;
+    fixes: Array<{
+        file: string;
+        fixes: string[];
+    }>;
+}
+/**
+ * Auto-fix safe QA issues in a docs output directory.
+ * Runs conservative fix functions on all .md/.mdx files and writes changes back.
+ */
+export declare function fixQAIssues(outputDir: string): FixReport;
+/**
+ * Print fix report to stdout
+ */
+export declare function printFixReport(report: FixReport): void;

package/dist/qa/index.js

@@ -0,0 +1,187 @@
+import { readdirSync, readFileSync, writeFileSync } from 'fs';
+import { join, relative } from 'path';
+import { checkFrontmatter, checkHeadings, checkCodeBlocks, checkComponents, checkLinks, checkSecurity, checkContentQuality, checkMdxSyntax, checkScreenshots, } from './checks.js';
+import { fixFrontmatter, fixMdxSyntax, fixCodeBlocks, fixSecurity, } from './fixes.js';
+/**
+ * Recursively find all .md and .mdx files in a directory
+ */
+function findDocFiles(dir, maxDepth = 20) {
+    const files = [];
+    function walk(currentDir, depth) {
+        if (depth > maxDepth)
+            return;
+        try {
+            const entries = readdirSync(currentDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.name.startsWith('.') || entry.name === 'node_modules')
+                    continue;
+                const fullPath = join(currentDir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(fullPath, depth + 1);
+                }
+                else if (entry.name.endsWith('.md') || entry.name.endsWith('.mdx')) {
+                    // Skip metadata files
+                    const name = entry.name.replace(/\.(mdx?|md)$/, '');
+                    if (name.startsWith('_') || name.startsWith('llms') || name === 'README')
+                        continue;
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Directory not accessible
+        }
+    }
+    walk(dir, 0);
+    return files;
+}
+/**
+ * Run a single check across all files and return results
+ */
+function runCheck(name, files, checkFn) {
+    const start = Date.now();
+    const issues = [];
+    const allFilePaths = new Set(files.map(f => f.relPath));
+    for (const file of files) {
+        try {
+            const fileIssues = checkFn(file.content, file.relPath, allFilePaths);
+            issues.push(...fileIssues);
+        }
+        catch {
+            // Check failed for this file — skip
+        }
+    }
+    return {
+        check: name,
+        passed: issues.filter(i => i.severity === 'error').length === 0,
+        issues,
+        duration: Date.now() - start,
+    };
+}
+/**
+ * Run embedded QA on a docs output directory.
+ * Returns a report with all issues found.
+ */
+export function runQA(outputDir) {
+    const startTime = Date.now();
+    // Find all doc files
+    const filePaths = findDocFiles(outputDir);
+    // Read all files
+    const files = filePaths.map(p => ({
+        path: p,
+        content: readFileSync(p, 'utf-8'),
+        relPath: relative(outputDir, p),
+    }));
+    // Run all checks
+    const checks = [
+        runCheck('frontmatter', files, (content, relPath) => checkFrontmatter('', content, relPath)),
+        runCheck('headings', files, (content, relPath) => checkHeadings(content, relPath)),
+        runCheck('code-blocks', files, (content, relPath) => checkCodeBlocks(content, relPath)),
+        runCheck('components', files, (content, relPath) => checkComponents(content, relPath)),
+        runCheck('links', files, (content, relPath, allFiles) => checkLinks(content, relPath, allFiles)),
+        runCheck('security', files, (content, relPath) => checkSecurity(content, relPath)),
+        runCheck('content', files, (content, relPath) => checkContentQuality(content, relPath)),
+        runCheck('mdx-syntax', files, (content, relPath) => checkMdxSyntax(content, relPath)),
+        runCheck('screenshots', files, (content, relPath) => checkScreenshots(content, relPath, outputDir)),
+    ];
+    // Aggregate
+    const allIssues = checks.flatMap(c => c.issues);
+    const errors = allIssues.filter(i => i.severity === 'error').length;
+    const warnings = allIssues.filter(i => i.severity === 'warning').length;
+    const infos = allIssues.filter(i => i.severity === 'info').length;
+    return {
+        outputDir,
+        filesChecked: files.length,
+        checks,
+        errors,
+        warnings,
+        infos,
+        passed: errors === 0,
+        duration: Date.now() - startTime,
+    };
+}
+/**
+ * Print QA report to stdout
+ */
+export function printQAReport(report) {
+    const statusIcon = report.passed ? '✓' : '✗';
+    const statusLabel = report.passed ? 'PASSED' : 'FAILED';
+    console.log(`\n  QA ${statusIcon} ${statusLabel}`);
+    console.log(`  ${report.filesChecked} files checked in ${report.duration}ms`);
+    // Summary line
+    const parts = [];
+    if (report.errors > 0)
+        parts.push(`${report.errors} error${report.errors > 1 ? 's' : ''}`);
+    if (report.warnings > 0)
+        parts.push(`${report.warnings} warning${report.warnings > 1 ? 's' : ''}`);
+    if (report.infos > 0)
+        parts.push(`${report.infos} info${report.infos > 1 ? 's' : ''}`);
+    if (parts.length > 0) {
+        console.log(`  ${parts.join(', ')}`);
+    }
+    // Show errors and warnings (not infos unless verbose)
+    const significant = report.checks
+        .flatMap(c => c.issues)
+        .filter(i => i.severity === 'error' || i.severity === 'warning');
+    if (significant.length > 0) {
+        console.log('');
+        const shown = significant.slice(0, 20);
+        for (const issue of shown) {
+            const icon = issue.severity === 'error' ? '✗' : '⚠';
+            const loc = issue.line ? `${issue.file}:${issue.line}` : issue.file;
+            console.log(`  ${icon} [${issue.check}] ${loc}: ${issue.message}`);
+        }
+        if (significant.length > 20) {
+            console.log(`  ... and ${significant.length - 20} more`);
+        }
+    }
+}
+/**
+ * Auto-fix safe QA issues in a docs output directory.
+ * Runs conservative fix functions on all .md/.mdx files and writes changes back.
+ */
+export function fixQAIssues(outputDir) {
+    const filePaths = findDocFiles(outputDir);
+    const result = { filesFixed: 0, totalFixes: 0, fixes: [] };
+    for (const filePath of filePaths) {
+        const original = readFileSync(filePath, 'utf-8');
+        const relPath = relative(outputDir, filePath);
+        let content = original;
+        const allFixes = [];
+        // Run each fix function in sequence
+        const frontmatterResult = fixFrontmatter(content, filePath);
+        content = frontmatterResult.content;
+        allFixes.push(...frontmatterResult.fixes);
+        const mdxResult = fixMdxSyntax(content);
+        content = mdxResult.content;
+        allFixes.push(...mdxResult.fixes);
+        const codeResult = fixCodeBlocks(content);
+        content = codeResult.content;
+        allFixes.push(...codeResult.fixes);
+        const securityResult = fixSecurity(content);
+        content = securityResult.content;
+        allFixes.push(...securityResult.fixes);
+        // Only write if content actually changed
+        if (content !== original) {
+            writeFileSync(filePath, content, 'utf-8');
+            result.filesFixed++;
+            result.totalFixes += allFixes.length;
+            result.fixes.push({ file: relPath, fixes: allFixes });
+        }
+    }
+    return result;
+}
+/**
+ * Print fix report to stdout
+ */
+export function printFixReport(report) {
+    if (report.totalFixes === 0) {
+        return;
+    }
+    console.log(`  Auto-fixed ${report.totalFixes} issue${report.totalFixes > 1 ? 's' : ''} in ${report.filesFixed} file${report.filesFixed > 1 ? 's' : ''}`);
+    for (const entry of report.fixes) {
+        for (const fix of entry.fixes) {
+            console.log(`    \u2713 ${entry.file}: ${fix}`);
+        }
+    }
+}

package/dist/qa/types.d.ts

@@ -0,0 +1,24 @@
+export type Severity = 'error' | 'warning' | 'info';
+export interface QAIssue {
+    file: string;
+    line?: number;
+    severity: Severity;
+    check: string;
+    message: string;
+}
+export interface QACheckResult {
+    check: string;
+    passed: boolean;
+    issues: QAIssue[];
+    duration: number;
+}
+export interface QAReport {
+    outputDir: string;
+    filesChecked: number;
+    checks: QACheckResult[];
+    errors: number;
+    warnings: number;
+    infos: number;
+    passed: boolean;
+    duration: number;
+}

package/dist/qa/types.js

@@ -0,0 +1 @@
+export {};

package/dist/scanner/csharp.d.ts

@@ -0,0 +1,23 @@
+import { Scanner, ScanResult } from './types.js';
+/**
+ * Scanner for C# source files
+ * Extracts: public classes, interfaces, enums, structs, records, methods
+ */
+export declare class CSharpScanner implements Scanner {
+    languages: string[];
+    canHandle(filePath: string): boolean;
+    scanFile(filePath: string): Promise<ScanResult>;
+    private extractImports;
+    private extractTypes;
+    private extractMethods;
+    private extractInterfaceMethods;
+    private findClassRanges;
+    private findMatchingBrace;
+    private findParentClass;
+    private parseCSharpParams;
+    private splitParams;
+    private getLineNumber;
+    private getDocComment;
+    private extractGenerics;
+    private getSourceContext;
+}