clavix 2.3.0 → 2.4.0

package/dist/core 2/doc-injector.js

@@ -0,0 +1,236 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocInjector = void 0;
+const path = __importStar(require("path"));
+const file_system_1 = require("../utils/file-system");
+const errors_1 = require("../types/errors");
+/**
+ * DocInjector - manages injection and updating of managed blocks in documentation files
+ */
+class DocInjector {
+    /**
+     * Inject or update managed block in a file
+     */
+    static async injectBlock(filePath, content, options) {
+        const opts = {
+            startMarker: options?.startMarker || this.DEFAULT_START_MARKER,
+            endMarker: options?.endMarker || this.DEFAULT_END_MARKER,
+            content,
+            createIfMissing: options?.createIfMissing ?? true,
+            validateMarkdown: options?.validateMarkdown ?? true,
+        };
+        const fullPath = path.resolve(filePath);
+        let fileContent = '';
+        // Read existing file or create new
+        if (await file_system_1.FileSystem.exists(fullPath)) {
+            fileContent = await file_system_1.FileSystem.readFile(fullPath);
+        }
+        else if (!opts.createIfMissing) {
+            throw new errors_1.DataError(`File not found: ${filePath}`, 'Set createIfMissing: true to create the file automatically');
+        }
+        // Build the managed block
+        const blockRegex = new RegExp(`${this.escapeRegex(opts.startMarker)}[\\s\\S]*?${this.escapeRegex(opts.endMarker)}`, 'g');
+        const wrappedContent = this.wrapContent(opts.content, opts.startMarker, opts.endMarker);
+        if (blockRegex.test(fileContent)) {
+            // Replace existing block
+            await file_system_1.FileSystem.backup(fullPath);
+            fileContent = fileContent.replace(blockRegex, wrappedContent);
+        }
+        else {
+            // Append new block
+            if (fileContent && !fileContent.endsWith('\n\n')) {
+                fileContent += '\n\n';
+            }
+            fileContent += wrappedContent + '\n';
+        }
+        // Validate markdown if requested
+        if (opts.validateMarkdown) {
+            this.validateMarkdown(fileContent);
+        }
+        try {
+            // Ensure parent directory exists
+            const dir = path.dirname(fullPath);
+            await file_system_1.FileSystem.ensureDir(dir);
+            await file_system_1.FileSystem.writeFileAtomic(fullPath, fileContent);
+        }
+        catch (error) {
+            // Attempt to restore backup
+            if (await file_system_1.FileSystem.exists(`${fullPath}.backup`)) {
+                await file_system_1.FileSystem.restoreBackup(fullPath);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Detect if file contains managed block
+     */
+    static async hasBlock(filePath, startMarker, endMarker) {
+        const start = startMarker || this.DEFAULT_START_MARKER;
+        const end = endMarker || this.DEFAULT_END_MARKER;
+        if (!(await file_system_1.FileSystem.exists(filePath))) {
+            return false;
+        }
+        const content = await file_system_1.FileSystem.readFile(filePath);
+        const blockRegex = new RegExp(`${this.escapeRegex(start)}[\\s\\S]*?${this.escapeRegex(end)}`, 'g');
+        return blockRegex.test(content);
+    }
+    /**
+     * Extract content from managed block
+     */
+    static async extractBlock(filePath, startMarker, endMarker) {
+        const start = startMarker || this.DEFAULT_START_MARKER;
+        const end = endMarker || this.DEFAULT_END_MARKER;
+        if (!(await file_system_1.FileSystem.exists(filePath))) {
+            return null;
+        }
+        const content = await file_system_1.FileSystem.readFile(filePath);
+        const blockRegex = new RegExp(`${this.escapeRegex(start)}([\\s\\S]*?)${this.escapeRegex(end)}`, 'g');
+        const match = blockRegex.exec(content);
+        return match ? match[1].trim() : null;
+    }
+    /**
+     * Remove managed block from file
+     */
+    static async removeBlock(filePath, startMarker, endMarker) {
+        const start = startMarker || this.DEFAULT_START_MARKER;
+        const end = endMarker || this.DEFAULT_END_MARKER;
+        if (!(await file_system_1.FileSystem.exists(filePath))) {
+            return;
+        }
+        const content = await file_system_1.FileSystem.readFile(filePath);
+        const blockRegex = new RegExp(`${this.escapeRegex(start)}[\\s\\S]*?${this.escapeRegex(end)}\\n?`, 'g');
+        if (blockRegex.test(content)) {
+            await file_system_1.FileSystem.backup(filePath);
+            const updated = content.replace(blockRegex, '');
+            await file_system_1.FileSystem.writeFileAtomic(filePath, updated);
+        }
+    }
+    /**
+     * Wrap content with markers
+     */
+    static wrapContent(content, startMarker, endMarker) {
+        return `${startMarker}\n${content}\n${endMarker}`;
+    }
+    /**
+     * Escape special regex characters
+     */
+    static escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    /**
+     * Basic markdown validation
+     */
+    static validateMarkdown(content) {
+        // Check for balanced code blocks
+        const codeBlockMarkers = (content.match(/```/g) || []).length;
+        if (codeBlockMarkers % 2 !== 0) {
+            throw new errors_1.DataError('Invalid markdown: Unbalanced code blocks');
+        }
+        // Check for balanced brackets
+        const openBrackets = (content.match(/\[/g) || []).length;
+        const closeBrackets = (content.match(/\]/g) || []).length;
+        if (openBrackets !== closeBrackets) {
+            console.warn('Warning: Unbalanced brackets in markdown');
+        }
+    }
+    /**
+     * Create default AGENTS.md content
+     */
+    static getDefaultAgentsContent() {
+        return `# AI Agent Instructions
+
+This file contains instructions for AI agents working with this project.
+
+<!-- CLAVIX:START -->
+# Clavix - Prompt Improvement Assistant
+
+Clavix is installed in this project. Use the following slash commands:
+
+- \`/clavix:fast [prompt]\` - Quick prompt improvements with smart triage
+- \`/clavix:deep [prompt]\` - Comprehensive prompt analysis
+- \`/clavix:prd\` - Generate a PRD through guided questions
+- \`/clavix:start\` - Start conversational mode for iterative refinement
+- \`/clavix:summarize\` - Extract optimized prompt from conversation
+
+**When to use:**
+- **Fast mode**: Quick cleanup for simple prompts
+- **Deep mode**: Comprehensive analysis for complex requirements
+- **PRD mode**: Strategic planning with architecture and business impact
+
+For more information, run \`clavix --help\` in your terminal.
+<!-- CLAVIX:END -->
+`;
+    }
+    /**
+     * Create default CLAUDE.md content for Claude Code
+     */
+    static getDefaultClaudeContent() {
+        return `# Claude Code Instructions
+
+<!-- CLAVIX:START -->
+## Clavix Integration
+
+This project uses Clavix for prompt improvement and PRD generation. The following slash commands are available:
+
+### /clavix:fast [prompt]
+Quick prompt improvements with smart triage. Clavix will analyze your prompt and recommend deep analysis if needed. Perfect for making "shitty prompts good" quickly.
+
+### /clavix:deep [prompt]
+Comprehensive prompt analysis with alternative phrasings, edge cases, implementation examples, and potential issues. Use for complex requirements or when you want thorough exploration.
+
+### /clavix:prd
+Launch the PRD generation workflow. Clavix will guide you through strategic questions and generate both a comprehensive PRD and a quick-reference version optimized for AI consumption.
+
+### /clavix:start
+Enter conversational mode for iterative prompt development. Discuss your requirements naturally, and later use \`/clavix:summarize\` to extract an optimized prompt.
+
+### /clavix:summarize
+Analyze the current conversation and extract key requirements into a structured prompt and mini-PRD.
+
+**When to use which mode:**
+- **Fast mode** (\`/clavix:fast\`): Quick cleanup for simple prompts
+- **Deep mode** (\`/clavix:deep\`): Comprehensive analysis for complex requirements
+- **PRD mode** (\`/clavix:prd\`): Strategic planning with architecture and business impact
+
+**Pro tip**: Start complex features with \`/clavix:prd\` or \`/clavix:start\` to ensure clear requirements before implementation.
+<!-- CLAVIX:END -->
+`;
+    }
+}
+exports.DocInjector = DocInjector;
+DocInjector.DEFAULT_START_MARKER = '<!-- CLAVIX:START -->';
+DocInjector.DEFAULT_END_MARKER = '<!-- CLAVIX:END -->';
+//# sourceMappingURL=doc-injector.js.map

package/dist/core 2/git-manager.d.ts

@@ -0,0 +1,100 @@
+/**
+ * GitManager - Manages git auto-commit functionality for task implementation
+ *
+ * This class handles:
+ * - Checking git repository status
+ * - Creating commits based on user preferences
+ * - Generating commit messages
+ * - Handling commit strategies (per task, per phase, per N tasks)
+ */
+/**
+ * Git commit strategy options
+ */
+export type CommitStrategy = 'per-phase' | 'per-5-tasks' | 'per-task' | 'none';
+/**
+ * Options for creating a commit
+ */
+export interface CommitOptions {
+    tasks: string[];
+    phase?: string;
+    projectName?: string;
+}
+/**
+ * GitManager class
+ *
+ * Handles git operations for the implement command
+ */
+export declare class GitManager {
+    /**
+     * Check if current directory is a git repository
+     */
+    isGitRepository(): Promise<boolean>;
+    /**
+     * Check if there are uncommitted changes
+     */
+    hasUncommittedChanges(): Promise<boolean>;
+    /**
+     * Create a commit with the given tasks
+     */
+    createCommit(options: CommitOptions): Promise<boolean>;
+    /**
+     * Generate commit message from tasks
+     */
+    private generateCommitMessage;
+    /**
+     * Escape commit message for shell
+     */
+    private escapeCommitMessage;
+    /**
+     * Get the current branch name
+     */
+    getCurrentBranch(): Promise<string>;
+    /**
+     * Check if working directory is clean
+     */
+    isWorkingDirectoryClean(): Promise<boolean>;
+    /**
+     * Get short status for display
+     */
+    getStatus(): Promise<string>;
+    /**
+     * Validate git setup before implementing
+     */
+    validateGitSetup(): Promise<{
+        isRepo: boolean;
+        hasChanges: boolean;
+        currentBranch: string;
+    }>;
+}
+/**
+ * Helper class to track when to commit based on strategy
+ */
+export declare class CommitScheduler {
+    private strategy;
+    private completedTasksInPhase;
+    private completedTasksTotal;
+    private completedTasksSinceLastCommit;
+    private currentPhase;
+    constructor(strategy: CommitStrategy);
+    /**
+     * Mark a task as completed and check if commit should be made
+     */
+    taskCompleted(taskPhase: string): boolean;
+    /**
+     * Mark a phase as completed
+     */
+    phaseCompleted(): boolean;
+    /**
+     * Check if a commit should be made now
+     */
+    private shouldCommit;
+    /**
+     * Reset commit counter (after a commit is made)
+     */
+    resetCommitCounter(): void;
+    /**
+     * Get accumulated task count for commit message
+     */
+    getTaskCountSinceLastCommit(): number;
+}
+//# sourceMappingURL=git-manager.d.ts.map

package/dist/core 2/git-manager.js

@@ -0,0 +1,214 @@
+"use strict";
+/**
+ * GitManager - Manages git auto-commit functionality for task implementation
+ *
+ * This class handles:
+ * - Checking git repository status
+ * - Creating commits based on user preferences
+ * - Generating commit messages
+ * - Handling commit strategies (per task, per phase, per N tasks)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommitScheduler = exports.GitManager = void 0;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * GitManager class
+ *
+ * Handles git operations for the implement command
+ */
+class GitManager {
+    /**
+     * Check if current directory is a git repository
+     */
+    async isGitRepository() {
+        try {
+            await execAsync('git rev-parse --git-dir');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if there are uncommitted changes
+     */
+    async hasUncommittedChanges() {
+        try {
+            const { stdout } = await execAsync('git status --porcelain');
+            return stdout.trim().length > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Create a commit with the given tasks
+     */
+    async createCommit(options) {
+        try {
+            // Check for changes first
+            if (!(await this.hasUncommittedChanges())) {
+                return false; // No changes to commit
+            }
+            // Stage all changes
+            await execAsync('git add .');
+            // Generate commit message
+            const message = this.generateCommitMessage(options);
+            // Create commit
+            await execAsync(`git commit -m "${this.escapeCommitMessage(message)}"`);
+            return true;
+        }
+        catch (error) {
+            // If commit fails, log but don't throw
+            console.error('Git commit failed:', error);
+            return false;
+        }
+    }
+    /**
+     * Generate commit message from tasks
+     */
+    generateCommitMessage(options) {
+        const { tasks, phase, projectName } = options;
+        let message = '';
+        // Header
+        if (phase) {
+            message += `clavix: ${phase}\n\n`;
+        }
+        else if (tasks.length === 1) {
+            message += `clavix: ${tasks[0]}\n\n`;
+        }
+        else {
+            message += `clavix: implement ${tasks.length} tasks\n\n`;
+        }
+        // Task list
+        message += 'Completed tasks:\n';
+        tasks.forEach((task) => {
+            message += `- ${task}\n`;
+        });
+        // Footer
+        message += '\n';
+        if (projectName) {
+            message += `Project: ${projectName}\n`;
+        }
+        message += 'Generated by Clavix /clavix:implement';
+        return message;
+    }
+    /**
+     * Escape commit message for shell
+     */
+    escapeCommitMessage(message) {
+        return message.replace(/"/g, '\\"').replace(/\n/g, '\\n');
+    }
+    /**
+     * Get the current branch name
+     */
+    async getCurrentBranch() {
+        try {
+            const { stdout } = await execAsync('git rev-parse --abbrev-ref HEAD');
+            return stdout.trim();
+        }
+        catch {
+            return 'unknown';
+        }
+    }
+    /**
+     * Check if working directory is clean
+     */
+    async isWorkingDirectoryClean() {
+        return !(await this.hasUncommittedChanges());
+    }
+    /**
+     * Get short status for display
+     */
+    async getStatus() {
+        try {
+            const { stdout } = await execAsync('git status --short');
+            return stdout.trim();
+        }
+        catch {
+            return 'Unable to get git status';
+        }
+    }
+    /**
+     * Validate git setup before implementing
+     */
+    async validateGitSetup() {
+        const isRepo = await this.isGitRepository();
+        const hasChanges = await this.hasUncommittedChanges();
+        const currentBranch = isRepo ? await this.getCurrentBranch() : '';
+        return {
+            isRepo,
+            hasChanges,
+            currentBranch,
+        };
+    }
+}
+exports.GitManager = GitManager;
+/**
+ * Helper class to track when to commit based on strategy
+ */
+class CommitScheduler {
+    constructor(strategy) {
+        this.strategy = strategy;
+        this.completedTasksInPhase = 0;
+        this.completedTasksTotal = 0;
+        this.completedTasksSinceLastCommit = 0;
+        this.currentPhase = '';
+    }
+    /**
+     * Mark a task as completed and check if commit should be made
+     */
+    taskCompleted(taskPhase) {
+        this.completedTasksTotal++;
+        this.completedTasksSinceLastCommit++;
+        if (taskPhase !== this.currentPhase) {
+            this.completedTasksInPhase = 0;
+            this.currentPhase = taskPhase;
+        }
+        this.completedTasksInPhase++;
+        return this.shouldCommit();
+    }
+    /**
+     * Mark a phase as completed
+     */
+    phaseCompleted() {
+        // Reset phase counter
+        this.completedTasksInPhase = 0;
+        // If strategy is per-phase, we should commit
+        return this.strategy === 'per-phase';
+    }
+    /**
+     * Check if a commit should be made now
+     */
+    shouldCommit() {
+        switch (this.strategy) {
+            case 'per-task':
+                return true;
+            case 'per-5-tasks':
+                return this.completedTasksSinceLastCommit >= 5;
+            case 'per-phase':
+                // Will be handled by phaseCompleted()
+                return false;
+            case 'none':
+                return false;
+            default:
+                return false;
+        }
+    }
+    /**
+     * Reset commit counter (after a commit is made)
+     */
+    resetCommitCounter() {
+        this.completedTasksSinceLastCommit = 0;
+    }
+    /**
+     * Get accumulated task count for commit message
+     */
+    getTaskCountSinceLastCommit() {
+        return this.completedTasksSinceLastCommit;
+    }
+}
+exports.CommitScheduler = CommitScheduler;
+//# sourceMappingURL=git-manager.js.map