tarsk 0.3.19 → 0.3.20

package/dist/index.js

@@ -19,7 +19,10 @@ 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';
+import { createRunRoutes } from './routes/run.js';
+import { createOnboardingRoutes } from './routes/onboarding.js';
+import { createScaffoldRoutes } from './routes/scaffold.js';
+import { AVAILABLE_PROGRAMS } from '@tarsk/shared';
 import { getDataDir } from './paths.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -67,21 +70,34 @@ app.get('/api/threads/processing', (c) => {
 });
 // Register API routes
 app.route('/api/projects', createProjectRoutes(projectManager, threadManager));
+app.route('/api/projects', createRunRoutes(projectManager));
 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));
+app.route('/api/onboarding', createOnboardingRoutes(metadataManager));
+app.route('/api/scaffold', createScaffoldRoutes(projectManager));
 // 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)
-}));
-// Fallback to index.html for SPA routing
-app.get('*', serveStatic({
-    path: path.relative(process.cwd(), path.join(publicDir, 'index.html'))
-}));
+const staticRoot = path.relative(process.cwd(), publicDir);
+app.use('/*', async (c, next) => {
+    // Never serve static files or SPA fallback for API routes
+    if (c.req.path.startsWith('/api/')) {
+        return next();
+    }
+    return serveStatic({ root: staticRoot })(c, next);
+});
+// Fallback to index.html for SPA routing (only for non-API paths)
+app.get('*', async (c, next) => {
+    if (c.req.path.startsWith('/api/')) {
+        return next();
+    }
+    return serveStatic({
+        path: path.relative(process.cwd(), path.join(publicDir, 'index.html'))
+    })(c, next);
+});
 // Error handling middleware for unmatched routes
 app.all('*', (c) => {
     const errorResponse = {

package/dist/lib/conversation-content.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Helpers for extracting and normalizing conversation content from Neovate events.
+ * Used when saving completed messages (store only final answer) and when
+ * mapping stream events to thinking vs content for the UI.
+ */
+import type { NeovateEvent, ConversationMessage } from '@tarsk/shared';
+/**
+ * Formats completed conversation messages into a single context string to prepend
+ * to the next user prompt so the model retains conversation history.
+ */
+export declare function formatConversationContext(messages: ConversationMessage[], maxMessages?: number): string;
+/**
+ * Parses assistant message content into content blocks when it is a JSON array
+ * (e.g. [{ type: 'reasoning', text: '...' }, { type: 'text', text: '...' }, { type: 'tool_use', ... }]).
+ * Returns null if content is not a structured array.
+ */
+export declare function parseAssistantContentBlocks(content: string): Array<{
+    type: string;
+    [key: string]: unknown;
+}> | null;
+/** Returns true if content looks like tool result/use JSON */
+export declare function isToolLikeContent(content: string): boolean;
+/**
+ * Returns only the final assistant answer text from events (no user message, no tool JSON).
+ * Use this when persisting response content so the stored file stays clean.
+ */
+export declare function extractAssistantContent(events: NeovateEvent[] | undefined, fallback: string): string;
+//# sourceMappingURL=conversation-content.d.ts.map

package/dist/lib/conversation-content.js

@@ -0,0 +1,130 @@
+/**
+ * Helpers for extracting and normalizing conversation content from Neovate events.
+ * Used when saving completed messages (store only final answer) and when
+ * mapping stream events to thinking vs content for the UI.
+ */
+/** Max number of prior exchanges to include in context (user + assistant pairs) */
+const DEFAULT_MAX_CONTEXT_MESSAGES = 10;
+/**
+ * Formats completed conversation messages into a single context string to prepend
+ * to the next user prompt so the model retains conversation history.
+ */
+export function formatConversationContext(messages, maxMessages = DEFAULT_MAX_CONTEXT_MESSAGES) {
+    const completed = messages.filter((m) => m.response != null);
+    const recent = completed.slice(-maxMessages);
+    if (recent.length === 0)
+        return '';
+    const lines = ['Previous conversation:'];
+    for (const m of recent) {
+        lines.push(`User: ${m.request.message}`);
+        lines.push(`Assistant: ${m.response.content}`);
+    }
+    return lines.join('\n');
+}
+const extractTextBlocksFromContent = (content) => {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith('[') && !trimmed.startsWith('{')) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed
+                .filter((block) => block && typeof block === 'object' && block.type === 'text')
+                .map((block) => (typeof block.text === 'string' ? block.text : ''))
+                .filter((text) => text.length > 0);
+        }
+        if (parsed && typeof parsed === 'object' && 'text' in parsed && typeof parsed.text === 'string') {
+            return [parsed.text];
+        }
+    }
+    catch {
+        // ignore
+    }
+    return [];
+};
+/**
+ * Parses assistant message content into content blocks when it is a JSON array
+ * (e.g. [{ type: 'reasoning', text: '...' }, { type: 'text', text: '...' }, { type: 'tool_use', ... }]).
+ * Returns null if content is not a structured array.
+ */
+export function parseAssistantContentBlocks(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith('['))
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (!Array.isArray(parsed) || parsed.length === 0)
+            return null;
+        const blocks = [];
+        for (const item of parsed) {
+            if (item && typeof item === 'object' && 'type' in item) {
+                blocks.push(item);
+            }
+        }
+        return blocks.length > 0 ? blocks : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Returns true if content looks like tool result/use JSON */
+export function isToolLikeContent(content) {
+    const trimmed = content.trim();
+    if (!trimmed.startsWith('[') && !trimmed.startsWith('{'))
+        return false;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (Array.isArray(parsed)) {
+            return parsed.some((item) => item &&
+                typeof item === 'object' &&
+                'type' in item &&
+                (item.type === 'tool-result' || item.type === 'tool_use'));
+        }
+        return (typeof parsed === 'object' &&
+            parsed !== null &&
+            'type' in parsed &&
+            (parsed.type === 'tool-result' || parsed.type === 'tool_use'));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Returns only the final assistant answer text from events (no user message, no tool JSON).
+ * Use this when persisting response content so the stored file stays clean.
+ */
+export function extractAssistantContent(events, fallback) {
+    if (!events || events.length === 0) {
+        return fallback;
+    }
+    const resultEvent = [...events].reverse().find((event) => event.type === 'result');
+    if (resultEvent && typeof resultEvent.content === 'string' && resultEvent.content.trim().length > 0) {
+        return resultEvent.content;
+    }
+    const assistantMessages = events.filter((event) => event.type === 'message' && event.role === 'assistant');
+    let lastTextBlock = null;
+    const assistantChunks = [];
+    for (const event of assistantMessages) {
+        if (typeof event.content !== 'string') {
+            continue;
+        }
+        if (isToolLikeContent(event.content)) {
+            continue;
+        }
+        assistantChunks.push(event.content);
+        const textBlocks = extractTextBlocksFromContent(event.content);
+        if (textBlocks.length > 0) {
+            lastTextBlock = textBlocks[textBlocks.length - 1];
+        }
+    }
+    if (lastTextBlock) {
+        return lastTextBlock;
+    }
+    if (assistantChunks.length === 0) {
+        return fallback;
+    }
+    const combined = assistantChunks.join('');
+    return combined.trim().length > 0 ? combined : fallback;
+}
+//# sourceMappingURL=conversation-content.js.map

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

@@ -5,7 +5,7 @@
  * 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';
+import type { ErrorResponse } from '@tarsk/shared';
 /**
  * Factory for building consistent API responses
  */

package/dist/managers/conversation-manager.d.ts

@@ -6,7 +6,7 @@
  * - Retrieving conversation history for a thread
  * - Managing conversation persistence
  */
-import { ConversationHistory, ConversationMessage, NeovateEvent, FileData } from '../types/models.js';
+import { ConversationHistory, ConversationMessage, NeovateEvent, FileData } from '@tarsk/shared';
 /**
  * ConversationManager interface defines the contract for conversation operations
  */
@@ -71,9 +71,6 @@ export declare class ConversationManagerImpl implements ConversationManager {
      * 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

package/dist/managers/git-manager.d.ts

@@ -6,7 +6,7 @@
  * - Cloning repositories with streaming output
  * - Handling git operation errors
  */
-import { GitEvent } from '../types/models.js';
+import { GitEvent } from '@tarsk/shared';
 /**
  * GitManager interface defines the contract for git operations
  */
@@ -45,6 +45,11 @@ export interface GitManager {
      * @yields GitEvent objects for stdout, stderr, complete, and error events
      */
     createAndCheckoutBranch(repoPath: string, branchName: string): AsyncGenerator<GitEvent>;
+    /**
+     * Initializes a new git repository at the given path
+     * @param repoPath - The path where to run git init
+     */
+    initRepository(repoPath: string): Promise<void>;
 }
 /**
  * GitManagerImpl provides the implementation for git operations
@@ -129,5 +134,6 @@ export declare class GitManagerImpl implements GitManager {
      * @yields GitEvent objects during the branch creation
      */
     createAndCheckoutBranch(repoPath: string, branchName: string): AsyncGenerator<GitEvent>;
+    initRepository(repoPath: string): Promise<void>;
 }
 //# sourceMappingURL=git-manager.d.ts.map

package/dist/managers/git-manager.js

@@ -6,7 +6,7 @@
  * - Cloning repositories with streaming output
  * - Handling git operation errors
  */
-import { spawn } from 'child_process';
+import { spawn, spawnSync } from 'child_process';
 import { mkdir } from 'fs/promises';
 import { dirname } from 'path';
 /**
@@ -326,5 +326,12 @@ export class GitManagerImpl {
             };
         }
     }
+    async initRepository(repoPath) {
+        const result = spawnSync('git', ['init'], { cwd: repoPath, encoding: 'utf-8' });
+        if (result.status !== 0) {
+            const stderr = result.stderr?.trim() || result.error?.message || 'Unknown error';
+            throw new Error(`git init failed: ${stderr}`);
+        }
+    }
 }
 //# sourceMappingURL=git-manager.js.map

package/dist/managers/metadata-manager.d.ts

@@ -4,7 +4,7 @@
  * This manager provides JSON file-based storage with atomic writes
  * to ensure data consistency even if the process crashes during write operations.
  */
-import { Project, Thread } from "../types/models.js";
+import { Project, Thread } from "@tarsk/shared";
 /**
  * MetadataManager manages persistence of projects and threads
  */
@@ -12,6 +12,7 @@ interface AppState {
     selectedThreadId: string | null;
     providerKeys: Record<string, string>;
     enabledModels: Record<string, string[]>;
+    onboardingCompleted: boolean;
 }
 export declare class MetadataManager {
     private projectsFile;
@@ -48,15 +49,6 @@ export declare class MetadataManager {
      * @returns Array of threads
      */
     loadThreads(): Promise<Thread[]>;
-    /**
-     * Perform atomic write using temp file
-     *
-     * This ensures that if the process crashes during write,
-     * we don't end up with corrupted or partial data.
-     *
-     * @param filePath - Target file path
-     * @param data - Data to write
-     */
     private atomicWrite;
     /**
      * Get the metadata directory path
@@ -88,12 +80,12 @@ export declare class MetadataManager {
     /**
      * Update provider keys
      * @param providerName - Name of the provider
-     * @param apiKey - API key to save
+     * @param apiKey - API key to save (will be encrypted)
      */
     saveProviderKey(providerName: string, apiKey: string): Promise<void>;
     /**
      * Get all provider keys
-     * @returns Record of provider names to API keys
+     * @returns Record of provider names to decrypted API keys
      */
     getProviderKeys(): Promise<Record<string, string>>;
     /**
@@ -135,6 +127,16 @@ export declare class MetadataManager {
      * @param modelIds - Array of model IDs to enable
      */
     setEnabledModels(provider: string, modelIds: string[]): Promise<void>;
+    /**
+     * Set onboarding completed flag
+     * @param completed - Whether onboarding is completed
+     */
+    setOnboardingCompleted(completed: boolean): Promise<void>;
+    /**
+     * Get onboarding completed flag
+     * @returns Whether onboarding has been completed
+     */
+    getOnboardingCompleted(): Promise<boolean>;
 }
 export {};
 //# sourceMappingURL=metadata-manager.d.ts.map

package/dist/managers/metadata-manager.js

@@ -6,6 +6,7 @@
  */
 import { promises as fs } from "fs";
 import { join, dirname } from "path";
+import { encrypt, decrypt, isEncrypted } from "../utils/crypto.js";
 export class MetadataManager {
     projectsFile;
     threadsFile;
@@ -49,6 +50,7 @@ export class MetadataManager {
                     selectedThreadId: null,
                     providerKeys: {},
                     enabledModels: {},
+                    onboardingCompleted: false,
                 });
             }
         }
@@ -187,11 +189,15 @@ export class MetadataManager {
             if (!state.enabledModels) {
                 state.enabledModels = {};
             }
+            // Ensure onboardingCompleted exists
+            if (state.onboardingCompleted === undefined) {
+                state.onboardingCompleted = false;
+            }
             return state;
         }
         catch (error) {
             if (error.code === "ENOENT") {
-                return { selectedThreadId: null, providerKeys: {}, enabledModels: {} };
+                return { selectedThreadId: null, providerKeys: {}, enabledModels: {}, onboardingCompleted: false };
             }
             throw new Error(`Failed to load state: ${error}`);
         }
@@ -202,26 +208,62 @@ export class MetadataManager {
      */
     async saveAllProviderKeys(keys) {
         const state = await this.loadState();
-        state.providerKeys = { ...state.providerKeys, ...keys };
+        // Encrypt all keys before saving
+        const encryptedKeys = {};
+        for (const [provider, key] of Object.entries(keys)) {
+            encryptedKeys[provider] = key ? encrypt(key) : '';
+        }
+        state.providerKeys = { ...state.providerKeys, ...encryptedKeys };
         await this.saveState(state);
     }
     /**
      * Update provider keys
      * @param providerName - Name of the provider
-     * @param apiKey - API key to save
+     * @param apiKey - API key to save (will be encrypted)
      */
     async saveProviderKey(providerName, apiKey) {
         const state = await this.loadState();
-        state.providerKeys[providerName] = apiKey;
+        // Encrypt the API key before saving
+        state.providerKeys[providerName] = apiKey ? encrypt(apiKey) : '';
         await this.saveState(state);
     }
     /**
      * Get all provider keys
-     * @returns Record of provider names to API keys
+     * @returns Record of provider names to decrypted API keys
      */
     async getProviderKeys() {
         const state = await this.loadState();
-        return state.providerKeys;
+        // Decrypt all keys and migrate any plain-text keys
+        const decryptedKeys = {};
+        let needsMigration = false;
+        for (const [provider, encryptedKey] of Object.entries(state.providerKeys)) {
+            if (!encryptedKey) {
+                decryptedKeys[provider] = '';
+                continue;
+            }
+            // Check if key is already encrypted
+            if (isEncrypted(encryptedKey)) {
+                try {
+                    decryptedKeys[provider] = decrypt(encryptedKey);
+                }
+                catch (error) {
+                    console.error(`Failed to decrypt key for ${provider}:`, error);
+                    // Keep the encrypted value if decryption fails
+                    decryptedKeys[provider] = '';
+                }
+            }
+            else {
+                // Plain-text key found - needs migration
+                decryptedKeys[provider] = encryptedKey;
+                needsMigration = true;
+            }
+        }
+        // If we found plain-text keys, encrypt them
+        if (needsMigration) {
+            console.log('Migrating plain-text API keys to encrypted format...');
+            await this.saveAllProviderKeys(decryptedKeys);
+        }
+        return decryptedKeys;
     }
     /**
      * Set the selected thread ID
@@ -302,5 +344,22 @@ export class MetadataManager {
         }
         await this.saveState(state);
     }
+    /**
+     * Set onboarding completed flag
+     * @param completed - Whether onboarding is completed
+     */
+    async setOnboardingCompleted(completed) {
+        const state = await this.loadState();
+        state.onboardingCompleted = completed;
+        await this.saveState(state);
+    }
+    /**
+     * Get onboarding completed flag
+     * @returns Whether onboarding has been completed
+     */
+    async getOnboardingCompleted() {
+        const state = await this.loadState();
+        return state.onboardingCompleted;
+    }
 }
 //# sourceMappingURL=metadata-manager.js.map

package/dist/managers/model-manager.d.ts

@@ -4,7 +4,7 @@
  * Manages available and enabled models across different providers.
  * Enriches models with pricing (and name/description) from model-info when available (e.g. OpenRouter).
  */
-import { Model } from '../types/models.js';
+import { Model } from '@tarsk/shared';
 import { MetadataManager } from './metadata-manager.js';
 /**
  * ModelManager handles model availability and selection

package/dist/managers/neovate-executor.d.ts

@@ -6,7 +6,7 @@
  * - Streaming result messages back to the caller
  * - Handling execution errors
  */
-import { NeovateEvent, ExecutionContext } from "../types/models.js";
+import { NeovateEvent, ExecutionContext } from "@tarsk/shared";
 import { MetadataManager } from "./metadata-manager.js";
 /**
  * NeovateExecutor interface defines the contract for neovate command execution

package/dist/managers/process-manager.d.ts

@@ -0,0 +1,55 @@
+/**
+ * ProcessManager handles running and stopping dev server processes
+ *
+ * This manager is responsible for:
+ * - Starting dev server processes with output capture
+ * - Detecting URLs from process output
+ * - Stopping running processes
+ * - Streaming output back to the frontend
+ */
+import { EventEmitter } from 'events';
+export interface ProcessOutput {
+    type: 'stdout' | 'stderr' | 'url' | 'error' | 'complete';
+    content?: string;
+    url?: string;
+    error?: unknown;
+}
+export declare class ProcessManager extends EventEmitter {
+    private processes;
+    private detectedUrls;
+    private queues;
+    private resolvers;
+    /**
+     * Run a command and stream its output
+     * @param projectId - The project ID (used as a key)
+     * @param command - The command to run (e.g., "npm run dev")
+     * @param cwd - Working directory to run the command in
+     * @returns AsyncGenerator that yields ProcessOutput events
+     */
+    runProcess(projectId: string, command: string, cwd: string): AsyncGenerator<ProcessOutput>;
+    /**
+     * Stop a running process
+     * @param projectId - The project ID
+     * @returns true if process was stopped, false if no process was running
+     */
+    stopProcess(projectId: string): boolean;
+    /**
+     * Check if a process is running for a project
+     * @param projectId - The project ID
+     * @returns true if a process is running
+     */
+    isRunning(projectId: string): boolean;
+    /**
+     * Get the detected URL for a running process
+     * @param projectId - The project ID
+     * @returns The URL if detected, undefined otherwise
+     */
+    getDetectedUrl(projectId: string): string | undefined;
+    /**
+     * Detect URL from text output
+     * @param text - The text to search for URLs
+     * @returns The first detected URL or undefined
+     */
+    private detectUrl;
+}
+//# sourceMappingURL=process-manager.d.ts.map