tarsk 0.2.6 → 0.3.0

package/README.md

@@ -1,9 +1,3 @@
 # Tarsk
 
-Tarsk is an AI tool available at https://tarsk.io.
-
-Run `npx tarsk` to launch it.
-
-## Details
-
-This will serve at `http://localhost:4021`
+Run `npx tarsk` to start the Tarsk App.

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,40 +1,100 @@
 #!/usr/bin/env node
-import { serve } from "@hono/node-server";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import open from 'open';
-import { api_prompt } from "./api/prompt.js";
-import { api_delete_tool, api_get_tool, api_get_tools, api_run_tool, api_save_tool, } from "./api/tools.js";
-import { api_get_settings, api_save_settings } from "./api/settings.js";
-import { api_get_models } from "./api/models.js";
+import { Hono } from 'hono';
+import { cors } from 'hono/cors';
+import { serve } from '@hono/node-server';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { exec } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { ProjectManagerImpl } from './managers/project-manager.js';
+import { ThreadManagerImpl } from './managers/thread-manager.js';
+import { GitManagerImpl } from './managers/git-manager.js';
+import { MetadataManager } from './managers/metadata-manager.js';
+import { NeovateExecutorImpl } from './managers/neovate-executor.js';
+import { ConversationManagerImpl } from './managers/conversation-manager.js';
+import { ProcessingStateManagerImpl } from './managers/processing-state-manager.js';
+import { createProjectRoutes } from './routes/projects.js';
+import { createThreadRoutes } from './routes/threads.js';
+import { createChatRoutes } from './routes/chat.js';
+import { createProviderRoutes } from './routes/providers.js';
+import { createModelRoutes } from './routes/models.js';
+import { createGitRoutes } from './routes/git.js';
+import { AVAILABLE_PROGRAMS } from './types/models.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
 const app = new Hono();
-app.use("/*", cors({
-    origin: (origin, c) => {
-        return (origin.startsWith("http://localhost") ||
-            origin.startsWith('https://tarsk.io')) ? origin : "x";
-    },
+// Configure CORS middleware
+app.use('/*', cors());
+// Initialize managers
+const rootFolder = process.env.ROOT_FOLDER || process.cwd();
+const metadataManager = new MetadataManager(rootFolder);
+const gitManager = new GitManagerImpl();
+const projectManager = new ProjectManagerImpl(rootFolder, metadataManager, gitManager);
+const threadManager = new ThreadManagerImpl(metadataManager, gitManager);
+const conversationManager = new ConversationManagerImpl(rootFolder);
+const neovateExecutor = new NeovateExecutorImpl(metadataManager);
+const processingStateManager = new ProcessingStateManagerImpl();
+// Initialize metadata storage
+await metadataManager.initialize();
+// Health check endpoint
+app.get('/health', (c) => {
+    return c.json({
+        status: 'ok',
+        timestamp: new Date().toISOString(),
+        service: 'project-threads-manager-cli'
+    });
+});
+// Available programs endpoint
+app.get('/api/programs', (c) => {
+    return c.json({
+        programs: AVAILABLE_PROGRAMS
+    });
+});
+// Processing threads endpoint - returns list of thread IDs currently processing
+app.get('/api/threads/processing', (c) => {
+    return c.json({
+        processingThreadIds: processingStateManager.getProcessingThreadIds()
+    });
+});
+// Register API routes
+app.route('/api/projects', createProjectRoutes(projectManager, threadManager));
+app.route('/api/threads', createThreadRoutes(threadManager, gitManager, conversationManager));
+app.route('/api/chat', createChatRoutes(threadManager, neovateExecutor, conversationManager, processingStateManager));
+app.route('/api/providers', createProviderRoutes(metadataManager));
+app.route('/api/models', createModelRoutes(metadataManager));
+app.route('/api/git', createGitRoutes(metadataManager));
+// Serve static files from the 'public' directory
+// In production, this will be the built frontend app
+const publicDir = path.join(__dirname, 'public');
+app.use('/*', serveStatic({
+    root: path.relative(process.cwd(), publicDir)
 }));
-app.get("/", (c) => {
-    return c.text("Tarsk Started.");
+// Fallback to index.html for SPA routing
+app.get('*', serveStatic({
+    path: path.relative(process.cwd(), path.join(publicDir, 'index.html'))
+}));
+// Error handling middleware for unmatched routes
+app.all('*', (c) => {
+    const errorResponse = {
+        error: {
+            code: 'NOT_FOUND',
+            message: `Route not found: ${c.req.method} ${c.req.path}`,
+            timestamp: new Date().toISOString()
+        }
+    };
+    return c.json(errorResponse, 404);
 });
-app.post("/prompt", async (c) => await api_prompt(c));
-app.post("/tools", async (c) => await api_save_tool(c));
-app.get("/tools", async (c) => await api_get_tools(c));
-app.post("/run/tool", async (c) => await api_run_tool(c));
-app.get("/tools/:tool", async (c) => await api_get_tool(c));
-app.delete("/tools/:tool", async (c) => await api_delete_tool(c));
-app.get("/settings", async (c) => await api_get_settings(c));
-app.post("/settings", async (c) => await api_save_settings(c));
-app.get("/models", async (c) => await api_get_models(c));
+const port = process.env.PORT ? parseInt(process.env.PORT) : 641;
+const url = `http://localhost:${port}`;
+console.log(`Tarsk started on ${url}`);
 serve({
     fetch: app.fetch,
-    port: 4021,
-}, (info) => {
-    if (process.env._ && process.env._.endsWith('tsx')) {
-        console.log(`Tarsk is running in dev mode on http://localhost:${info.port}`);
-    }
-    else {
-        console.log(`Tarsk is running. Visit https://tarsk.io`);
-        open("https://tarsk.io");
+    port
+}, () => {
+    // Open browser in production/cli mode
+    if (process.env.NODE_ENV !== 'development') {
+        const start = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+        exec(`${start} ${url}`);
     }
 });
+//# sourceMappingURL=index.js.map

package/dist/lib/response-builder.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Response builder utility for centralizing API response formatting
+ *
+ * Provides factory methods for creating consistent error and success responses
+ * across all route handlers. This eliminates duplication of response formatting
+ * logic and ensures consistent error handling throughout the API.
+ */
+import type { ErrorResponse } from '../types/models.js';
+/**
+ * Factory for building consistent API responses
+ */
+export declare class ResponseBuilder {
+    /**
+     * Creates an error response with standard error structure
+     *
+     * @param code - Machine-readable error code (e.g., 'INVALID_REQUEST', 'NOT_FOUND')
+     * @param message - Human-readable error message
+     * @param statusCode - HTTP status code to return
+     * @param details - Optional additional error context
+     * @returns Object containing both response data and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'Project ID is required', 400);
+     * return c.json(response, statusCode as any);
+     * ```
+     */
+    static error(code: string, message: string, statusCode: number, details?: unknown): {
+        response: ErrorResponse;
+        statusCode: number;
+    };
+    /**
+     * Creates a success response with optional data
+     *
+     * @param data - Response payload data
+     * @param statusCode - HTTP status code (default: 200)
+     * @returns Object containing both response data and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * const { response, statusCode } = ResponseBuilder.success(projects, 200);
+     * return c.json(response, statusCode as any);
+     * ```
+     */
+    static success(data: unknown, statusCode?: number): {
+        response: unknown;
+        statusCode: number;
+    };
+}
+//# sourceMappingURL=response-builder.d.ts.map

package/dist/lib/response-builder.js

@@ -0,0 +1,56 @@
+/**
+ * Response builder utility for centralizing API response formatting
+ *
+ * Provides factory methods for creating consistent error and success responses
+ * across all route handlers. This eliminates duplication of response formatting
+ * logic and ensures consistent error handling throughout the API.
+ */
+/**
+ * Factory for building consistent API responses
+ */
+export class ResponseBuilder {
+    /**
+     * Creates an error response with standard error structure
+     *
+     * @param code - Machine-readable error code (e.g., 'INVALID_REQUEST', 'NOT_FOUND')
+     * @param message - Human-readable error message
+     * @param statusCode - HTTP status code to return
+     * @param details - Optional additional error context
+     * @returns Object containing both response data and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'Project ID is required', 400);
+     * return c.json(response, statusCode as any);
+     * ```
+     */
+    static error(code, message, statusCode, details) {
+        const error = {
+            code,
+            message,
+            timestamp: new Date().toISOString()
+        };
+        if (details !== undefined) {
+            error.details = details;
+        }
+        const response = { error };
+        return { response, statusCode };
+    }
+    /**
+     * Creates a success response with optional data
+     *
+     * @param data - Response payload data
+     * @param statusCode - HTTP status code (default: 200)
+     * @returns Object containing both response data and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * const { response, statusCode } = ResponseBuilder.success(projects, 200);
+     * return c.json(response, statusCode as any);
+     * ```
+     */
+    static success(data, statusCode = 200) {
+        return { response: data, statusCode };
+    }
+}
+//# sourceMappingURL=response-builder.js.map

package/dist/lib/stream-helper.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Stream helper utilities for handling async generator streaming responses
+ *
+ * Centralizes streaming logic to avoid duplication across route handlers
+ */
+import { Context } from 'hono';
+import { stream } from 'hono/streaming';
+/**
+ * Options for streaming async generators
+ */
+export interface StreamOptions<T> {
+    /**
+     * Custom error event formatter
+     * If not provided, defaults to { type: 'error', message: ... }
+     */
+    onError?: (error: Error) => T;
+}
+/**
+ * Streams an async generator as newline-delimited JSON
+ *
+ * Handles:
+ * - Iterating through async generator
+ * - Serializing each event to JSON
+ * - Writing newline-delimited format
+ * - Error handling and recovery
+ * - Proper stream cleanup
+ *
+ * @param c - Hono context
+ * @param generator - Async generator yielding events
+ * @param options - Optional configuration
+ * @returns Hono response
+ *
+ * @example
+ * ```typescript
+ * return StreamHelper.streamAsyncGenerator(c, projectManager.createProject(gitUrl));
+ * ```
+ */
+export declare function streamAsyncGenerator<T>(c: Context, generator: AsyncGenerator<T>, options?: StreamOptions<T>): ReturnType<typeof stream>;
+//# sourceMappingURL=stream-helper.d.ts.map

package/dist/lib/stream-helper.js

@@ -0,0 +1,43 @@
+/**
+ * Stream helper utilities for handling async generator streaming responses
+ *
+ * Centralizes streaming logic to avoid duplication across route handlers
+ */
+import { stream } from 'hono/streaming';
+/**
+ * Streams an async generator as newline-delimited JSON
+ *
+ * Handles:
+ * - Iterating through async generator
+ * - Serializing each event to JSON
+ * - Writing newline-delimited format
+ * - Error handling and recovery
+ * - Proper stream cleanup
+ *
+ * @param c - Hono context
+ * @param generator - Async generator yielding events
+ * @param options - Optional configuration
+ * @returns Hono response
+ *
+ * @example
+ * ```typescript
+ * return StreamHelper.streamAsyncGenerator(c, projectManager.createProject(gitUrl));
+ * ```
+ */
+export function streamAsyncGenerator(c, generator, options) {
+    return stream(c, async (writer) => {
+        try {
+            for await (const event of generator) {
+                await writer.write(JSON.stringify(event) + '\n');
+            }
+        }
+        catch (error) {
+            const errorEvent = options?.onError?.(error) || {
+                type: 'error',
+                message: error instanceof Error ? error.message : String(error)
+            };
+            await writer.write(JSON.stringify(errorEvent) + '\n');
+        }
+    });
+}
+//# sourceMappingURL=stream-helper.js.map

package/dist/managers/ConversationManager.d.ts

@@ -0,0 +1,83 @@
+/**
+ * ConversationManager handles conversation history storage and retrieval
+ *
+ * This manager is responsible for:
+ * - Storing request/response pairs in JSON format
+ * - Retrieving conversation history for a thread
+ * - Managing conversation persistence
+ */
+import { ConversationHistory, ConversationMessage, NeovateEvent, FileData } from '../types/models.js';
+/**
+ * ConversationManager interface defines the contract for conversation operations
+ */
+export interface ConversationManager {
+    /**
+     * Starts a new conversation message (request captured)
+     * @param threadId - The thread ID
+     * @param threadPath - The absolute path to the thread directory
+     * @param message - The user's message
+     * @param model - The model being used
+     * @param attachments - Optional file attachments
+     * @param planMode - Optional plan mode flag
+     * @returns The message ID for this conversation
+     */
+    startMessage(threadId: string, threadPath: string, message: string, model: string, attachments?: FileData[], planMode?: boolean): Promise<string>;
+    /**
+     * Completes a conversation message (response captured)
+     * @param threadPath - The absolute path to the thread directory
+     * @param messageId - The message ID to complete
+     * @param content - The complete response content
+     * @param events - All events captured during execution
+     */
+    completeMessage(threadPath: string, messageId: string, content: string, events: NeovateEvent[]): Promise<void>;
+    /**
+     * Gets the conversation history for a thread
+     * @param threadPath - The absolute path to the thread directory
+     * @returns The conversation history or null if not found
+     */
+    getConversationHistory(threadPath: string): Promise<ConversationHistory | null>;
+    /**
+     * Gets the last N messages from conversation history
+     * @param threadPath - The absolute path to the thread directory
+     * @param count - Number of messages to retrieve (default: 1)
+     * @returns Array of conversation messages
+     */
+    getLastMessages(threadPath: string, count?: number): Promise<ConversationMessage[]>;
+}
+/**
+ * ConversationManagerImpl provides the implementation for conversation operations
+ */
+export declare class ConversationManagerImpl implements ConversationManager {
+    private metadataDir;
+    /**
+     * Create a new ConversationManagerImpl
+     * @param rootFolder - Base directory where metadata will be stored
+     */
+    constructor(rootFolder?: string);
+    /**
+     * Starts a new conversation message
+     */
+    startMessage(threadId: string, threadPath: string, message: string, model: string, attachments?: FileData[], planMode?: boolean): Promise<string>;
+    /**
+     * Completes a conversation message
+     */
+    completeMessage(threadPath: string, messageId: string, content: string, events: NeovateEvent[]): Promise<void>;
+    /**
+     * Gets the conversation history for a thread
+     */
+    getConversationHistory(threadPath: string): Promise<ConversationHistory | null>;
+    /**
+     * Gets the last N messages from conversation history
+     */
+    getLastMessages(threadPath: string, count?: number): Promise<ConversationMessage[]>;
+    /**
+     * Saves conversation history to file
+     */
+    private saveConversationHistory;
+    /**
+     * Gets the file path for a thread's conversation history in the metadata folder
+     * Extracts threadId from threadPath and stores in .metadata/conversations/<threadId>/history.json
+     */
+    private getConversationFilePath;
+}
+//# sourceMappingURL=ConversationManager.d.ts.map

package/dist/managers/ConversationManager.js

@@ -0,0 +1,129 @@
+/**
+ * ConversationManager handles conversation history storage and retrieval
+ *
+ * This manager is responsible for:
+ * - Storing request/response pairs in JSON format
+ * - Retrieving conversation history for a thread
+ * - Managing conversation persistence
+ */
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+import { randomUUID } from 'crypto';
+const CONVERSATION_FILE = 'conversation-history.json';
+const METADATA_DIR = '.metadata';
+/**
+ * ConversationManagerImpl provides the implementation for conversation operations
+ */
+export class ConversationManagerImpl {
+    metadataDir;
+    /**
+     * Create a new ConversationManagerImpl
+     * @param rootFolder - Base directory where metadata will be stored
+     */
+    constructor(rootFolder = './projects') {
+        this.metadataDir = join(rootFolder, METADATA_DIR);
+    }
+    /**
+     * Starts a new conversation message
+     */
+    async startMessage(threadId, threadPath, message, model, attachments, planMode) {
+        const messageId = randomUUID();
+        const timestamp = new Date().toISOString();
+        // Load existing history or create new
+        let history = await this.getConversationHistory(threadPath);
+        if (!history) {
+            history = {
+                threadId,
+                messages: [],
+                lastUpdated: timestamp,
+            };
+        }
+        // Create incomplete message (will be completed later)
+        const incompleteMessage = {
+            id: messageId,
+            timestamp,
+            request: {
+                message,
+                model,
+                ...(attachments && { attachments }),
+                ...(planMode && { planMode }),
+            },
+            response: null,
+        };
+        history.messages.push(incompleteMessage);
+        history.lastUpdated = timestamp;
+        // Save to file
+        await this.saveConversationHistory(threadPath, history);
+        return messageId;
+    }
+    /**
+     * Completes a conversation message
+     */
+    async completeMessage(threadPath, messageId, content, events) {
+        const history = await this.getConversationHistory(threadPath);
+        if (!history) {
+            throw new Error('Conversation history not found');
+        }
+        // Find the message to complete
+        const message = history.messages.find((m) => m.id === messageId);
+        if (!message) {
+            throw new Error(`Message ${messageId} not found in conversation history`);
+        }
+        // Complete the message with response data
+        message.response = {
+            content,
+            events,
+            completedAt: new Date().toISOString(),
+        };
+        history.lastUpdated = new Date().toISOString();
+        // Save to file
+        await this.saveConversationHistory(threadPath, history);
+    }
+    /**
+     * Gets the conversation history for a thread
+     */
+    async getConversationHistory(threadPath) {
+        try {
+            const filePath = this.getConversationFilePath(threadPath);
+            const content = await fs.readFile(filePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch (error) {
+            if (error instanceof Error && error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Gets the last N messages from conversation history
+     */
+    async getLastMessages(threadPath, count = 1) {
+        const history = await this.getConversationHistory(threadPath);
+        if (!history || history.messages.length === 0) {
+            return [];
+        }
+        // Return last N messages
+        return history.messages.slice(-count);
+    }
+    /**
+     * Saves conversation history to file
+     */
+    async saveConversationHistory(threadPath, history) {
+        const filePath = this.getConversationFilePath(threadPath);
+        // Ensure all parent directories exist
+        await fs.mkdir(dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, JSON.stringify(history, null, 2), 'utf-8');
+    }
+    /**
+     * Gets the file path for a thread's conversation history in the metadata folder
+     * Extracts threadId from threadPath and stores in .metadata/conversations/<threadId>/history.json
+     */
+    getConversationFilePath(threadPath) {
+        // Extract thread ID from path (last part of the path)
+        const threadId = threadPath.split(/[\\/]/).pop() || 'unknown';
+        const conversationsDir = join(this.metadataDir, 'conversations');
+        return join(conversationsDir, threadId, CONVERSATION_FILE);
+    }
+}
+//# sourceMappingURL=ConversationManager.js.map