tarsk 0.4.4 → 0.4.6

package/dist/features/threads/threads.routes.js

@@ -1,230 +0,0 @@
-/**
- * Thread routes for the REST API
- *
- * Handles all thread-related operations:
- * - POST /api/threads - Create a new thread
- * - GET /api/threads?projectId=xxx - List threads for a project
- * - DELETE /api/threads/:id - Delete a thread
- */
-import { Hono } from "hono";
-import { handleCreateThread } from "./threads-create.route.js";
-import { handleListThreads } from "./threads-list.route.js";
-import { handleDeleteThread } from "./threads-delete.route.js";
-import { handleSelectThread } from "./threads-select.route.js";
-import { handleGetThread } from "./threads-get.route.js";
-import { handleGetThreadMessages } from "./threads-messages.route.js";
-import { handleListThreadFiles } from "./threads-files.route.js";
-import { handleUpdateThread } from "./threads-update.route.js";
-import { handleOpenThread } from "./threads-open.route.js";
-import { handleGetConversationFolderPath } from "./threads-conversation-folder-path.route.js";
-import { handleFixComments } from "./threads-fix-comments.route.js";
-import { handleGetThreadAIFiles, handleGetThreadAIFile, handleSaveThreadAIFile, handleDeleteThreadAIFile, handleCreateThreadSkill, handleCreateThreadAgent, } from "./threads-ai-files.route.js";
-/**
- * Creates thread routes
- * @param threadManager - The ThreadManager instance
- * @param gitManager - The GitManager instance
- * @returns Hono router with thread routes
- */
-export function createThreadRoutes(threadManager, gitManager, conversationManager) {
-    const router = new Hono();
-    /**
-     * POST /api/threads
-     * Create a new thread for a project
-     *
-     * Request body:
-     * {
-     *   "projectId": "uuid",
-     *   "title": "Optional thread title"
-     * }
-     *
-     * Response: Newline-delimited JSON stream of ThreadEvent objects
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     * - 8.3 - WHEN creating a Thread, THE App SHALL send a POST request with the Project identifier to the CLI
-     * - 8.4 - THE CLI SHALL support streaming responses to the client
-     */
-    router.post("/", async (c) => {
-        return handleCreateThread(c, threadManager, gitManager);
-    });
-    /**
-     * GET /api/threads?projectId=xxx
-     * List all threads for a specific project
-     *
-     * Query parameters:
-     * - projectId (required): The project ID to filter threads
-     *
-     * Response:
-     * [
-     *   {
-     *     "id": "uuid",
-     *     "projectId": "uuid",
-     *     "title": "Thread title",
-     *     "path": "/path/to/thread",
-     *     "currentBranch": "branch-name",
-     *     "createdAt": "2024-01-01T00:00:00Z"
-     *   }
-     * ]
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     */
-    router.get("/", async (c) => {
-        const { getDatabase } = await import("../../database/database.js");
-        const db = await getDatabase();
-        return handleListThreads(c, threadManager, db);
-    });
-    /**
-     * DELETE /api/threads/:id
-     * Delete a thread
-     *
-     * Response:
-     * {
-     *   "success": true,
-     *   "message": "Thread deleted successfully"
-     * }
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     * - 8.4 - WHEN deleting a Thread, THE App SHALL send a DELETE request with the Thread identifier to the CLI
-     */
-    router.delete("/:id", async (c) => {
-        return handleDeleteThread(c, threadManager);
-    });
-    /**
-     * POST /api/threads/:id/select
-     * Select a thread as the active thread
-     *
-     * Response:
-     * {
-     *   "success": true,
-     *   "message": "Thread selected successfully",
-     *   "threadId": "uuid"
-     * }
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     */
-    router.post("/:id/select", async (c) => {
-        return handleSelectThread(c, threadManager);
-    });
-    /**
-     * GET /api/threads/:id
-     * Get details of a specific thread
-     *
-     * Response:
-     * {
-     *   "id": "uuid",
-     *   "projectId": "uuid",
-     *   "title": "Thread title",
-     *   "path": "/path/to/thread",
-     *   "currentBranch": "branch-name",
-     *   "createdAt": "2024-01-01T00:00:00Z",
-     *   "currentConversationId": "uuid",
-     *   "status": "active"
-     * }
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     */
-    router.get("/:id", async (c) => {
-        return handleGetThread(c, threadManager);
-    });
-    /**
-     * GET /api/threads/:id/messages
-     * Get chat history for a thread
-     */
-    router.get("/:id/messages", async (c) => {
-        return handleGetThreadMessages(c, threadManager, conversationManager);
-    });
-    /**
-     * GET /api/threads/:id/files
-     * List all files in a thread's directory
-     */
-    router.get("/:id/files", async (c) => {
-        return handleListThreadFiles(c, threadManager);
-    });
-    /**
-     * PATCH /api/threads/:id
-     * Update thread metadata
-     */
-    router.patch("/:id", async (c) => {
-        return handleUpdateThread(c, threadManager);
-    });
-    /**
-     * POST /api/threads/:id/open
-     * Open a thread in the specified program
-     *
-     * Request body:
-     * {
-     *   "program": "VS Code" | "Cursor" | "Windsurf" | "Xcode" | "Android Studio" | "Kiro"
-     * }
-     *
-     * Response:
-     * {
-     *   "success": true,
-     *   "message": "Thread opened in VS Code"
-     * }
-     */
-    router.post("/:id/open", async (c) => {
-        return handleOpenThread(c, threadManager);
-    });
-    /**
-     * GET /api/threads/:id/conversation-folder-path
-     * Return the absolute path to the folder containing the conversation history JSON for this thread.
-     */
-    router.get("/:id/conversation-folder-path", async (c) => {
-        return handleGetConversationFolderPath(c);
-    });
-    /**
-     * POST /api/threads/:id/fix-comments
-     * Convert diff review comments into todos and return the prompt to send to the agent.
-     */
-    router.post("/:id/fix-comments", async (c) => {
-        return handleFixComments(c, threadManager);
-    });
-    /**
-     * GET /api/threads/:id/ai-files
-     * List AI-related files (skills, rules, commands, markdown files) from the thread's path
-     */
-    router.get("/:id/ai-files", async (c) => {
-        return handleGetThreadAIFiles(c, threadManager);
-    });
-    /**
-     * GET /api/threads/:id/ai-file?path=...
-     * Read the content of an AI-related file from the thread's path
-     */
-    router.get("/:id/ai-file", async (c) => {
-        return handleGetThreadAIFile(c, threadManager);
-    });
-    /**
-     * PUT /api/threads/:id/ai-file
-     * Save the content of an AI-related file in the thread's path
-     */
-    router.put("/:id/ai-file", async (c) => {
-        return handleSaveThreadAIFile(c, threadManager);
-    });
-    /**
-     * DELETE /api/threads/:id/ai-file?path=...
-     * Delete a file or folder in the thread's path
-     */
-    router.delete("/:id/ai-file", async (c) => {
-        return handleDeleteThreadAIFile(c, threadManager);
-    });
-    /**
-     * POST /api/threads/:id/ai-files/skill
-     * Create a new skill in the thread's path
-     */
-    router.post("/:id/ai-files/skill", async (c) => {
-        return handleCreateThreadSkill(c, threadManager);
-    });
-    /**
-     * POST /api/threads/:id/ai-files/agent
-     * Create a new agent in the thread's path
-     */
-    router.post("/:id/ai-files/agent", async (c) => {
-        return handleCreateThreadAgent(c, threadManager);
-    });
-    return router;
-}
-//# sourceMappingURL=threads.routes.js.map

package/dist/features/todos/todos.database.d.ts

@@ -1,14 +0,0 @@
-import type { Database } from "../../database/database.types.js";
-export interface TodoRecord {
-    id: string;
-    threadId: string;
-    description: string;
-    status: string;
-    assignedTo: string;
-    createdAt: string;
-    updatedAt: string;
-}
-export declare function fetchAllTodos(db: Database, threadId: string): Promise<TodoRecord[]>;
-export declare function addTodos(threadId: string, descriptions: string[], assignedTo?: string): Promise<TodoRecord[]>;
-export declare function clearTodos(threadId: string): Promise<void>;
-//# sourceMappingURL=todos.database.d.ts.map

package/dist/features/todos/todos.database.js

@@ -1,31 +0,0 @@
-import { randomUUID } from "crypto";
-import { getDatabase } from "../../database/database.js";
-export async function fetchAllTodos(db, threadId) {
-    const result = await db.execute({
-        sql: `SELECT id, threadId, description, status, assignedTo, createdAt, updatedAt
-		      FROM todos WHERE threadId = ? ORDER BY createdAt ASC`,
-        args: [threadId],
-    });
-    return result.rows;
-}
-export async function addTodos(threadId, descriptions, assignedTo = "agent") {
-    const db = await getDatabase();
-    const now = new Date().toISOString();
-    for (const desc of descriptions) {
-        const id = randomUUID();
-        await db.execute({
-            sql: `INSERT INTO todos (id, threadId, description, status, assignedTo, createdAt, updatedAt)
-			      VALUES (?, ?, ?, 'pending', ?, ?, ?)`,
-            args: [id, threadId, desc.trim(), assignedTo, now, now],
-        });
-    }
-    return fetchAllTodos(db, threadId);
-}
-export async function clearTodos(threadId) {
-    const db = await getDatabase();
-    await db.execute({
-        sql: "DELETE FROM todos WHERE threadId = ?",
-        args: [threadId],
-    });
-}
-//# sourceMappingURL=todos.database.js.map

package/dist/features/updates/updates.routes.d.ts

@@ -1,13 +0,0 @@
-import { Hono } from "hono";
-export interface UpdateFunctions {
-    checkForUpdate: () => Promise<{
-        updateAvailable: boolean;
-    } | null>;
-    downloadUpdate: () => Promise<void>;
-    applyUpdate: () => Promise<void>;
-    getUpdateInfo: () => {
-        updateReady?: boolean;
-    } | null;
-}
-export declare function createUpdateRoutes(updater?: UpdateFunctions): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-//# sourceMappingURL=updates.routes.d.ts.map

package/dist/features/updates/updates.routes.js

@@ -1,40 +0,0 @@
-import { Hono } from "hono";
-export function createUpdateRoutes(updater) {
-    const app = new Hono();
-    app.get("/check", async (c) => {
-        if (!updater) {
-            return c.json({ updateAvailable: false, supported: false });
-        }
-        try {
-            const result = await updater.checkForUpdate();
-            return c.json({
-                updateAvailable: result?.updateAvailable ?? false,
-                supported: true,
-            });
-        }
-        catch (error) {
-            console.error("Failed to check for update:", error);
-            return c.json({ updateAvailable: false, supported: true, error: "Check failed" });
-        }
-    });
-    app.post("/apply", async (c) => {
-        if (!updater) {
-            return c.json({ error: "Updates not supported in this environment" }, 400);
-        }
-        try {
-            await updater.downloadUpdate();
-            const info = updater.getUpdateInfo();
-            if (info?.updateReady) {
-                await updater.applyUpdate();
-                return c.json({ success: true, message: "Update applied, restarting..." });
-            }
-            return c.json({ success: false, message: "Update downloaded but not ready to apply" });
-        }
-        catch (error) {
-            console.error("Failed to apply update:", error);
-            return c.json({ error: "Failed to apply update" }, 500);
-        }
-    });
-    return app;
-}
-//# sourceMappingURL=updates.routes.js.map

package/dist/index.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=index.d.ts.map

package/dist/project-analyzer.d.ts

@@ -1,26 +0,0 @@
-interface ProjectInfo {
-    framework?: string;
-    frameworkVersion?: string;
-    buildTool?: string;
-    testingLibraries?: string[];
-    uiLibraries?: string[];
-    projectType?: string;
-    packageManager?: string;
-    description: string;
-}
-export declare class ProjectAnalyzer {
-    private projectPath;
-    constructor(projectPath?: string);
-    analyze(): string;
-    getProjectInfo(): ProjectInfo;
-    private detectFramework;
-    private detectBuildTool;
-    private detectTestingLibraries;
-    private detectUILibraries;
-    private detectProjectType;
-    private detectPackageManager;
-    private generateDescription;
-}
-export declare function analyzeProject(projectPath?: string): string;
-export {};
-//# sourceMappingURL=project-analyzer.d.ts.map

package/dist/project-analyzer.js

@@ -1,307 +0,0 @@
-import { readFileSync, existsSync } from "fs";
-import { join } from "path";
-export class ProjectAnalyzer {
-    projectPath;
-    constructor(projectPath = process.cwd()) {
-        this.projectPath = projectPath;
-    }
-    analyze() {
-        const info = this.getProjectInfo();
-        return this.generateDescription(info);
-    }
-    getProjectInfo() {
-        const packageJsonPath = join(this.projectPath, "package.json");
-        const info = { description: "" };
-        if (existsSync(packageJsonPath)) {
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-            const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
-            // Detect framework
-            this.detectFramework(allDeps, info);
-            // Detect build tool
-            this.detectBuildTool(packageJson.scripts, allDeps, info);
-            // Detect testing libraries
-            this.detectTestingLibraries(allDeps, info);
-            // Detect UI libraries
-            this.detectUILibraries(allDeps, info);
-        }
-        // Detect project type from files
-        this.detectProjectType(info);
-        // Detect package manager
-        this.detectPackageManager(info);
-        return info;
-    }
-    detectFramework(deps, info) {
-        // React
-        if (deps.react) {
-            info.framework = "React";
-            info.frameworkVersion = deps.react.replace(/^[\^~]/, "");
-        }
-        // Vue
-        else if (deps.vue) {
-            info.framework = "Vue";
-            info.frameworkVersion = deps.vue.replace(/^[\^~]/, "");
-        }
-        // Angular
-        else if (deps["@angular/core"]) {
-            info.framework = "Angular";
-            info.frameworkVersion = deps["@angular/core"].replace(/^[\^~]/, "");
-        }
-        // Svelte
-        else if (deps.svelte) {
-            info.framework = "Svelte";
-            info.frameworkVersion = deps.svelte.replace(/^[\^~]/, "");
-        }
-        // Solid
-        else if (deps["solid-js"]) {
-            info.framework = "Solid";
-            info.frameworkVersion = deps["solid-js"].replace(/^[\^~]/, "");
-        }
-        // Next.js
-        else if (deps.next) {
-            info.framework = "Next.js";
-            info.frameworkVersion = deps.next.replace(/^[\^~]/, "");
-        }
-        // Nuxt
-        else if (deps.nuxt) {
-            info.framework = "Nuxt";
-            info.frameworkVersion = deps.nuxt.replace(/^[\^~]/, "");
-        }
-        // Astro
-        else if (deps.astro) {
-            info.framework = "Astro";
-            info.frameworkVersion = deps.astro.replace(/^[\^~]/, "");
-        }
-    }
-    detectBuildTool(_scripts = {}, deps, info) {
-        // Vite
-        if (deps.vite ||
-            existsSync(join(this.projectPath, "vite.config.js")) ||
-            existsSync(join(this.projectPath, "vite.config.ts"))) {
-            info.buildTool = "Vite";
-            return;
-        }
-        // Webpack
-        if (deps.webpack || existsSync(join(this.projectPath, "webpack.config.js"))) {
-            info.buildTool = "Webpack";
-            return;
-        }
-        // Rollup
-        if (deps.rollup || existsSync(join(this.projectPath, "rollup.config.js"))) {
-            info.buildTool = "Rollup";
-            return;
-        }
-        // Parcel
-        if (deps.parcel) {
-            info.buildTool = "Parcel";
-            return;
-        }
-        // esbuild
-        if (deps.esbuild) {
-            info.buildTool = "esbuild";
-            return;
-        }
-        // Turbopack
-        if (deps.turbo) {
-            info.buildTool = "Turbopack";
-            return;
-        }
-    }
-    detectTestingLibraries(deps, info) {
-        const testingLibs = [];
-        // Testing frameworks
-        if (deps.jest)
-            testingLibs.push("Jest");
-        if (deps.vitest)
-            testingLibs.push("Vitest");
-        if (deps.mocha)
-            testingLibs.push("Mocha");
-        if (deps.jasmine)
-            testingLibs.push("Jasmine");
-        if (deps["@jest/globals"])
-            testingLibs.push("Jest");
-        // Testing utilities
-        if (deps["@testing-library/react"])
-            testingLibs.push("React Testing Library");
-        if (deps["@testing-library/vue"])
-            testingLibs.push("Vue Testing Library");
-        if (deps["@testing-library/jest-dom"])
-            testingLibs.push("Jest DOM");
-        if (deps.cypress)
-            testingLibs.push("Cypress");
-        if (deps.playwright)
-            testingLibs.push("Playwright");
-        if (deps["@playwright/test"])
-            testingLibs.push("Playwright");
-        if (deps.puppeteer)
-            testingLibs.push("Puppeteer");
-        // Remove duplicates and filter out empty strings
-        info.testingLibraries = [...new Set(testingLibs)].filter(Boolean);
-    }
-    detectUILibraries(deps, info) {
-        const uiLibs = [];
-        // UI component libraries
-        if (deps["@mui/material"])
-            uiLibs.push("Material-UI");
-        if (deps["@chakra-ui/react"])
-            uiLibs.push("Chakra UI");
-        if (deps["@radix-ui/react"])
-            uiLibs.push("Radix UI");
-        if (deps["@headlessui/react"])
-            uiLibs.push("Headless UI");
-        if (deps.antd)
-            uiLibs.push("Ant Design");
-        if (deps["semantic-ui-css"])
-            uiLibs.push("Semantic UI");
-        if (deps.bootstrap)
-            uiLibs.push("Bootstrap");
-        if (deps["react-bootstrap"])
-            uiLibs.push("React Bootstrap");
-        if (deps.tailwindcss)
-            uiLibs.push("Tailwind CSS");
-        if (deps["styled-components"])
-            uiLibs.push("Styled Components");
-        if (deps.emotion)
-            uiLibs.push("Emotion");
-        if (deps["@mantine/core"])
-            uiLibs.push("Mantine");
-        // Remove duplicates and filter out empty strings
-        info.uiLibraries = [...new Set(uiLibs)].filter(Boolean);
-    }
-    detectProjectType(info) {
-        // Xcode project
-        if (existsSync(join(this.projectPath, ".xcodeproj")) ||
-            existsSync(join(this.projectPath, ".xcworkspace")) ||
-            existsSync(join(this.projectPath, "project.pbxproj"))) {
-            info.projectType = "Xcode";
-        }
-        // Android Studio project
-        else if (existsSync(join(this.projectPath, "build.gradle")) ||
-            existsSync(join(this.projectPath, "build.gradle.kts")) ||
-            existsSync(join(this.projectPath, "app/build.gradle")) ||
-            existsSync(join(this.projectPath, "settings.gradle"))) {
-            info.projectType = "Android Studio";
-        }
-        // Flutter project
-        else if (existsSync(join(this.projectPath, "pubspec.yaml"))) {
-            info.projectType = "Flutter";
-        }
-        // Go project
-        else if (existsSync(join(this.projectPath, "go.mod"))) {
-            info.projectType = "Go";
-        }
-        // Rust project
-        else if (existsSync(join(this.projectPath, "Cargo.toml"))) {
-            info.projectType = "Rust";
-        }
-        // Python project
-        else if (existsSync(join(this.projectPath, "requirements.txt")) ||
-            existsSync(join(this.projectPath, "pyproject.toml")) ||
-            existsSync(join(this.projectPath, "setup.py"))) {
-            info.projectType = "Python";
-        }
-        // Ruby project
-        else if (existsSync(join(this.projectPath, "Gemfile"))) {
-            info.projectType = "Ruby";
-        }
-        // PHP project
-        else if (existsSync(join(this.projectPath, "composer.json"))) {
-            info.projectType = "PHP";
-        }
-        // Java project
-        else if (existsSync(join(this.projectPath, "pom.xml")) ||
-            existsSync(join(this.projectPath, "build.xml"))) {
-            info.projectType = "Java";
-        }
-        // C#/.NET project
-        else if (existsSync(join(this.projectPath, ".csproj")) ||
-            existsSync(join(this.projectPath, "project.json"))) {
-            info.projectType = ".NET";
-        }
-    }
-    detectPackageManager(info) {
-        // Check for lock files in order of specificity
-        if (existsSync(join(this.projectPath, "bun.lockb"))) {
-            info.packageManager = "Bun";
-        }
-        else if (existsSync(join(this.projectPath, "bun.lock"))) {
-            info.packageManager = "Bun";
-        }
-        else if (existsSync(join(this.projectPath, "pnpm-lock.yaml"))) {
-            info.packageManager = "pnpm";
-        }
-        else if (existsSync(join(this.projectPath, "yarn.lock"))) {
-            info.packageManager = "Yarn";
-        }
-        else if (existsSync(join(this.projectPath, "package-lock.json"))) {
-            info.packageManager = "npm";
-        }
-        else if (existsSync(join(this.projectPath, "npm-shrinkwrap.json"))) {
-            info.packageManager = "npm";
-        }
-    }
-    generateDescription(info) {
-        const parts = [];
-        // Start with project type if it's a non-JS project
-        if (info.projectType && !info.framework) {
-            parts.push(`This is a ${info.projectType} project`);
-            return parts.join(". ") + ".";
-        }
-        // Framework description
-        if (info.framework) {
-            let frameworkDesc = `This is a ${info.framework}`;
-            if (info.frameworkVersion) {
-                frameworkDesc += ` ${info.frameworkVersion}`;
-            }
-            parts.push(frameworkDesc);
-        }
-        // Build tool description
-        if (info.buildTool) {
-            parts.push(`built with ${info.buildTool}`);
-        }
-        // Package manager description
-        if (info.packageManager) {
-            parts.push(`using ${info.packageManager}`);
-        }
-        // Testing libraries
-        if (info.testingLibraries && info.testingLibraries.length > 0) {
-            if (info.testingLibraries.length === 1) {
-                parts.push(`using ${info.testingLibraries[0]} for testing`);
-            }
-            else {
-                parts.push(`using ${info.testingLibraries.slice(0, -1).join(", ")} and ${info.testingLibraries[info.testingLibraries.length - 1]} for testing`);
-            }
-        }
-        // UI libraries
-        if (info.uiLibraries && info.uiLibraries.length > 0) {
-            if (info.uiLibraries.length === 1) {
-                parts.push(`with ${info.uiLibraries[0]}`);
-            }
-            else {
-                parts.push(`with ${info.uiLibraries.slice(0, -1).join(", ")} and ${info.uiLibraries[info.uiLibraries.length - 1]}`);
-            }
-        }
-        // If no framework detected but we have testing libraries or build tools
-        if (!info.framework && !info.projectType && parts.length === 0) {
-            if (info.buildTool) {
-                parts.push(`This is a project built with ${info.buildTool}`);
-            }
-            else if (info.testingLibraries && info.testingLibraries.length > 0) {
-                parts.push(`This is a project using ${info.testingLibraries.join(", ")} for testing`);
-            }
-            else {
-                parts.push("This is a JavaScript/TypeScript project");
-            }
-        }
-        // Project type for JS projects
-        if (info.projectType) {
-            parts.push(`(${info.projectType} project)`);
-        }
-        return parts.join(", ") + ".";
-    }
-}
-// Convenience function for quick analysis
-export function analyzeProject(projectPath) {
-    const analyzer = new ProjectAnalyzer(projectPath);
-    return analyzer.analyze();
-}
-//# sourceMappingURL=project-analyzer.js.map

package/dist/server.d.ts

@@ -1,12 +0,0 @@
-import { type UpdateFunctions } from "./features/updates/updates.routes.js";
-export type StartServerOptions = {
-    isDebug: boolean;
-    openBrowser: boolean;
-    publicDir?: string;
-    updater?: UpdateFunctions;
-};
-export declare function startTarskServer(options: StartServerOptions): Promise<{
-    url: string;
-    port: number;
-}>;
-//# sourceMappingURL=server.d.ts.map