skrypt-ai 0.8.0 → 0.8.1

package/dist/mutation/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * A single mutation applied to source code
+ */
+export interface Mutant {
+    id: string;
+    filePath: string;
+    originalCode: string;
+    mutatedCode: string;
+    startLine: number;
+    endLine: number;
+    type: 'return_value' | 'string_literal' | 'conditional' | 'logical_operator' | 'body_removal';
+    description: string;
+}
+/**
+ * Result of testing a single mutant
+ */
+export interface MutantResult {
+    mutant: Mutant;
+    status: 'killed' | 'survived' | 'error' | 'timeout';
+    failedExample?: string;
+    error?: string;
+}
+/**
+ * Full mutation testing report
+ */
+export interface MutationReport {
+    totalMutants: number;
+    killed: number;
+    survived: number;
+    errors: number;
+    timeouts: number;
+    mutationScore: number;
+    files: Array<{
+        filePath: string;
+        mutants: number;
+        killed: number;
+        survived: number;
+        score: number;
+    }>;
+    survivors: MutantResult[];
+}
+/**
+ * Options for mutation testing
+ */
+export interface MutationOptions {
+    files?: string[];
+    maxMutants?: number;
+    json?: boolean;
+    minScore?: number;
+    timeout?: number;
+}

package/dist/mutation/types.js

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

package/dist/qa/checks.d.ts

@@ -8,3 +8,4 @@ export declare function checkSecurity(content: string, relPath: string): QAIssue
 export declare function checkContentQuality(content: string, relPath: string): QAIssue[];
 export declare function checkScreenshots(content: string, relPath: string, outputDir: string): QAIssue[];
 export declare function checkMdxSyntax(content: string, relPath: string): QAIssue[];
+export declare function checkCodeBlockBraces(content: string, relPath: string): QAIssue[];

package/dist/qa/checks.js

@@ -490,3 +490,50 @@ export function checkMdxSyntax(content, relPath) {
     }
     return issues;
 }
+// ── Check: Unescaped curly braces inside fenced code blocks (.md files only) ──
+// When .md files are compiled as MDX (format: 'mdx'), curly braces inside code
+// blocks are interpreted as JSX expressions, causing "Could not parse expression
+// with acorn" errors. The template uses format: 'md' for .md files to avoid this,
+// but this check serves as a defensive warning layer.
+export function checkCodeBlockBraces(content, relPath) {
+    // Only check .md files — .mdx files intentionally use JSX expressions
+    if (relPath.endsWith('.mdx'))
+        return [];
+    const issues = [];
+    const lines = content.split('\n');
+    let inCodeBlock = false;
+    let codeBlockStart = 0;
+    let braceCount = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.startsWith('```')) {
+            if (!inCodeBlock) {
+                inCodeBlock = true;
+                codeBlockStart = i + 1;
+                braceCount = 0;
+            }
+            else {
+                // Closing fence — report if braces were found
+                if (braceCount > 0) {
+                    issues.push({
+                        file: relPath,
+                        line: codeBlockStart,
+                        severity: 'info',
+                        check: 'mdx-syntax',
+                        message: `Code block contains ${braceCount} unescaped curly brace${braceCount > 1 ? 's' : ''} — may break MDX compilation if format is not set to "md"`,
+                    });
+                }
+                inCodeBlock = false;
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            // Count curly braces in code block lines
+            for (const ch of line) {
+                if (ch === '{' || ch === '}')
+                    braceCount++;
+            }
+        }
+    }
+    return issues;
+}

package/dist/qa/index.js

@@ -1,6 +1,6 @@
 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 { checkFrontmatter, checkHeadings, checkCodeBlocks, checkComponents, checkLinks, checkSecurity, checkContentQuality, checkMdxSyntax, checkCodeBlockBraces, checkScreenshots, } from './checks.js';
 import { fixFrontmatter, fixMdxSyntax, fixCodeBlocks, fixSecurity, } from './fixes.js';
 /**
  * Recursively find all .md and .mdx files in a directory
@@ -82,6 +82,7 @@ export function runQA(outputDir) {
         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('mdx-code-braces', files, (content, relPath) => checkCodeBlockBraces(content, relPath)),
         runCheck('screenshots', files, (content, relPath) => checkScreenshots(content, relPath, outputDir)),
     ];
     // Aggregate

package/dist/scanner/index.js

@@ -1,4 +1,5 @@
 import { readdir, stat } from 'fs/promises';
+import { statSync } from 'fs';
 import { join, parse as parsePath } from 'path';
 import { PythonScanner } from './python.js';
 import { TypeScriptScanner } from './typescript.js';
@@ -52,13 +53,23 @@ function globToRegex(pattern) {
     re = re.replace(/\0GLOBSTAR\0/g, '.*');
     return new RegExp(`(^|/)${re}($|/)`);
 }
+/** Cache compiled glob RegExp patterns so they're created once per pattern, not once per file. */
+const globRegexCache = new Map();
+function getCachedGlobRegex(pattern) {
+    let regex = globRegexCache.get(pattern);
+    if (!regex) {
+        regex = globToRegex(pattern);
+        globRegexCache.set(pattern, regex);
+    }
+    return regex;
+}
 /**
  * Check if a path should be excluded based on patterns
  */
 function shouldExclude(filePath, excludePatterns) {
     const normalized = filePath.replace(/\\/g, '/');
     for (const pattern of excludePatterns) {
-        if (globToRegex(pattern).test(normalized))
+        if (getCachedGlobRegex(pattern).test(normalized))
             return true;
     }
     return false;
@@ -71,13 +82,16 @@ function shouldInclude(filePath, includePatterns) {
         return true;
     const normalized = filePath.replace(/\\/g, '/');
     for (const pattern of includePatterns) {
-        if (globToRegex(pattern).test(normalized))
+        if (getCachedGlobRegex(pattern).test(normalized))
             return true;
     }
     return false;
 }
 const MAX_SCAN_DEPTH = 30;
 const MAX_SCAN_FILES = 10000;
+/** Skip files larger than 1 MB to avoid memory bloat and slow parsing */
+const MAX_FILE_SIZE = 1024 * 1024;
+const SCAN_CONCURRENCY = 8;
 /**
  * Recursively find all files in a directory
  */
@@ -113,6 +127,38 @@ async function findFiles(dir, include, exclude) {
     await walk(dir, 0);
     return files;
 }
+/**
+ * Simple concurrency limiter (pLimit-style). Limits the number of
+ * concurrently executing async functions without adding a dependency.
+ */
+function createScanLimiter(concurrency) {
+    let active = 0;
+    const queue = [];
+    function next() {
+        if (queue.length > 0 && active < concurrency) {
+            active++;
+            const resolve = queue.shift();
+            resolve();
+        }
+    }
+    return async function limit(fn) {
+        if (active >= concurrency) {
+            await new Promise((resolve) => {
+                queue.push(resolve);
+            });
+        }
+        else {
+            active++;
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            active--;
+            next();
+        }
+    };
+}
 /**
  * Scan a directory (or single file) for all API elements
  */
@@ -129,27 +175,48 @@ export async function scanDirectory(dir, options = {}) {
     else {
         files = await findFiles(dir, include, exclude);
     }
-    const results = [];
+    // Pre-allocate results array to preserve original file ordering
+    const results = new Array(files.length);
     const allErrors = [];
     let totalElements = 0;
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        options.onProgress?.(i + 1, files.length, file);
+    let progressCounter = 0;
+    const limit = createScanLimiter(SCAN_CONCURRENCY);
+    const promises = files.map((file, i) => limit(async () => {
+        // P3: Skip files larger than MAX_FILE_SIZE
+        try {
+            const fileStats = statSync(file);
+            if (fileStats.size > MAX_FILE_SIZE) {
+                const sizeMB = (fileStats.size / (1024 * 1024)).toFixed(1);
+                console.warn(`  Warning: Skipping ${file} (${sizeMB} MB exceeds 1 MB limit)`);
+                return;
+            }
+        }
+        catch {
+            // If stat fails, let scanFile handle the error
+        }
+        progressCounter++;
+        options.onProgress?.(progressCounter, files.length, file);
         const scanner = getScannerForFile(file);
         if (!scanner)
-            continue;
+            return;
         try {
             const result = await scanner.scanFile(file);
-            results.push(result);
-            totalElements += result.elements.length;
-            allErrors.push(...result.errors);
+            results[i] = result;
         }
         catch (err) {
             allErrors.push(`Error scanning ${file}: ${err}`);
         }
+    }));
+    await Promise.all(promises);
+    // Collect results in original order
+    for (const result of results) {
+        if (!result)
+            continue;
+        totalElements += result.elements.length;
+        allErrors.push(...result.errors);
     }
     return {
-        files: results,
+        files: results.filter((r) => r !== undefined),
         totalElements,
         errors: allErrors
     };

package/dist/scanner/typescript.js

@@ -1,5 +1,14 @@
-import ts from 'typescript';
 import { readFileSync } from 'fs';
+/**
+ * Lazy-loaded TypeScript compiler (23MB, ~221ms load). Only loaded on first TS/JS scan.
+ * `_ts` holds the runtime module; type annotations use the `import type ts` namespace.
+ */
+let _ts;
+async function ensureTS() {
+    if (!_ts) {
+        _ts = (await import('typescript')).default;
+    }
+}
 export class TypeScriptScanner {
     languages = ['typescript', 'javascript'];
     canHandle(filePath) {
@@ -9,11 +18,13 @@ export class TypeScriptScanner {
         const language = filePath.endsWith('.ts') || filePath.endsWith('.tsx')
             ? 'typescript'
             : 'javascript';
+        // Ensure TypeScript compiler is loaded (lazy, cached after first call)
+        await ensureTS();
         try {
             const source = readFileSync(filePath, 'utf-8');
-            const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') || filePath.endsWith('.jsx')
-                ? ts.ScriptKind.TSX
-                : ts.ScriptKind.TS);
+            const sourceFile = _ts.createSourceFile(filePath, source, _ts.ScriptTarget.Latest, true, filePath.endsWith('.tsx') || filePath.endsWith('.jsx')
+                ? _ts.ScriptKind.TSX
+                : _ts.ScriptKind.TS);
             const elements = [];
             const errors = [];
             // Extract imports for context
@@ -41,8 +52,8 @@ export class TypeScriptScanner {
      */
     extractImports(sourceFile) {
         const imports = [];
-        ts.forEachChild(sourceFile, node => {
-            if (ts.isImportDeclaration(node)) {
+        _ts.forEachChild(sourceFile, node => {
+            if (_ts.isImportDeclaration(node)) {
                 imports.push(node.getText(sourceFile));
             }
         });
@@ -82,7 +93,7 @@ export class TypeScriptScanner {
     }
     visit(node, sourceFile, elements, filePath, source, imports, packageName, parentClass) {
         // Function declarations
-        if (ts.isFunctionDeclaration(node) && node.name) {
+        if (_ts.isFunctionDeclaration(node) && node.name) {
             const name = node.name.text;
             if (!this.isPrivate(name) && this.isExported(node)) {
                 const element = this.extractFunction(node, sourceFile, filePath);
@@ -93,10 +104,10 @@ export class TypeScriptScanner {
             }
         }
         // Arrow functions assigned to const (exported)
-        if (ts.isVariableStatement(node) && this.isExported(node)) {
+        if (_ts.isVariableStatement(node) && this.isExported(node)) {
             for (const decl of node.declarationList.declarations) {
-                if (ts.isIdentifier(decl.name) && decl.initializer) {
-                    if (ts.isArrowFunction(decl.initializer) || ts.isFunctionExpression(decl.initializer)) {
+                if (_ts.isIdentifier(decl.name) && decl.initializer) {
+                    if (_ts.isArrowFunction(decl.initializer) || _ts.isFunctionExpression(decl.initializer)) {
                         const name = decl.name.text;
                         if (!this.isPrivate(name)) {
                             const element = this.extractArrowFunction(decl, decl.initializer, sourceFile, filePath);
@@ -110,7 +121,7 @@ export class TypeScriptScanner {
             }
         }
         // Class declarations
-        if (ts.isClassDeclaration(node) && node.name) {
+        if (_ts.isClassDeclaration(node) && node.name) {
             const name = node.name.text;
             if (!this.isPrivate(name) && this.isExported(node)) {
                 const classElement = this.extractClass(node, sourceFile, filePath);
@@ -120,7 +131,7 @@ export class TypeScriptScanner {
                 elements.push(classElement);
                 // Extract methods
                 for (const member of node.members) {
-                    if (ts.isMethodDeclaration(member) && member.name) {
+                    if (_ts.isMethodDeclaration(member) && member.name) {
                         const methodName = this.getPropertyName(member.name);
                         if (methodName && !this.isPrivateMember(member) && !methodName.startsWith('_')) {
                             const methodElement = this.extractMethod(member, sourceFile, filePath, name);
@@ -130,7 +141,7 @@ export class TypeScriptScanner {
                             elements.push(methodElement);
                         }
                     }
-                    if (ts.isConstructorDeclaration(member)) {
+                    if (_ts.isConstructorDeclaration(member)) {
                         const ctorElement = this.extractConstructor(member, sourceFile, filePath, name);
                         ctorElement.imports = imports;
                         ctorElement.packageName = packageName;
@@ -141,28 +152,28 @@ export class TypeScriptScanner {
             }
         }
         // Recurse into children (but not into function/class bodies for top-level scan)
-        if (ts.isSourceFile(node) || ts.isModuleBlock(node)) {
-            ts.forEachChild(node, child => this.visit(child, sourceFile, elements, filePath, source, imports, packageName, parentClass));
+        if (_ts.isSourceFile(node) || _ts.isModuleBlock(node)) {
+            _ts.forEachChild(node, child => this.visit(child, sourceFile, elements, filePath, source, imports, packageName, parentClass));
         }
     }
     isPrivate(name) {
         return name.startsWith('_') && !name.startsWith('__');
     }
     isPrivateMember(node) {
-        const modifiers = ts.getModifiers(node);
+        const modifiers = _ts.getModifiers(node);
         if (modifiers) {
             for (const mod of modifiers) {
-                if (mod.kind === ts.SyntaxKind.PrivateKeyword)
+                if (mod.kind === _ts.SyntaxKind.PrivateKeyword)
                     return true;
             }
         }
         return false;
     }
     isExported(node) {
-        const modifiers = ts.getModifiers(node);
+        const modifiers = _ts.getModifiers(node);
         if (modifiers) {
             for (const mod of modifiers) {
-                if (mod.kind === ts.SyntaxKind.ExportKeyword)
+                if (mod.kind === _ts.SyntaxKind.ExportKeyword)
                     return true;
             }
         }
@@ -170,15 +181,15 @@ export class TypeScriptScanner {
         return false;
     }
     getPropertyName(name) {
-        if (ts.isIdentifier(name))
+        if (_ts.isIdentifier(name))
             return name.text;
-        if (ts.isStringLiteral(name))
+        if (_ts.isStringLiteral(name))
             return name.text;
         return undefined;
     }
     extractFunction(node, sourceFile, filePath) {
         const name = node.name?.text ?? 'anonymous';
-        const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const isAsync = node.modifiers?.some(m => m.kind === _ts.SyntaxKind.AsyncKeyword) ?? false;
         return {
             kind: 'function',
             name,
@@ -194,8 +205,8 @@ export class TypeScriptScanner {
         };
     }
     extractArrowFunction(decl, fn, sourceFile, filePath) {
-        const name = ts.isIdentifier(decl.name) ? decl.name.text : 'anonymous';
-        const isAsync = fn.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const name = _ts.isIdentifier(decl.name) ? decl.name.text : 'anonymous';
+        const isAsync = fn.modifiers?.some(m => m.kind === _ts.SyntaxKind.AsyncKeyword) ?? false;
         return {
             kind: 'function',
             name,
@@ -215,10 +226,10 @@ export class TypeScriptScanner {
         let signature = `class ${name}`;
         if (node.heritageClauses) {
             for (const clause of node.heritageClauses) {
-                if (clause.token === ts.SyntaxKind.ExtendsKeyword) {
+                if (clause.token === _ts.SyntaxKind.ExtendsKeyword) {
                     signature += ` extends ${clause.types.map(t => t.getText(sourceFile)).join(', ')}`;
                 }
-                if (clause.token === ts.SyntaxKind.ImplementsKeyword) {
+                if (clause.token === _ts.SyntaxKind.ImplementsKeyword) {
                     signature += ` implements ${clause.types.map(t => t.getText(sourceFile)).join(', ')}`;
                 }
             }
@@ -237,7 +248,7 @@ export class TypeScriptScanner {
     }
     extractMethod(node, sourceFile, filePath, parentClass) {
         const name = this.getPropertyName(node.name) ?? 'anonymous';
-        const isAsync = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
+        const isAsync = node.modifiers?.some(m => m.kind === _ts.SyntaxKind.AsyncKeyword) ?? false;
         return {
             kind: 'method',
             name,
@@ -267,7 +278,7 @@ export class TypeScriptScanner {
     }
     extractParameters(params, sourceFile) {
         return params.map(p => {
-            const name = ts.isIdentifier(p.name) ? p.name.text : p.name.getText(sourceFile);
+            const name = _ts.isIdentifier(p.name) ? p.name.text : p.name.getText(sourceFile);
             return {
                 name: p.dotDotDotToken ? `...${name}` : name,
                 type: p.type ? p.type.getText(sourceFile) : undefined,
@@ -276,7 +287,7 @@ export class TypeScriptScanner {
         });
     }
     buildSignature(node, sourceFile) {
-        const async = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+        const async = node.modifiers?.some(m => m.kind === _ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
         const name = node.name.text;
         const typeParams = node.typeParameters
             ? `<${node.typeParameters.map(t => t.getText(sourceFile)).join(', ')}>`
@@ -287,7 +298,7 @@ export class TypeScriptScanner {
     }
     buildArrowSignature(decl, fn, sourceFile) {
         const name = decl.name.text;
-        const async = fn.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+        const async = fn.modifiers?.some(m => m.kind === _ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
         const typeParams = fn.typeParameters
             ? `<${fn.typeParameters.map(t => t.getText(sourceFile)).join(', ')}>`
             : '';
@@ -296,7 +307,7 @@ export class TypeScriptScanner {
         return `const ${name} = ${async}${typeParams}(${params})${returnType} => ...`;
     }
     buildMethodSignature(node, sourceFile) {
-        const async = node.modifiers?.some(m => m.kind === ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
+        const async = node.modifiers?.some(m => m.kind === _ts.SyntaxKind.AsyncKeyword) ? 'async ' : '';
         const name = this.getPropertyName(node.name);
         const typeParams = node.typeParameters
             ? `<${node.typeParameters.map(t => t.getText(sourceFile)).join(', ')}>`

package/dist/sentry.d.ts

@@ -0,0 +1,3 @@
+import * as Sentry from '@sentry/node';
+export declare function initSentry(): void;
+export { Sentry };

package/dist/sentry.js

@@ -0,0 +1,28 @@
+import * as Sentry from '@sentry/node';
+const DSN = process.env.SENTRY_DSN;
+export function initSentry() {
+    if (!DSN)
+        return; // Gracefully disable when no DSN configured
+    Sentry.init({
+        dsn: DSN,
+        tracesSampleRate: 0.2,
+        environment: process.env.NODE_ENV || 'production',
+        release: process.env.npm_package_version,
+        beforeSend(event) {
+            // Strip any user file paths for privacy
+            if (event.exception?.values) {
+                for (const ex of event.exception.values) {
+                    if (ex.stacktrace?.frames) {
+                        for (const frame of ex.stacktrace.frames) {
+                            if (frame.filename && !frame.filename.includes('node_modules')) {
+                                frame.filename = frame.filename.replace(/\/Users\/[^/]+/, '~');
+                            }
+                        }
+                    }
+                }
+            }
+            return event;
+        },
+    });
+}
+export { Sentry };

package/dist/template/docs.json

@@ -1,4 +1,5 @@
 {
+  "$schema": "./public/docs-schema.json",
   "name": "Skrypt",
   "description": "AI-powered documentation generation",
   "fonts": {
@@ -6,8 +7,7 @@
     "mono": "JetBrains Mono"
   },
   "theme": {
-    "primaryColor": "#3b82f6",
-    "accentColor": "#8b5cf6"
+    "primaryColor": "#3b82f6"
   },
   "navigation": [
     {
@@ -33,6 +33,9 @@
     "links": [
       { "title": "GitHub", "url": "https://github.com/debgotwired/skrypt" },
       { "title": "npm", "url": "https://www.npmjs.com/package/skrypt-ai" }
-    ]
+    ],
+    "social": {
+      "github": "https://github.com/debgotwired/skrypt"
+    }
   }
 }

package/dist/template/next.config.mjs

@@ -1,6 +1,7 @@
 import createMDX from '@next/mdx'
 import remarkGfm from 'remark-gfm'
 import remarkFrontmatter from 'remark-frontmatter'
+import { withSentryConfig } from '@sentry/nextjs'
 
 const withMDX = createMDX({
   extension: /\.mdx?$/,
@@ -47,4 +48,17 @@ const nextConfig = {
   },
 }
 
-export default withMDX(nextConfig)
+export default withSentryConfig(withMDX(nextConfig), {
+  // Suppress Sentry build logs
+  silent: true,
+
+  // Source maps: disabled for now — enable per-customer later
+  sourcemaps: {
+    disable: true,
+  },
+
+  // Tunnel Sentry events through Next.js to bypass ad-blockers
+  tunnelRoute: '/monitoring',
+
+  // Do not set org/project — each customer configures their own via env vars
+})

package/dist/template/package.json

@@ -17,6 +17,8 @@
     "@mdx-js/react": "^3.1.0",
     "@next/mdx": "^15.3.0",
     "@orama/orama": "^3.1.0",
+    "@sentry/nextjs": "^10.45.0",
+    "ai": "^4.0.0",
     "clsx": "^2.1.0",
     "gray-matter": "^4.0.3",
     "lucide-react": "^0.500.0",
@@ -26,7 +28,6 @@
     "react-dom": "^19.0.0",
     "remark-frontmatter": "^5.0.0",
     "remark-gfm": "^4.0.0",
-    "ai": "^4.0.0",
     "shiki": "^3.0.0",
     "streamdown": "^1.0.0",
     "tailwind-merge": "^3.0.0",
@@ -34,8 +35,8 @@
   },
   "optionalDependencies": {
     "@codesandbox/sandpack-react": "^2.20.0",
-    "mermaid": "^11.13.0",
-    "@scalar/nextjs-api-reference": "^0.4.0"
+    "@scalar/nextjs-api-reference": "^0.4.0",
+    "mermaid": "^11.13.0"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4.1.0",