skrypt-ai 0.6.1 → 0.8.0

package/dist/next-actions/suggest.d.ts

@@ -0,0 +1,3 @@
+import { NextActionPreferences, ProjectActionState, Suggestion } from './types.js';
+export declare function getSuggestions(commandName: string, preferences: NextActionPreferences, _state?: ProjectActionState): Suggestion[];
+export declare function printSuggestions(suggestions: Suggestion[]): void;

package/dist/next-actions/suggest.js

@@ -0,0 +1,47 @@
+import { ACTION_DEFINITIONS } from './actions.js';
+const MAX_SUGGESTIONS = 2;
+export function getSuggestions(commandName, preferences, _state) {
+    if (!preferences.enabled)
+        return [];
+    const candidates = ACTION_DEFINITIONS
+        .filter(action => {
+        if (!action.afterCommands.includes(commandName))
+            return false;
+        if (!preferences.categories[action.category])
+            return false;
+        if (action.condition && !action.condition())
+            return false;
+        // Don't suggest the same command that just ran
+        if (action.command.startsWith('skrypt ')) {
+            const suggestedCmd = action.command.split(' ')[1];
+            if (suggestedCmd === commandName)
+                return false;
+        }
+        return true;
+    })
+        .sort((a, b) => b.priority - a.priority)
+        .slice(0, MAX_SUGGESTIONS);
+    // Deduplicate by command string
+    const seen = new Set();
+    const unique = [];
+    for (const c of candidates) {
+        if (!seen.has(c.command)) {
+            seen.add(c.command);
+            unique.push({ command: c.command, message: c.message });
+        }
+    }
+    return unique;
+}
+export function printSuggestions(suggestions) {
+    if (suggestions.length === 0)
+        return;
+    console.log('');
+    console.log('  \x1b[36m───\x1b[0m');
+    console.log('');
+    for (const s of suggestions) {
+        console.log(`  \x1b[36m\u2192\x1b[0m \x1b[1m${s.command}\x1b[0m`);
+        console.log(`    ${s.message}`);
+    }
+    console.log('');
+    console.log('  \x1b[90mManage: skrypt config --suggestions\x1b[0m');
+}

package/dist/next-actions/types.d.ts

@@ -0,0 +1,26 @@
+export interface NextActionPreferences {
+    enabled: boolean;
+    categories: {
+        workflow: boolean;
+        quality: boolean;
+        cicd: boolean;
+        advanced: boolean;
+    };
+}
+export interface ProjectActionState {
+    completedCommands: string[];
+    lastUpdated: string;
+}
+export interface ActionDefinition {
+    id: string;
+    afterCommands: string[];
+    category: keyof NextActionPreferences['categories'];
+    message: string;
+    command: string;
+    priority: number;
+    condition?: () => boolean;
+}
+export interface Suggestion {
+    command: string;
+    message: string;
+}

package/dist/refresh/differ.d.ts

@@ -0,0 +1,9 @@
+import { DocManifest, StaleElement } from './types.js';
+/**
+ * Get list of changed files since a given ref using git diff
+ */
+export declare function getChangedFiles(since: string, cwd?: string): string[];
+/**
+ * Find elements whose signatures have changed since the manifest was written
+ */
+export declare function findStaleElements(manifest: DocManifest, changedFiles: string[]): Promise<StaleElement[]>;

package/dist/refresh/differ.js

@@ -0,0 +1,67 @@
+import { spawnSync } from 'child_process';
+import { scanDirectory } from '../scanner/index.js';
+import { hashSignature } from './manifest.js';
+/**
+ * Get list of changed files since a given ref using git diff
+ */
+export function getChangedFiles(since, cwd) {
+    const result = spawnSync('git', ['diff', '--name-only', `${since}..HEAD`], {
+        stdio: 'pipe',
+        cwd,
+        timeout: 10000,
+    });
+    if (result.status !== 0) {
+        const stderr = result.stderr?.toString() || '';
+        throw new Error(`git diff failed: ${stderr}`);
+    }
+    return result.stdout
+        .toString()
+        .trim()
+        .split('\n')
+        .filter(Boolean);
+}
+/**
+ * Find elements whose signatures have changed since the manifest was written
+ */
+export async function findStaleElements(manifest, changedFiles) {
+    const stale = [];
+    // Find manifest entries whose source files have changed
+    const affectedEntries = manifest.elements.filter(entry => changedFiles.some(f => entry.sourceFile === f ||
+        entry.sourceFile.endsWith('/' + f) ||
+        f.endsWith('/' + entry.sourceFile)));
+    if (affectedEntries.length === 0) {
+        return stale;
+    }
+    // Re-scan the changed source files to get current signatures
+    const filesToScan = [...new Set(affectedEntries.map(e => e.sourceFile))];
+    for (const file of filesToScan) {
+        try {
+            const scanResult = await scanDirectory(file);
+            const currentElements = scanResult.files.flatMap(f => f.elements);
+            for (const entry of affectedEntries.filter(e => e.sourceFile === file)) {
+                const current = currentElements.find(el => el.name === entry.name && el.kind === entry.kind);
+                if (!current) {
+                    // Element was removed from code
+                    stale.push({
+                        entry,
+                        newSignature: '[REMOVED]',
+                        newSignatureHash: '',
+                    });
+                    continue;
+                }
+                const currentHash = hashSignature(current.signature);
+                if (currentHash !== entry.signatureHash) {
+                    stale.push({
+                        entry,
+                        newSignature: current.signature,
+                        newSignatureHash: currentHash,
+                    });
+                }
+            }
+        }
+        catch (err) {
+            console.warn(`  Warning: Could not scan ${file}: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    return stale;
+}

package/dist/refresh/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './manifest.js';
+export * from './differ.js';
+export * from './splicer.js';

package/dist/refresh/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './manifest.js';
+export * from './differ.js';
+export * from './splicer.js';

package/dist/refresh/manifest.d.ts

@@ -0,0 +1,18 @@
+import { APIElement } from '../scanner/types.js';
+import { DocManifest, ManifestEntry } from './types.js';
+/**
+ * Hash a signature string for change detection
+ */
+export declare function hashSignature(signature: string): string;
+/**
+ * Build manifest entries from scanned elements and output path
+ */
+export declare function buildManifestEntries(elements: APIElement[], outputPath: string): ManifestEntry[];
+/**
+ * Write manifest to .skrypt/manifest.json relative to output dir
+ */
+export declare function writeManifest(outputPath: string, entries: ManifestEntry[]): void;
+/**
+ * Read existing manifest
+ */
+export declare function readManifest(outputPath: string): DocManifest | null;

package/dist/refresh/manifest.js

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { createHash } from 'crypto';
+import { spawnSync } from 'child_process';
+const MANIFEST_DIR = '.skrypt';
+const MANIFEST_FILE = 'manifest.json';
+/**
+ * Hash a signature string for change detection
+ */
+export function hashSignature(signature) {
+    return createHash('sha256').update(signature).digest('hex').slice(0, 16);
+}
+/**
+ * Get current git commit SHA (short)
+ */
+function getCommitSha() {
+    try {
+        const result = spawnSync('git', ['rev-parse', '--short', 'HEAD'], {
+            stdio: 'pipe',
+            timeout: 3000,
+        });
+        if (result.status === 0) {
+            return result.stdout.toString().trim();
+        }
+    }
+    catch {
+        // Not a git repo or git not available
+    }
+    return 'unknown';
+}
+/**
+ * Build manifest entries from scanned elements and output path
+ */
+export function buildManifestEntries(elements, outputPath) {
+    return elements.map(el => ({
+        name: el.name,
+        kind: el.kind,
+        sourceFile: el.filePath,
+        signatureHash: hashSignature(el.signature),
+        docFile: outputPath,
+    }));
+}
+/**
+ * Write manifest to .skrypt/manifest.json relative to output dir
+ */
+export function writeManifest(outputPath, entries) {
+    const manifestDir = join(outputPath, MANIFEST_DIR);
+    mkdirSync(manifestDir, { recursive: true });
+    const manifest = {
+        generatedAt: new Date().toISOString(),
+        commitSha: getCommitSha(),
+        elements: entries,
+    };
+    writeFileSync(join(manifestDir, MANIFEST_FILE), JSON.stringify(manifest, null, 2));
+}
+/**
+ * Read existing manifest
+ */
+export function readManifest(outputPath) {
+    const manifestPath = join(outputPath, MANIFEST_DIR, MANIFEST_FILE);
+    if (!existsSync(manifestPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(manifestPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/refresh/splicer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Replace a section in a markdown file that documents a specific element.
+ * Finds the heading for the element and replaces content until the next heading of same/higher level.
+ */
+export declare function spliceDocSection(docFilePath: string, elementName: string, newContent: string): boolean;
+/**
+ * Remove a section from a doc file for a removed element
+ */
+export declare function removeDocSection(docFilePath: string, elementName: string): boolean;

package/dist/refresh/splicer.js

@@ -0,0 +1,50 @@
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+/**
+ * Replace a section in a markdown file that documents a specific element.
+ * Finds the heading for the element and replaces content until the next heading of same/higher level.
+ */
+export function spliceDocSection(docFilePath, elementName, newContent) {
+    if (!existsSync(docFilePath)) {
+        return false;
+    }
+    const content = readFileSync(docFilePath, 'utf-8');
+    const lines = content.split('\n');
+    // Find the heading for this element
+    const headingPattern = new RegExp(`^(#{2,4})\\s+\`${escapeRegex(elementName)}\``);
+    let startIdx = -1;
+    let headingLevel = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const match = lines[i].match(headingPattern);
+        if (match) {
+            startIdx = i;
+            headingLevel = match[1].length;
+            break;
+        }
+    }
+    if (startIdx === -1) {
+        return false;
+    }
+    // Find the end of this section (next heading of same or higher level)
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        const nextHeading = lines[i].match(/^(#{2,4})\s/);
+        if (nextHeading && nextHeading[1].length <= headingLevel) {
+            endIdx = i;
+            break;
+        }
+    }
+    // Splice in new content
+    const newLines = newContent.split('\n');
+    lines.splice(startIdx, endIdx - startIdx, ...newLines);
+    writeFileSync(docFilePath, lines.join('\n'));
+    return true;
+}
+/**
+ * Remove a section from a doc file for a removed element
+ */
+export function removeDocSection(docFilePath, elementName) {
+    return spliceDocSection(docFilePath, elementName, '');
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/refresh/types.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Entry in the doc manifest mapping code elements to docs
+ */
+export interface ManifestEntry {
+    name: string;
+    kind: 'function' | 'class' | 'method';
+    sourceFile: string;
+    signatureHash: string;
+    docFile: string;
+}
+/**
+ * The full manifest written to .skrypt/manifest.json
+ */
+export interface DocManifest {
+    generatedAt: string;
+    commitSha: string;
+    elements: ManifestEntry[];
+}
+/**
+ * An element whose signature has changed since last generation
+ */
+export interface StaleElement {
+    entry: ManifestEntry;
+    newSignature: string;
+    newSignatureHash: string;
+}
+/**
+ * Report for a refresh operation
+ */
+export interface RefreshReport {
+    regenerated: number;
+    removed: number;
+    unchanged: number;
+    total: number;
+    changedFiles: string[];
+    staleElements: StaleElement[];
+}

package/dist/review/index.d.ts

@@ -0,0 +1,8 @@
+import { LLMClient } from '../llm/types.js';
+import { ReviewFeedback, ReviewResult } from './types.js';
+export * from './types.js';
+export * from './parser.js';
+/**
+ * Apply a single feedback item by re-generating the relevant section
+ */
+export declare function applyFeedback(feedback: ReviewFeedback, client: LLMClient): Promise<ReviewResult>;

package/dist/review/index.js

@@ -0,0 +1,94 @@
+import { readFileSync, writeFileSync } from 'fs';
+export * from './types.js';
+export * from './parser.js';
+/**
+ * Apply a single feedback item by re-generating the relevant section
+ */
+export async function applyFeedback(feedback, client) {
+    try {
+        const content = readFileSync(feedback.filePath, 'utf-8');
+        const lines = content.split('\n');
+        // Determine the section to rewrite
+        let sectionStart = 0;
+        let sectionEnd = lines.length;
+        if (feedback.lineNumber) {
+            // Find the heading before this line
+            for (let i = feedback.lineNumber - 1; i >= 0; i--) {
+                if (lines[i].match(/^#{2,4}\s/)) {
+                    sectionStart = i;
+                    break;
+                }
+            }
+            // Find next heading of same/higher level
+            const headingMatch = lines[sectionStart]?.match(/^(#{2,4})\s/);
+            const level = headingMatch ? headingMatch[1].length : 2;
+            for (let i = sectionStart + 1; i < lines.length; i++) {
+                const nextHeading = lines[i].match(/^(#{2,4})\s/);
+                if (nextHeading && nextHeading[1].length <= level) {
+                    sectionEnd = i;
+                    break;
+                }
+            }
+        }
+        else if (feedback.elementName) {
+            // Find the element heading
+            const pattern = new RegExp(`^#{2,4}\\s+\`${escapeRegex(feedback.elementName)}\``);
+            for (let i = 0; i < lines.length; i++) {
+                if (pattern.test(lines[i])) {
+                    sectionStart = i;
+                    const headingMatch = lines[i].match(/^(#{2,4})/);
+                    const level = headingMatch ? headingMatch[1].length : 2;
+                    for (let j = i + 1; j < lines.length; j++) {
+                        const next = lines[j].match(/^(#{2,4})\s/);
+                        if (next && next[1].length <= level) {
+                            sectionEnd = j;
+                            break;
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+        const section = lines.slice(sectionStart, sectionEnd).join('\n');
+        // Ask LLM to rewrite incorporating feedback
+        const response = await client.complete({
+            messages: [
+                {
+                    role: 'system',
+                    content: 'You are a technical documentation writer. Rewrite the given documentation section incorporating the provided feedback. Maintain the same heading level and markdown structure. Return ONLY the rewritten section, no explanation.'
+                },
+                {
+                    role: 'user',
+                    content: `## Current documentation section:\n\n${section}\n\n## Feedback to incorporate:\n\n${feedback.feedback}\n\n## Rewrite the section above incorporating this feedback:`
+                }
+            ],
+            temperature: 0,
+            maxTokens: 2048,
+        });
+        const newSection = response.content.trim();
+        if (!newSection) {
+            return { feedback, applied: false, error: 'LLM returned empty response' };
+        }
+        lines.splice(sectionStart, sectionEnd - sectionStart, ...newSection.split('\n'));
+        // Remove the inline comment if it was an inline feedback
+        if (feedback.source === 'inline') {
+            const updatedContent = lines.join('\n');
+            const cleaned = updatedContent.replace(/<!--\s*(?:FIXME|TODO)\s*:[\s\S]*?-->\s*\n?/g, '');
+            writeFileSync(feedback.filePath, cleaned);
+        }
+        else {
+            writeFileSync(feedback.filePath, lines.join('\n'));
+        }
+        return { feedback, applied: true };
+    }
+    catch (err) {
+        return {
+            feedback,
+            applied: false,
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/review/parser.d.ts

@@ -0,0 +1,16 @@
+import { ReviewFeedback } from './types.js';
+/**
+ * Parse a feedback markdown file.
+ *
+ * Format:
+ * ## docs/api/users.md
+ * - Line 42: Use the SDK client.get() method, not raw fetch()
+ * - General: Too formal, make it conversational
+ */
+export declare function parseFeedbackFile(feedbackPath: string): ReviewFeedback[];
+/**
+ * Scan markdown files for inline FIXME/TODO comments.
+ *
+ * Looks for: <!-- FIXME: ... --> or <!-- TODO: ... -->
+ */
+export declare function parseInlineComments(docsDir: string): ReviewFeedback[];

package/dist/review/parser.js

@@ -0,0 +1,95 @@
+import { readFileSync, readdirSync, statSync } from 'fs';
+import { join, extname } from 'path';
+/**
+ * Parse a feedback markdown file.
+ *
+ * Format:
+ * ## docs/api/users.md
+ * - Line 42: Use the SDK client.get() method, not raw fetch()
+ * - General: Too formal, make it conversational
+ */
+export function parseFeedbackFile(feedbackPath) {
+    const content = readFileSync(feedbackPath, 'utf-8');
+    const lines = content.split('\n');
+    const feedback = [];
+    let currentFile = null;
+    for (const line of lines) {
+        // ## path/to/file.md
+        const fileMatch = line.match(/^##\s+(.+\.(?:md|mdx))\s*$/);
+        if (fileMatch) {
+            currentFile = fileMatch[1].trim();
+            continue;
+        }
+        if (!currentFile)
+            continue;
+        // - Line 42: feedback text
+        const lineMatch = line.match(/^-\s+Line\s+(\d+)\s*:\s*(.+)$/);
+        if (lineMatch) {
+            feedback.push({
+                filePath: currentFile,
+                lineNumber: parseInt(lineMatch[1], 10),
+                feedback: lineMatch[2].trim(),
+                source: 'file',
+            });
+            continue;
+        }
+        // - "elementName": feedback text
+        const elementMatch = line.match(/^-\s+"([^"]+)"\s*:\s*(.+)$/);
+        if (elementMatch) {
+            feedback.push({
+                filePath: currentFile,
+                elementName: elementMatch[1].trim(),
+                feedback: elementMatch[2].trim(),
+                source: 'file',
+            });
+            continue;
+        }
+        // - General: feedback text  or  - feedback text
+        const generalMatch = line.match(/^-\s+(?:General\s*:\s*)?(.+)$/);
+        if (generalMatch) {
+            feedback.push({
+                filePath: currentFile,
+                feedback: generalMatch[1].trim(),
+                source: 'file',
+            });
+        }
+    }
+    return feedback;
+}
+/**
+ * Scan markdown files for inline FIXME/TODO comments.
+ *
+ * Looks for: <!-- FIXME: ... --> or <!-- TODO: ... -->
+ */
+export function parseInlineComments(docsDir) {
+    const feedback = [];
+    function walk(dir) {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+            const fullPath = join(dir, entry);
+            const stat = statSync(fullPath);
+            if (stat.isDirectory() && !entry.startsWith('.') && entry !== 'node_modules') {
+                walk(fullPath);
+            }
+            else if (stat.isFile() && (extname(entry) === '.md' || extname(entry) === '.mdx')) {
+                const content = readFileSync(fullPath, 'utf-8');
+                const lines = content.split('\n');
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+                    // <!-- FIXME: ... --> or <!-- TODO: ... -->
+                    const commentMatch = line.match(/<!--\s*(?:FIXME|TODO)\s*:\s*(.*?)\s*-->/);
+                    if (commentMatch) {
+                        feedback.push({
+                            filePath: fullPath,
+                            lineNumber: i + 1,
+                            feedback: commentMatch[1].trim(),
+                            source: 'inline',
+                        });
+                    }
+                }
+            }
+        }
+    }
+    walk(docsDir);
+    return feedback;
+}

package/dist/review/types.d.ts

@@ -0,0 +1,18 @@
+/**
+ * A piece of feedback targeting a specific doc file or element
+ */
+export interface ReviewFeedback {
+    filePath: string;
+    lineNumber?: number;
+    elementName?: string;
+    feedback: string;
+    source: 'file' | 'inline';
+}
+/**
+ * Result of processing a single feedback item
+ */
+export interface ReviewResult {
+    feedback: ReviewFeedback;
+    applied: boolean;
+    error?: string;
+}

package/dist/scanner/csharp.d.ts

@@ -12,12 +12,8 @@ export declare class CSharpScanner implements Scanner {
     private extractMethods;
     private extractInterfaceMethods;
     private findClassRanges;
-    private findMatchingBrace;
     private findParentClass;
     private parseCSharpParams;
-    private splitParams;
-    private getLineNumber;
     private getDocComment;
     private extractGenerics;
-    private getSourceContext;
 }