commandmate 0.1.0 → 0.1.6

package/dist/server/src/lib/cli-tools/manager.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * CLI Tool Manager
+ * Singleton class to manage multiple CLI tools (Claude, Codex, Gemini)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLIToolManager = void 0;
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+const gemini_1 = require("./gemini");
+/**
+ * CLI Tool Manager (Singleton)
+ * Provides centralized access to all CLI tools
+ */
+class CLIToolManager {
+    static instance;
+    tools;
+    /**
+     * Private constructor for Singleton pattern
+     */
+    constructor() {
+        this.tools = new Map();
+        // Initialize all tools
+        this.tools.set('claude', new claude_1.ClaudeTool());
+        this.tools.set('codex', new codex_1.CodexTool());
+        this.tools.set('gemini', new gemini_1.GeminiTool());
+    }
+    /**
+     * Get singleton instance
+     *
+     * @returns CLIToolManager instance
+     */
+    static getInstance() {
+        if (!CLIToolManager.instance) {
+            CLIToolManager.instance = new CLIToolManager();
+        }
+        return CLIToolManager.instance;
+    }
+    /**
+     * Get a specific CLI tool by type
+     *
+     * @param type - CLI tool type
+     * @returns CLI tool instance
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const claude = manager.getTool('claude');
+     * await claude.startSession('my-worktree', '/path/to/worktree');
+     * ```
+     */
+    getTool(type) {
+        const tool = this.tools.get(type);
+        if (!tool) {
+            throw new Error(`CLI tool '${type}' not found`);
+        }
+        return tool;
+    }
+    /**
+     * Get all CLI tools
+     *
+     * @returns Array of all CLI tool instances
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const allTools = manager.getAllTools();
+     * console.log(allTools.map(t => t.name)); // ['Claude Code', 'Codex CLI', 'Gemini CLI']
+     * ```
+     */
+    getAllTools() {
+        return Array.from(this.tools.values());
+    }
+    /**
+     * Get information about a specific tool including installation status
+     *
+     * @param type - CLI tool type
+     * @returns Tool information with installation status
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const info = await manager.getToolInfo('claude');
+     * if (info.installed) {
+     *   console.log(`${info.name} is installed`);
+     * }
+     * ```
+     */
+    async getToolInfo(type) {
+        const tool = this.getTool(type);
+        const installed = await tool.isInstalled();
+        return {
+            id: tool.id,
+            name: tool.name,
+            command: tool.command,
+            installed,
+        };
+    }
+    /**
+     * Get information about all tools including installation status
+     *
+     * @returns Array of tool information for all tools
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const allInfo = await manager.getAllToolsInfo();
+     * allInfo.forEach(info => {
+     *   console.log(`${info.name}: ${info.installed ? 'installed' : 'not installed'}`);
+     * });
+     * ```
+     */
+    async getAllToolsInfo() {
+        const tools = this.getAllTools();
+        const infoPromises = tools.map(async (tool) => {
+            const installed = await tool.isInstalled();
+            return {
+                id: tool.id,
+                name: tool.name,
+                command: tool.command,
+                installed,
+            };
+        });
+        return Promise.all(infoPromises);
+    }
+    /**
+     * Get only installed tools
+     *
+     * @returns Array of tool information for installed tools only
+     *
+     * @example
+     * ```typescript
+     * const manager = CLIToolManager.getInstance();
+     * const installed = await manager.getInstalledTools();
+     * console.log(`${installed.length} tools installed`);
+     * ```
+     */
+    async getInstalledTools() {
+        const allInfo = await this.getAllToolsInfo();
+        return allInfo.filter(info => info.installed);
+    }
+}
+exports.CLIToolManager = CLIToolManager;

package/dist/server/src/lib/cli-tools/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions and interfaces for CLI tools
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/lib/conversation-logger.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Conversation logging helper
+ * Ensures Claude responses are paired with the latest user input before writing markdown logs
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recordClaudeConversation = recordClaudeConversation;
+const db_1 = require("./db");
+const log_manager_1 = require("./log-manager");
+/**
+ * Persist the latest Claude response alongside the most recent user prompt.
+ * Errors are swallowed so the calling API route can continue responding.
+ */
+async function recordClaudeConversation(db, worktreeId, claudeResponse, cliToolId = 'claude') {
+    const lastUserMessage = (0, db_1.getLastUserMessage)(db, worktreeId);
+    if (!lastUserMessage) {
+        return;
+    }
+    try {
+        await (0, log_manager_1.createLog)(worktreeId, lastUserMessage.content, claudeResponse, cliToolId);
+    }
+    catch (error) {
+        console.error('[recordClaudeConversation] Failed to create log file:', error);
+    }
+}

package/dist/server/src/lib/db-instance.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Database instance singleton
+ * Provides a shared database connection for API routes
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbInstance = getDbInstance;
+exports.closeDbInstance = closeDbInstance;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const path_1 = __importDefault(require("path"));
+const db_migrations_1 = require("./db-migrations");
+let dbInstance = null;
+/**
+ * Get or create the database instance
+ *
+ * @returns Singleton database instance
+ *
+ * @example
+ * ```typescript
+ * const db = getDbInstance();
+ * const worktrees = getWorktrees(db);
+ * ```
+ */
+function getDbInstance() {
+    if (!dbInstance) {
+        const dbPath = process.env.DATABASE_PATH || path_1.default.join(process.cwd(), 'data', 'db.sqlite');
+        // Ensure the database directory exists
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const fs = require('fs');
+        const dir = path_1.default.dirname(dbPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        dbInstance = new better_sqlite3_1.default(dbPath);
+        (0, db_migrations_1.runMigrations)(dbInstance);
+    }
+    return dbInstance;
+}
+/**
+ * Close the database connection
+ * Mainly used for testing cleanup
+ */
+function closeDbInstance() {
+    if (dbInstance) {
+        dbInstance.close();
+        dbInstance = null;
+    }
+}