skrypt-ai 0.6.0 → 0.7.0

package/dist/next-actions/setup.js

@@ -0,0 +1,72 @@
+import * as readline from 'readline';
+import { writePreferences, DEFAULT_PREFERENCES } from './state.js';
+function ask(rl, question) {
+    return new Promise((resolve, reject) => {
+        rl.question(question, answer => resolve(answer.trim()));
+        rl.once('close', () => reject(new Error('EOF')));
+    });
+}
+export async function runFirstTimeSetup() {
+    console.log('');
+    console.log('  \x1b[36m─────────────────────────────────────\x1b[0m');
+    console.log('');
+    console.log('  Skrypt can suggest next steps after each command.');
+    console.log('');
+    console.log('  1) All suggestions (recommended)');
+    console.log('  2) Workflow only (generate \u2192 test \u2192 deploy)');
+    console.log('  3) Customize');
+    console.log('  4) Disable');
+    console.log('');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const choice = await ask(rl, '  Choice [1]: ');
+        const selected = choice || '1';
+        let prefs;
+        if (selected === '4') {
+            prefs = {
+                enabled: false,
+                categories: { workflow: false, quality: false, cicd: false, advanced: false },
+            };
+        }
+        else if (selected === '2') {
+            prefs = {
+                enabled: true,
+                categories: { workflow: true, quality: false, cicd: false, advanced: false },
+            };
+        }
+        else if (selected === '3') {
+            console.log('');
+            const w = await ask(rl, '  Workflow (generate, test, deploy)? [Y/n] ');
+            const q = await ask(rl, '  Quality (qa, lint, security)? [Y/n] ');
+            const c = await ask(rl, '  CI/CD (GitHub Actions, deploy)? [Y/n] ');
+            const a = await ask(rl, '  Advanced (audit, refresh, review)? [Y/n] ');
+            prefs = {
+                enabled: true,
+                categories: {
+                    workflow: w.toLowerCase() !== 'n',
+                    quality: q.toLowerCase() !== 'n',
+                    cicd: c.toLowerCase() !== 'n',
+                    advanced: a.toLowerCase() !== 'n',
+                },
+            };
+        }
+        else {
+            prefs = { ...DEFAULT_PREFERENCES };
+        }
+        writePreferences(prefs);
+        console.log('');
+        if (prefs.enabled) {
+            console.log('  \x1b[32mSaved!\x1b[0m Change anytime with: skrypt config --suggestions');
+        }
+        else {
+            console.log('  Suggestions disabled. Re-enable with: skrypt config --suggestions');
+        }
+        return prefs;
+    }
+    finally {
+        rl.close();
+    }
+}

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

@@ -0,0 +1,7 @@
+import { NextActionPreferences, ProjectActionState } from './types.js';
+export declare const DEFAULT_PREFERENCES: NextActionPreferences;
+export declare function readPreferences(): NextActionPreferences | null;
+export declare function writePreferences(prefs: NextActionPreferences): void;
+export declare function readProjectState(): ProjectActionState;
+export declare function writeProjectState(state: ProjectActionState): void;
+export declare function markCommandCompleted(commandName: string): void;

package/dist/next-actions/state.js

@@ -0,0 +1,68 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { createHash } from 'crypto';
+function skryptHome() {
+    return join(homedir(), '.skrypt');
+}
+function preferencesFile() {
+    return join(skryptHome(), 'preferences.json');
+}
+function projectsDir() {
+    return join(skryptHome(), 'projects');
+}
+export const DEFAULT_PREFERENCES = {
+    enabled: true,
+    categories: {
+        workflow: true,
+        quality: true,
+        cicd: true,
+        advanced: true,
+    },
+};
+function projectHash() {
+    return createHash('sha256').update(process.cwd()).digest('hex').slice(0, 12);
+}
+function projectStatePath() {
+    return join(projectsDir(), `${projectHash()}.json`);
+}
+export function readPreferences() {
+    try {
+        const path = preferencesFile();
+        if (!existsSync(path))
+            return null;
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+export function writePreferences(prefs) {
+    const home = skryptHome();
+    mkdirSync(home, { recursive: true });
+    writeFileSync(preferencesFile(), JSON.stringify(prefs, null, 2), { mode: 0o600 });
+}
+export function readProjectState() {
+    try {
+        const path = projectStatePath();
+        if (!existsSync(path)) {
+            return { completedCommands: [], lastUpdated: '' };
+        }
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return { completedCommands: [], lastUpdated: '' };
+    }
+}
+export function writeProjectState(state) {
+    mkdirSync(projectsDir(), { recursive: true });
+    state.lastUpdated = new Date().toISOString();
+    writeFileSync(projectStatePath(), JSON.stringify(state, null, 2), { mode: 0o600 });
+}
+export function markCommandCompleted(commandName) {
+    const state = readProjectState();
+    if (!state.completedCommands.includes(commandName)) {
+        state.completedCommands.push(commandName);
+    }
+    writeProjectState(state);
+}

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/next-actions/types.js

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

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/refresh/types.js

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

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[];