skrypt-ai 0.7.0 → 0.8.1

package/dist/auth/index.js

@@ -8,7 +8,7 @@ if (!homeDir) {
 }
 const CONFIG_DIR = join(homeDir, '.skrypt');
 const AUTH_FILE = join(CONFIG_DIR, 'auth.json');
-const API_BASE = process.env.SKRYPT_API_URL || 'https://api.skrypt.sh';
+const API_BASE = process.env.SKRYPT_API_URL || 'https://app.skrypt.sh';
 /**
  * Sync auth config reader — checks env var and auth file only (no keychain).
  * Use getAuthConfigAsync() when keychain access is needed.
@@ -107,7 +107,7 @@ export async function getKeyStorageMethod() {
 }
 export async function checkPlan(apiKey) {
     try {
-        const response = await fetch(`${API_BASE}/v1/plan`, {
+        const response = await fetch(`${API_BASE}/api/auth/plan`, {
             headers: {
                 'Authorization': `Bearer ${apiKey}`,
                 'Content-Type': 'application/json'
@@ -135,6 +135,10 @@ export async function checkPlan(apiKey) {
     }
 }
 export async function requirePro(commandName) {
+    // Dev bypass: requires both SKRYPT_DEV=1 and a valid signed dev token
+    if (process.env.SKRYPT_DEV === '1' && process.env.NODE_ENV === 'test') {
+        return true;
+    }
     const config = await getAuthConfigAsync();
     if (!config.apiKey) {
         console.error(`\n  ⚡ ${commandName} requires Skrypt Pro\n`);
@@ -173,14 +177,16 @@ export async function requirePro(commandName) {
 }
 // Pro commands list
 export const PRO_COMMANDS = [
+    'claims',
     'monitor',
+    'mutate',
     'autofix',
     'heal',
     'test',
     'sdk',
     'gh-action',
-    'ci',
     'mcp',
     'refresh',
     'review',
+    'review-pr',
 ];

package/dist/binding/binder.d.ts

@@ -0,0 +1,5 @@
+import { CodeSymbol, DocSection, Binding } from './types.js';
+/**
+ * Match doc sections to code symbols and produce bindings
+ */
+export declare function createBindings(symbols: CodeSymbol[], sections: DocSection[]): Binding[];

package/dist/binding/binder.js

@@ -0,0 +1,63 @@
+/**
+ * Match doc sections to code symbols and produce bindings
+ */
+export function createBindings(symbols, sections) {
+    const bindings = [];
+    const seen = new Set();
+    const symbolsByName = new Map();
+    for (const sym of symbols) {
+        const key = sym.name.toLowerCase();
+        if (!symbolsByName.has(key))
+            symbolsByName.set(key, []);
+        symbolsByName.get(key).push(sym);
+    }
+    for (const section of sections) {
+        for (const refName of section.referencedSymbols) {
+            const matches = symbolsByName.get(refName.toLowerCase());
+            if (!matches)
+                continue;
+            for (const sym of matches) {
+                // O(1) dedup check using Set
+                const dedupKey = `${section.filePath}::${section.heading}::${sym.name}::${sym.filePath}`;
+                if (seen.has(dedupKey))
+                    continue;
+                seen.add(dedupKey);
+                // Determine binding type and confidence
+                const { bindingType, confidence } = classifyBinding(section, sym, refName);
+                bindings.push({
+                    docSection: {
+                        filePath: section.filePath,
+                        heading: section.heading,
+                        startLine: section.startLine,
+                    },
+                    codeSymbol: {
+                        name: sym.name,
+                        kind: sym.kind,
+                        filePath: sym.filePath,
+                        hash: sym.hash,
+                    },
+                    confidence,
+                    bindingType,
+                });
+            }
+        }
+    }
+    return bindings;
+}
+/**
+ * Classify how a doc section references a code symbol
+ */
+function classifyBinding(section, symbol, _refName) {
+    // Check if any code block in the section explicitly uses this symbol
+    for (const block of section.codeBlocks) {
+        if (block.referencedSymbols.some(s => s.toLowerCase() === symbol.name.toLowerCase())) {
+            return { bindingType: 'explicit', confidence: 0.95 };
+        }
+    }
+    // Check if the section heading contains the symbol name
+    if (section.heading.toLowerCase().includes(symbol.name.toLowerCase())) {
+        return { bindingType: 'reference', confidence: 0.85 };
+    }
+    // Prose reference
+    return { bindingType: 'reference', confidence: 0.6 };
+}

package/dist/binding/detector.d.ts

@@ -0,0 +1,5 @@
+import { CodeSymbol, Binding, StaleDoc } from './types.js';
+/**
+ * Detect which doc sections are stale by comparing old and new symbol hashes
+ */
+export declare function detectStale(oldSymbols: CodeSymbol[], newSymbols: CodeSymbol[], bindings: Binding[]): StaleDoc[];

package/dist/binding/detector.js

@@ -0,0 +1,51 @@
+/**
+ * Detect which doc sections are stale by comparing old and new symbol hashes
+ */
+export function detectStale(oldSymbols, newSymbols, bindings) {
+    const staleDocs = [];
+    // Index by filePath::name for O(1) lookup
+    const oldByLookup = new Map();
+    const newByLookup = new Map();
+    for (const s of oldSymbols)
+        oldByLookup.set(lookupKey(s), s);
+    for (const s of newSymbols)
+        newByLookup.set(lookupKey(s), s);
+    for (const binding of bindings) {
+        const bKey = `${binding.codeSymbol.filePath}::${binding.codeSymbol.name}`;
+        const oldSym = oldByLookup.get(bKey);
+        const newSym = newByLookup.get(bKey);
+        if (!newSym && oldSym) {
+            // Symbol was deleted
+            staleDocs.push({
+                docPath: binding.docSection.filePath,
+                section: binding.docSection.heading,
+                reason: `Symbol '${binding.codeSymbol.name}' was deleted from ${binding.codeSymbol.filePath}`,
+                severity: 'high',
+                changedSymbol: binding.codeSymbol.name,
+            });
+        }
+        else if (oldSym && newSym && oldSym.hash !== newSym.hash) {
+            // Symbol was modified
+            const severity = binding.confidence >= 0.8 ? 'high' : 'medium';
+            staleDocs.push({
+                docPath: binding.docSection.filePath,
+                section: binding.docSection.heading,
+                reason: `Symbol '${binding.codeSymbol.name}' was modified in ${binding.codeSymbol.filePath}`,
+                severity,
+                changedSymbol: binding.codeSymbol.name,
+            });
+        }
+    }
+    // Deduplicate by docPath + section
+    const seen = new Set();
+    return staleDocs.filter(s => {
+        const key = `${s.docPath}::${s.section}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function lookupKey(s) {
+    return `${s.filePath}::${s.name}`;
+}

package/dist/binding/doc-parser.d.ts

@@ -0,0 +1,9 @@
+import { DocSection } from './types.js';
+/**
+ * Parse all doc files in a directory and extract sections with symbol references
+ */
+export declare function parseDocSections(docsDir: string): DocSection[];
+/**
+ * Parse a single markdown/MDX file into sections
+ */
+export declare function parseFile(filePath: string): DocSection[];

package/dist/binding/doc-parser.js

@@ -0,0 +1,138 @@
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+/**
+ * Parse all doc files in a directory and extract sections with symbol references
+ */
+export function parseDocSections(docsDir) {
+    const files = findMarkdownFiles(docsDir);
+    const sections = [];
+    for (const filePath of files) {
+        sections.push(...parseFile(filePath));
+    }
+    return sections;
+}
+/**
+ * Parse a single markdown/MDX file into sections
+ */
+export function parseFile(filePath) {
+    const content = readFileSync(filePath, 'utf-8');
+    const lines = content.split('\n');
+    const sections = [];
+    let currentSection = null;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const headingMatch = line.match(/^(#{1,6})\s+(.+)$/);
+        if (headingMatch) {
+            // Finalize previous section
+            if (currentSection) {
+                currentSection.endLine = i - 1;
+                currentSection.referencedSymbols = dedup(currentSection.referencedSymbols);
+                sections.push(currentSection);
+            }
+            currentSection = {
+                filePath,
+                heading: headingMatch[2].replace(/`/g, ''),
+                headingLevel: headingMatch[1].length,
+                startLine: i,
+                endLine: lines.length - 1,
+                referencedSymbols: [],
+                codeBlocks: [],
+            };
+        }
+        if (!currentSection)
+            continue;
+        // Extract inline code references (backtick-wrapped names)
+        const inlineCodeMatches = line.matchAll(/`([a-zA-Z_]\w*(?:\.\w+)*(?:\([^)]*\))?)`/g);
+        for (const match of inlineCodeMatches) {
+            const name = match[1].replace(/\(.*\)$/, ''); // strip function call parens
+            currentSection.referencedSymbols.push(name);
+        }
+        // Extract code blocks (opening fence: ```lang or bare ```)
+        const trimmedLine = line.trim();
+        // Match: bare ``` or ```language — but not single-line fences like ```code here```
+        if (trimmedLine.startsWith('```')) {
+            const afterBackticks = trimmedLine.slice(3);
+            const isSingleLineFence = afterBackticks.includes('```');
+            if (!isSingleLineFence) {
+                const lang = afterBackticks.trim();
+                const blockStart = i;
+                const blockLines = [];
+                i++;
+                while (i < lines.length && !lines[i].trim().startsWith('```')) {
+                    blockLines.push(lines[i]);
+                    i++;
+                }
+                const blockContent = blockLines.join('\n');
+                const blockSymbols = extractSymbolsFromCode(blockContent);
+                const codeBlock = {
+                    language: lang || 'unknown',
+                    content: blockContent,
+                    startLine: blockStart,
+                    endLine: i,
+                    referencedSymbols: blockSymbols,
+                };
+                currentSection.codeBlocks.push(codeBlock);
+                currentSection.referencedSymbols.push(...blockSymbols);
+            }
+        }
+    }
+    // Finalize last section
+    if (currentSection) {
+        currentSection.referencedSymbols = dedup(currentSection.referencedSymbols);
+        sections.push(currentSection);
+    }
+    return sections;
+}
+/**
+ * Extract symbol names referenced in a code block
+ */
+function extractSymbolsFromCode(code) {
+    const names = [];
+    // Function/method calls: name(
+    const callMatches = code.matchAll(/\b([a-zA-Z_]\w*)\s*\(/g);
+    for (const m of callMatches) {
+        const name = m[1];
+        if (!isCommonKeyword(name))
+            names.push(name);
+    }
+    // Class instantiation: new Name
+    const newMatches = code.matchAll(/\bnew\s+([A-Z]\w*)/g);
+    for (const m of newMatches)
+        names.push(m[1]);
+    // Type references: : TypeName or <TypeName>
+    const typeMatches = code.matchAll(/:\s*([A-Z]\w*)|<([A-Z]\w*)>/g);
+    for (const m of typeMatches)
+        names.push(m[1] || m[2]);
+    return dedup(names);
+}
+function isCommonKeyword(name) {
+    const keywords = new Set([
+        'if', 'else', 'for', 'while', 'return', 'const', 'let', 'var', 'function',
+        'class', 'import', 'export', 'from', 'async', 'await', 'try', 'catch',
+        'throw', 'new', 'typeof', 'instanceof', 'console', 'require', 'log',
+        'print', 'def', 'self', 'None', 'True', 'False', 'len', 'range', 'str',
+        'int', 'float', 'list', 'dict', 'set', 'map', 'filter', 'reduce',
+    ]);
+    return keywords.has(name);
+}
+function findMarkdownFiles(dir) {
+    const files = [];
+    function walk(d) {
+        const entries = readdirSync(d);
+        for (const entry of entries) {
+            const fullPath = join(d, entry);
+            const s = statSync(fullPath);
+            if (s.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules') {
+                walk(fullPath);
+            }
+            else if (s.isFile() && (extname(entry) === '.md' || extname(entry) === '.mdx')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    walk(dir);
+    return files;
+}
+function dedup(arr) {
+    return [...new Set(arr)];
+}

package/dist/binding/extractor.d.ts

@@ -0,0 +1,14 @@
+import { APIElement } from '../scanner/types.js';
+import { CodeSymbol } from './types.js';
+/**
+ * Extract code symbols from a source directory using the existing scanner
+ */
+export declare function extractSymbols(sourcePath: string): Promise<CodeSymbol[]>;
+/**
+ * Convert an APIElement from the scanner to a CodeSymbol for binding
+ */
+export declare function elementToSymbol(el: APIElement): CodeSymbol;
+/**
+ * Hash content for change detection
+ */
+export declare function hashContent(content: string): string;

package/dist/binding/extractor.js

@@ -0,0 +1,39 @@
+import { createHash } from 'crypto';
+import { scanDirectory } from '../scanner/index.js';
+/**
+ * Extract code symbols from a source directory using the existing scanner
+ */
+export async function extractSymbols(sourcePath) {
+    const scanResult = await scanDirectory(sourcePath);
+    const symbols = [];
+    for (const file of scanResult.files) {
+        for (const el of file.elements) {
+            symbols.push(elementToSymbol(el));
+        }
+    }
+    return symbols;
+}
+/**
+ * Convert an APIElement from the scanner to a CodeSymbol for binding
+ */
+export function elementToSymbol(el) {
+    return {
+        name: el.name,
+        kind: el.kind === 'function' || el.kind === 'method' || el.kind === 'class'
+            ? el.kind
+            : 'function',
+        filePath: el.filePath,
+        startLine: el.lineNumber,
+        endLine: el.lineNumber + (el.sourceContext?.split('\n').length ?? 1),
+        signature: el.signature,
+        hash: hashContent(el.signature + (el.sourceContext || '')),
+        isExported: el.isExported ?? el.isPublic ?? false,
+        parentClass: el.parentClass,
+    };
+}
+/**
+ * Hash content for change detection
+ */
+export function hashContent(content) {
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+}

package/dist/binding/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './extractor.js';
+export * from './doc-parser.js';
+export * from './binder.js';
+export * from './detector.js';

package/dist/binding/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './extractor.js';
+export * from './doc-parser.js';
+export * from './binder.js';
+export * from './detector.js';

package/dist/binding/types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * A code symbol extracted from source via AST or regex
+ */
+export interface CodeSymbol {
+    name: string;
+    kind: 'function' | 'class' | 'method' | 'type' | 'interface' | 'constant' | 'variable';
+    filePath: string;
+    startLine: number;
+    endLine: number;
+    signature: string;
+    hash: string;
+    isExported: boolean;
+    parentClass?: string;
+}
+/**
+ * A section of documentation parsed from MDX/markdown
+ */
+export interface DocSection {
+    filePath: string;
+    heading: string;
+    headingLevel: number;
+    startLine: number;
+    endLine: number;
+    referencedSymbols: string[];
+    codeBlocks: CodeBlockRef[];
+}
+/**
+ * A code block within a doc section
+ */
+export interface CodeBlockRef {
+    language: string;
+    content: string;
+    startLine: number;
+    endLine: number;
+    referencedSymbols: string[];
+}
+/**
+ * A binding between a doc section and a code symbol
+ */
+export interface Binding {
+    docSection: {
+        filePath: string;
+        heading: string;
+        startLine: number;
+    };
+    codeSymbol: {
+        name: string;
+        kind: string;
+        filePath: string;
+        hash: string;
+    };
+    confidence: number;
+    bindingType: 'explicit' | 'reference' | 'inferred';
+}
+/**
+ * A doc page detected as stale
+ */
+export interface StaleDoc {
+    docPath: string;
+    section: string;
+    reason: string;
+    severity: 'high' | 'medium' | 'low';
+    changedSymbol: string;
+}
+/**
+ * The full bindings file stored in .skrypt/bindings.json
+ */
+export interface BindingsFile {
+    version: 1;
+    generatedAt: string;
+    bindings: Binding[];
+    symbols: CodeSymbol[];
+    sections: DocSection[];
+}

package/dist/claims/extractor.d.ts

@@ -0,0 +1,13 @@
+import { LLMClient } from '../llm/types.js';
+import { Claim } from './types.js';
+/**
+ * Extract testable claims from a documentation file using LLM
+ */
+export declare function extractClaimsFromFile(filePath: string, client: LLMClient): Promise<Claim[]>;
+/**
+ * Extract claims from all docs in a directory
+ */
+export declare function extractClaimsFromDirectory(docsDir: string, client: LLMClient, options?: {
+    file?: string;
+    type?: Claim['type'];
+}): Promise<Claim[]>;

package/dist/claims/extractor.js

@@ -0,0 +1,138 @@
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+import { createHash } from 'crypto';
+const EXTRACTION_PROMPT = `You are a documentation analysis expert. Extract all TESTABLE CLAIMS from this documentation section.
+
+A testable claim is a statement that can be verified by running code. For each claim:
+1. Quote the exact text making the claim
+2. Classify its type:
+   - behavioral: "function X returns Y when Z" — directly testable
+   - constraint: "never returns null", "list is always sorted" — property-testable
+   - integration: "works with library X version Y" — env-testable
+   - performance: "handles 1000 requests/second" — benchmark-testable
+   - error_handling: "throws TypeError on invalid input" — exception-testable
+3. Assess confidence (0.0-1.0) that this is actually testable
+4. Mark testable: true/false
+5. Suggest a test code snippet if testable
+
+Respond with ONLY a JSON array:
+[
+  {
+    "text": "exact claim text",
+    "type": "behavioral|constraint|integration|performance|error_handling",
+    "confidence": 0.85,
+    "testable": true,
+    "suggestedTest": "// test code here"
+  }
+]
+
+If no testable claims found, return [].`;
+/**
+ * Extract testable claims from a documentation file using LLM
+ */
+export async function extractClaimsFromFile(filePath, client) {
+    const content = readFileSync(filePath, 'utf-8');
+    const sections = splitIntoSections(content);
+    const claims = [];
+    for (const section of sections) {
+        if (section.content.trim().length < 50)
+            continue; // skip tiny sections
+        try {
+            const sectionClaims = await extractClaimsFromSection(section.content, section.heading, filePath, section.startLine, client);
+            claims.push(...sectionClaims);
+        }
+        catch {
+            // Skip failed sections
+        }
+    }
+    return claims;
+}
+/**
+ * Extract claims from a single documentation section
+ */
+async function extractClaimsFromSection(content, heading, filePath, startLine, client) {
+    const response = await client.complete({
+        messages: [
+            { role: 'system', content: EXTRACTION_PROMPT },
+            { role: 'user', content: `## Section: ${heading}\n\n${content.slice(0, 3000)}` },
+        ],
+        temperature: 0,
+        maxTokens: 2048,
+    });
+    // Parse JSON from response
+    const jsonMatch = response.content.match(/\[[\s\S]*\]/);
+    if (!jsonMatch)
+        return [];
+    try {
+        const raw = JSON.parse(jsonMatch[0]);
+        return raw.map(item => ({
+            id: createHash('sha256').update(`${filePath}:${heading}:${item.text}`).digest('hex').slice(0, 12),
+            type: validateClaimType(item.type),
+            text: item.text,
+            source: { file: filePath, section: heading, line: startLine },
+            confidence: Math.max(0, Math.min(1, item.confidence)),
+            testable: item.testable,
+            suggestedTest: item.suggestedTest,
+            status: 'extracted',
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Extract claims from all docs in a directory
+ */
+export async function extractClaimsFromDirectory(docsDir, client, options) {
+    const files = options?.file
+        ? [options.file]
+        : findMarkdownFiles(docsDir);
+    const allClaims = [];
+    for (const file of files) {
+        const claims = await extractClaimsFromFile(file, client);
+        allClaims.push(...claims);
+    }
+    if (options?.type) {
+        return allClaims.filter(c => c.type === options.type);
+    }
+    return allClaims;
+}
+function validateClaimType(type) {
+    const valid = ['behavioral', 'constraint', 'integration', 'performance', 'error_handling'];
+    return valid.includes(type) ? type : 'behavioral';
+}
+function splitIntoSections(content) {
+    const lines = content.split('\n');
+    const sections = [];
+    let current = null;
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(/^(#{1,6})\s+(.+)$/);
+        if (match) {
+            if (current)
+                sections.push(current);
+            current = { heading: match[2], content: '', startLine: i };
+        }
+        else if (current) {
+            current.content += lines[i] + '\n';
+        }
+    }
+    if (current)
+        sections.push(current);
+    return sections;
+}
+function findMarkdownFiles(dir) {
+    const files = [];
+    function walk(d) {
+        const entries = readdirSync(d);
+        for (const entry of entries) {
+            const fullPath = join(d, entry);
+            const s = statSync(fullPath);
+            if (s.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules')
+                walk(fullPath);
+            else if (s.isFile() && (extname(entry) === '.md' || extname(entry) === '.mdx'))
+                files.push(fullPath);
+        }
+    }
+    walk(dir);
+    return files;
+}

package/dist/claims/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './extractor.js';
+export * from './store.js';
+export * from './reporter.js';

package/dist/claims/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './extractor.js';
+export * from './store.js';
+export * from './reporter.js';

package/dist/claims/reporter.d.ts

@@ -0,0 +1,9 @@
+import { Claim } from './types.js';
+/**
+ * Print claims report to terminal
+ */
+export declare function printClaimsReport(claims: Claim[]): void;
+/**
+ * Format claims as JSON
+ */
+export declare function formatClaimsJson(claims: Claim[]): string;