tarsk 0.3.16 → 0.3.19

package/dist/index.js

@@ -20,6 +20,7 @@ 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 { getDataDir } from './paths.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Parse arguments
@@ -30,20 +31,18 @@ const shouldOpenBrowser = args.includes('--open');
 if (!isDebug) {
     console.log = () => { };
 }
-const positionalArgs = args.filter(arg => !arg.startsWith('--'));
-const rootFolderArg = positionalArgs[0];
 const app = new Hono();
 // Configure CORS middleware
 app.use('/*', cors());
 // Initialize managers
-const rootFolder = rootFolderArg ? path.resolve(process.cwd(), rootFolderArg) : (process.env.ROOT_FOLDER || process.cwd());
-const metadataManager = new MetadataManager(rootFolder);
+const dataDir = getDataDir();
+const metadataManager = new MetadataManager(dataDir);
 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();
+const projectManager = new ProjectManagerImpl(dataDir, metadataManager, gitManager, processingStateManager);
+const threadManager = new ThreadManagerImpl(metadataManager, gitManager, processingStateManager);
+const conversationManager = new ConversationManagerImpl(dataDir);
+const neovateExecutor = new NeovateExecutorImpl(metadataManager);
 // Initialize metadata storage
 await metadataManager.initialize();
 // Health check endpoint

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

@@ -51,9 +51,10 @@ export declare class ConversationManagerImpl implements ConversationManager {
     private metadataDir;
     /**
      * Create a new ConversationManagerImpl
-     * @param rootFolder - Base directory where metadata will be stored
+     * @param dataDir - Directory where metadata files are stored
+     *                  (e.g. ~/Library/Application Support/Tarsk/data)
      */
-    constructor(rootFolder?: string);
+    constructor(dataDir: string);
     /**
      * Starts a new conversation message
      */

package/dist/managers/conversation-manager.js

@@ -10,7 +10,6 @@ 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
  */
@@ -18,10 +17,11 @@ export class ConversationManagerImpl {
     metadataDir;
     /**
      * Create a new ConversationManagerImpl
-     * @param rootFolder - Base directory where metadata will be stored
+     * @param dataDir - Directory where metadata files are stored
+     *                  (e.g. ~/Library/Application Support/Tarsk/data)
      */
-    constructor(rootFolder = './projects') {
-        this.metadataDir = join(rootFolder, METADATA_DIR);
+    constructor(dataDir) {
+        this.metadataDir = dataDir;
     }
     /**
      * Starts a new conversation message

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

@@ -20,9 +20,10 @@ export declare class MetadataManager {
     private metadataDir;
     /**
      * Create a new MetadataManager
-     * @param rootFolder - Base directory where metadata will be stored
+     * @param dataDir - Directory where metadata files will be stored
+     *                  (e.g. ~/Library/Application Support/Tarsk/data)
      */
-    constructor(rootFolder: string);
+    constructor(dataDir: string);
     /**
      * Initialize metadata directory if it doesn't exist
      */

package/dist/managers/metadata-manager.js

@@ -13,10 +13,11 @@ export class MetadataManager {
     metadataDir;
     /**
      * Create a new MetadataManager
-     * @param rootFolder - Base directory where metadata will be stored
+     * @param dataDir - Directory where metadata files will be stored
+     *                  (e.g. ~/Library/Application Support/Tarsk/data)
      */
-    constructor(rootFolder) {
-        this.metadataDir = join(rootFolder, ".metadata");
+    constructor(dataDir) {
+        this.metadataDir = dataDir;
         this.projectsFile = join(this.metadataDir, "projects.json");
         this.threadsFile = join(this.metadataDir, "threads.json");
         this.stateFile = join(this.metadataDir, "state.json");

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

@@ -10,6 +10,7 @@
 import { Project, ProjectEvent, Command } from '../types/models.js';
 import { MetadataManager } from './metadata-manager.js';
 import { GitManager } from './git-manager.js';
+import type { ProcessingStateManager } from './processing-state-manager.js';
 /**
  * ProjectManager interface defines the contract for project operations
  */
@@ -67,6 +68,12 @@ export interface ProjectManager {
      * @param cwd - Optional working directory relative to thread path
      */
     runCommand(threadId: string, commandLine: string, cwd?: string): AsyncGenerator<unknown>;
+    /**
+     * Updates the project's setup script
+     * @param projectId - The project ID
+     * @param setupScript - The setup script to run after clone (or null to clear)
+     */
+    updateSetupScript(projectId: string, setupScript: string | null): Promise<void>;
 }
 /**
  * ProjectManagerImpl provides the implementation for project operations
@@ -75,17 +82,19 @@ export declare class ProjectManagerImpl implements ProjectManager {
     private rootFolder;
     private metadataManager;
     private gitManager;
+    private processingStateManager?;
     /**
      * Create a new ProjectManager
      * @param rootFolder - Base directory where projects will be stored
      * @param metadataManager - Manager for persisting metadata
      * @param gitManager - Manager for git operations
+     * @param processingStateManager - Optional manager for processing state (for spinner during clone)
      *
      * Requirements:
      * - 1.1 - WHEN a user provides a git URL to create a new Project, THE CLI SHALL clone the repository into a folder under the Root_Folder
      * - 1.4 - THE CLI SHALL determine the storage path for each Project folder
      */
-    constructor(rootFolder: string, metadataManager: MetadataManager, gitManager: GitManager);
+    constructor(rootFolder: string, metadataManager: MetadataManager, gitManager: GitManager, processingStateManager?: ProcessingStateManager);
     /**
      * Creates a new project from a git URL
      *
@@ -149,9 +158,9 @@ export declare class ProjectManagerImpl implements ProjectManager {
      */
     private deriveProjectName;
     /**
-     * Generates a project path under the root folder
+     * Generates a project path under the root folder using the project ID
      *
-     * @param projectName - The project name
+     * @param projectId - The unique project ID
      * @returns The absolute path to the project folder
      *
      * Requirements:
@@ -189,6 +198,19 @@ export declare class ProjectManagerImpl implements ProjectManager {
      * @param commandId - The ID of the command to delete
      */
     deleteCommand(projectId: string, commandId: string): Promise<void>;
+    /**
+     * Detects a suggested setup script by checking for package.json and lock files
+     * Order: yarn.lock, bun.lock, pnpm-lock.yaml, else npm install
+     * @param chrootPath - Path to the cloned repo root
+     * @returns The suggested install command or null if no package.json
+     */
+    private detectSetupScript;
+    /**
+     * Updates the project's setup script
+     * @param projectId - The project ID
+     * @param setupScript - The setup script to run after clone (or null to clear)
+     */
+    updateSetupScript(projectId: string, setupScript: string | null): Promise<void>;
     /**
      * Runs a command in a thread's directory
      * @param threadId - The thread ID where to run the command

package/dist/managers/project-manager.js

@@ -10,6 +10,7 @@
 import { randomUUID } from 'crypto';
 import { join, relative } from 'path';
 import { realpathSync } from 'fs';
+import { access } from 'fs/promises';
 /**
  * ProjectManagerImpl provides the implementation for project operations
  */
@@ -17,20 +18,23 @@ export class ProjectManagerImpl {
     rootFolder;
     metadataManager;
     gitManager;
+    processingStateManager;
     /**
      * Create a new ProjectManager
      * @param rootFolder - Base directory where projects will be stored
      * @param metadataManager - Manager for persisting metadata
      * @param gitManager - Manager for git operations
+     * @param processingStateManager - Optional manager for processing state (for spinner during clone)
      *
      * Requirements:
      * - 1.1 - WHEN a user provides a git URL to create a new Project, THE CLI SHALL clone the repository into a folder under the Root_Folder
      * - 1.4 - THE CLI SHALL determine the storage path for each Project folder
      */
-    constructor(rootFolder, metadataManager, gitManager) {
+    constructor(rootFolder, metadataManager, gitManager, processingStateManager) {
         this.rootFolder = rootFolder;
         this.metadataManager = metadataManager;
         this.gitManager = gitManager;
+        this.processingStateManager = processingStateManager;
     }
     /**
      * Creates a new project from a git URL
@@ -63,27 +67,28 @@ export class ProjectManagerImpl {
             };
             return;
         }
+        let initialThreadId;
         try {
             // Generate unique project ID
             const projectId = randomUUID();
             // Derive project name from git URL
             const projectName = this.deriveProjectName(gitUrl);
-            // Generate project path
-            const projectPath = this.generateProjectPath(projectName);
-            yield {
-                type: 'progress',
-                message: `Creating project "${projectName}" from ${gitUrl}...`
-            };
-            // Generate unique thread ID for the initial thread
-            const initialThreadId = randomUUID();
+            // Generate project path using the unique ID (not the name, to avoid collisions)
+            const projectPath = this.generateProjectPath(projectId);
+            // Generate unique thread ID for the initial thread (before clone so frontend can show spinner)
+            initialThreadId = randomUUID();
             const firstThreadPath = join(projectPath, initialThreadId);
+            this.processingStateManager?.setProcessing(initialThreadId);
             yield {
                 type: 'progress',
-                message: `Cloning repository to ${firstThreadPath}...`
+                message: `Creating project "${projectName}" from ${gitUrl}...`,
+                threadId: initialThreadId,
+                projectId
             };
             // Stream git clone events
             for await (const gitEvent of this.gitManager.cloneRepository(gitUrl, firstThreadPath)) {
                 if (gitEvent.type === 'error') {
+                    this.processingStateManager?.clearProcessing(initialThreadId);
                     yield {
                         type: 'error',
                         message: `Git clone failed: ${gitEvent.message}`
@@ -98,7 +103,7 @@ export class ProjectManagerImpl {
                 }
             }
             // Create and checkout branch for initial thread
-            const initialThreadTitle = 'Thread 1';
+            const initialThreadTitle = 'thread-1';
             let branchName = this.gitManager.sanitizeBranchName(initialThreadTitle);
             yield {
                 type: 'progress',
@@ -122,6 +127,7 @@ export class ProjectManagerImpl {
             // Create and checkout the new branch
             for await (const gitEvent of this.gitManager.createAndCheckoutBranch(firstThreadPath, branchName)) {
                 if (gitEvent.type === 'error') {
+                    this.processingStateManager?.clearProcessing(initialThreadId);
                     yield {
                         type: 'error',
                         message: `Failed to create initial branch: ${gitEvent.message}`
@@ -139,6 +145,8 @@ export class ProjectManagerImpl {
                 type: 'progress',
                 message: `Branch "${branchName}" created and checked out`
             };
+            // Detect suggested setup script from package.json and lock files
+            const suggestedSetupScript = await this.detectSetupScript(firstThreadPath);
             // Create project metadata
             const project = {
                 id: projectId,
@@ -169,13 +177,18 @@ export class ProjectManagerImpl {
                 message: `Project "${projectName}" created successfully with initial thread`
             };
             // Yield complete event with project data
+            this.processingStateManager?.clearProcessing(initialThreadId);
             yield {
                 type: 'complete',
                 message: 'Project creation complete',
-                project
+                project,
+                suggestedSetupScript: suggestedSetupScript ?? undefined
             };
         }
         catch (error) {
+            if (typeof initialThreadId !== 'undefined') {
+                this.processingStateManager?.clearProcessing(initialThreadId);
+            }
             yield {
                 type: 'error',
                 message: `Failed to create project: ${error instanceof Error ? error.message : String(error)}`
@@ -258,16 +271,16 @@ export class ProjectManagerImpl {
         return name;
     }
     /**
-     * Generates a project path under the root folder
+     * Generates a project path under the root folder using the project ID
      *
-     * @param projectName - The project name
+     * @param projectId - The unique project ID
      * @returns The absolute path to the project folder
      *
      * Requirements:
      * - 1.4 - THE CLI SHALL determine the storage path for each Project folder
      */
-    generateProjectPath(projectName) {
-        return join(this.rootFolder, projectName);
+    generateProjectPath(projectId) {
+        return join(this.rootFolder, projectId);
     }
     /**
      * Gets the root folder path
@@ -391,6 +404,62 @@ export class ProjectManagerImpl {
         }
         await this.metadataManager.saveProjects(projects);
     }
+    /**
+     * Detects a suggested setup script by checking for package.json and lock files
+     * Order: yarn.lock, bun.lock, pnpm-lock.yaml, else npm install
+     * @param chrootPath - Path to the cloned repo root
+     * @returns The suggested install command or null if no package.json
+     */
+    async detectSetupScript(chrootPath) {
+        try {
+            await access(join(chrootPath, 'package.json'));
+        }
+        catch {
+            return null;
+        }
+        try {
+            await access(join(chrootPath, 'yarn.lock'));
+            return 'yarn install';
+        }
+        catch {
+            // continue
+        }
+        try {
+            await access(join(chrootPath, 'bun.lock'));
+            return 'bun install';
+        }
+        catch {
+            // continue
+        }
+        try {
+            await access(join(chrootPath, 'pnpm-lock.yaml'));
+            return 'pnpm install';
+        }
+        catch {
+            // continue
+        }
+        return 'npm install';
+    }
+    /**
+     * Updates the project's setup script
+     * @param projectId - The project ID
+     * @param setupScript - The setup script to run after clone (or null to clear)
+     */
+    async updateSetupScript(projectId, setupScript) {
+        const projects = await this.metadataManager.loadProjects();
+        const projectIndex = projects.findIndex(p => p.id === projectId);
+        if (projectIndex === -1) {
+            throw new Error(`Project not found: ${projectId}`);
+        }
+        // Update the project's setup script
+        if (setupScript === null || setupScript === '') {
+            delete projects[projectIndex].setupScript;
+        }
+        else {
+            projects[projectIndex].setupScript = setupScript;
+        }
+        await this.metadataManager.saveProjects(projects);
+    }
     /**
      * Runs a command in a thread's directory
      * @param threadId - The thread ID where to run the command

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

@@ -11,6 +11,7 @@
 import { Thread, ThreadEvent } from '../types/models.js';
 import { MetadataManager } from './metadata-manager.js';
 import { GitManager } from './git-manager.js';
+import type { ProcessingStateManager } from './processing-state-manager.js';
 /**
  * ThreadManager interface defines the contract for thread operations
  */
@@ -68,16 +69,18 @@ export interface ThreadManager {
 export declare class ThreadManagerImpl implements ThreadManager {
     private metadataManager;
     private gitManager;
+    private processingStateManager?;
     /**
      * Create a new ThreadManager
      * @param metadataManager - Manager for persisting metadata
      * @param gitManager - Manager for git operations
+     * @param processingStateManager - Optional manager for processing state (for spinner during clone)
      *
      * Requirements:
      * - 2.1 - WHEN a user creates a new Thread for a Project, THE CLI SHALL create a new clone of the Project's git repository
      * - 2.4 - THE System SHALL maintain a title for each Thread
      */
-    constructor(metadataManager: MetadataManager, gitManager: GitManager);
+    constructor(metadataManager: MetadataManager, gitManager: GitManager, processingStateManager?: ProcessingStateManager);
     /**
      * Creates a new thread for an existing project
      *
@@ -157,6 +160,13 @@ export declare class ThreadManagerImpl implements ThreadManager {
      * @returns The selected thread ID or null
      */
     getSelectedThreadId(): Promise<string | null>;
+    /**
+     * Runs a setup script in the given path and yields progress events
+     * @param threadPath - Path to run the command in
+     * @param commandLine - The command to execute
+     * @yields ThreadEvent progress events
+     */
+    private runSetupScript;
     /**
      * Generates a unique thread path
      *
@@ -175,12 +185,10 @@ export declare class ThreadManagerImpl implements ThreadManager {
     /**
      * Generates a thread title if not provided
      *
-     * Format: project-name Thread word1-word2
+     * Format: thread-{n} where n starts at 1 and increments for each new thread
      *
-     * @param existingTitles - Set of titles already in use
-     * @param threadId - Thread ID used as a fallback
-     * @param projectName - Optional project name to include in title
-     * @returns The generated thread title
+     * @param existingTitles - Set of titles already in use for this project
+     * @returns The generated thread title (e.g. thread-1, thread-2, thread-3)
      */
     private generateThreadTitle;
     /**

package/dist/managers/thread-manager.js

@@ -16,18 +16,21 @@ import { join } from 'path';
 export class ThreadManagerImpl {
     metadataManager;
     gitManager;
+    processingStateManager;
     /**
      * Create a new ThreadManager
      * @param metadataManager - Manager for persisting metadata
      * @param gitManager - Manager for git operations
+     * @param processingStateManager - Optional manager for processing state (for spinner during clone)
      *
      * Requirements:
      * - 2.1 - WHEN a user creates a new Thread for a Project, THE CLI SHALL create a new clone of the Project's git repository
      * - 2.4 - THE System SHALL maintain a title for each Thread
      */
-    constructor(metadataManager, gitManager) {
+    constructor(metadataManager, gitManager, processingStateManager) {
         this.metadataManager = metadataManager;
         this.gitManager = gitManager;
+        this.processingStateManager = processingStateManager;
     }
     /**
      * Creates a new thread for an existing project
@@ -53,6 +56,7 @@ export class ThreadManagerImpl {
      * - 7.4 - THE CLI SHALL ensure each Thread clone is stored in a unique directory path
      */
     async *createThread(projectId, title) {
+        let threadId;
         try {
             // Load project to verify it exists and get git URL
             const projects = await this.metadataManager.loadProjects();
@@ -65,7 +69,7 @@ export class ThreadManagerImpl {
                 return;
             }
             // Generate unique thread ID
-            const threadId = randomUUID();
+            threadId = randomUUID();
             // Generate thread path: {projectPath}/{threadId}
             const threadPath = this.generateThreadPath(project.path, threadId);
             // Generate thread title if not provided
@@ -73,10 +77,12 @@ export class ThreadManagerImpl {
             const existingTitles = new Set(existingThreads
                 .filter(t => t.projectId === projectId)
                 .map(t => t.title));
-            const threadTitle = title || this.generateThreadTitle(existingTitles, threadId, project.name);
+            const threadTitle = title || this.generateThreadTitle(existingTitles);
+            this.processingStateManager?.setProcessing(threadId);
             yield {
                 type: 'progress',
-                message: `Creating thread "${threadTitle}" for project "${project.name}"...`
+                message: `Creating thread "${threadTitle}" for project "${project.name}"...`,
+                threadId
             };
             yield {
                 type: 'progress',
@@ -85,6 +91,7 @@ export class ThreadManagerImpl {
             // Stream git clone events
             for await (const gitEvent of this.gitManager.cloneRepository(project.gitUrl, threadPath)) {
                 if (gitEvent.type === 'error') {
+                    this.processingStateManager?.clearProcessing(threadId);
                     yield {
                         type: 'error',
                         message: `Git clone failed: ${gitEvent.message}`
@@ -122,6 +129,7 @@ export class ThreadManagerImpl {
             // Create and checkout the new branch
             for await (const gitEvent of this.gitManager.createAndCheckoutBranch(threadPath, branchName)) {
                 if (gitEvent.type === 'error') {
+                    this.processingStateManager?.clearProcessing(threadId);
                     yield {
                         type: 'error',
                         message: `Failed to create branch: ${gitEvent.message}`
@@ -139,6 +147,16 @@ export class ThreadManagerImpl {
                 type: 'progress',
                 message: `Branch "${branchName}" created and checked out`
             };
+            // Run setup script if project has one configured
+            if (project.setupScript) {
+                yield {
+                    type: 'progress',
+                    message: `Running setup script: ${project.setupScript}`
+                };
+                for await (const event of this.runSetupScript(threadPath, project.setupScript)) {
+                    yield event;
+                }
+            }
             // Create thread metadata
             const thread = {
                 id: threadId,
@@ -161,6 +179,7 @@ export class ThreadManagerImpl {
                 message: `Thread "${threadTitle}" created successfully`
             };
             // Yield complete event with thread data
+            this.processingStateManager?.clearProcessing(threadId);
             yield {
                 type: 'complete',
                 message: 'Thread creation complete',
@@ -168,6 +187,9 @@ export class ThreadManagerImpl {
             };
         }
         catch (error) {
+            if (typeof threadId !== 'undefined') {
+                this.processingStateManager?.clearProcessing(threadId);
+            }
             yield {
                 type: 'error',
                 message: `Failed to create thread: ${error instanceof Error ? error.message : String(error)}`
@@ -272,6 +294,64 @@ export class ThreadManagerImpl {
     async getSelectedThreadId() {
         return await this.metadataManager.getSelectedThread();
     }
+    /**
+     * Runs a setup script in the given path and yields progress events
+     * @param threadPath - Path to run the command in
+     * @param commandLine - The command to execute
+     * @yields ThreadEvent progress events
+     */
+    async *runSetupScript(threadPath, commandLine) {
+        const { spawn } = await import('child_process');
+        const child = spawn(commandLine, {
+            shell: true,
+            cwd: threadPath
+        });
+        const decoder = new TextDecoder();
+        let resolveNext = () => { };
+        const outputQueue = [];
+        const errorQueue = [];
+        child.stdout.on('data', (data) => {
+            outputQueue.push(decoder.decode(data));
+            resolveNext();
+        });
+        child.stderr.on('data', (data) => {
+            errorQueue.push(decoder.decode(data));
+            resolveNext();
+        });
+        let isDone = false;
+        child.on('close', (code) => {
+            if (code !== 0) {
+                errorQueue.push(`Process exited with code ${code}`);
+            }
+            isDone = true;
+            resolveNext();
+        });
+        child.on('error', (err) => {
+            errorQueue.push(err.message);
+            isDone = true;
+            resolveNext();
+        });
+        const waitForData = () => new Promise((resolve) => {
+            resolveNext = resolve;
+        });
+        while (!isDone || outputQueue.length > 0 || errorQueue.length > 0) {
+            if (outputQueue.length > 0) {
+                const text = outputQueue.shift();
+                for (const line of text.split('\n').filter(l => l.trim())) {
+                    yield { type: 'progress', message: line };
+                }
+            }
+            else if (errorQueue.length > 0) {
+                const text = errorQueue.shift();
+                for (const line of text.split('\n').filter(l => l.trim())) {
+                    yield { type: 'progress', message: line };
+                }
+            }
+            else {
+                await waitForData();
+            }
+        }
+    }
     /**
      * Generates a unique thread path
      *
@@ -292,34 +372,23 @@ export class ThreadManagerImpl {
     /**
      * Generates a thread title if not provided
      *
-     * Format: project-name Thread word1-word2
+     * Format: thread-{n} where n starts at 1 and increments for each new thread
      *
-     * @param existingTitles - Set of titles already in use
-     * @param threadId - Thread ID used as a fallback
-     * @param projectName - Optional project name to include in title
-     * @returns The generated thread title
+     * @param existingTitles - Set of titles already in use for this project
+     * @returns The generated thread title (e.g. thread-1, thread-2, thread-3)
      */
-    generateThreadTitle(existingTitles, threadId, projectName) {
-        const wordsA = [
-            'amber', 'brisk', 'calm', 'drift', 'ember', 'frost', 'glow', 'hollow',
-            'ivory', 'jolly', 'keen', 'lucid', 'mellow', 'noble', 'opal', 'prism',
-            'quiet', 'ripple', 'sunny', 'timber', 'ultra', 'vivid', 'wisp', 'zen'
-        ];
-        const wordsB = [
-            'arch', 'bay', 'crest', 'dune', 'echo', 'fjord', 'glen', 'harbor',
-            'isle', 'jewel', 'knoll', 'lagoon', 'mesa', 'nest', 'oasis', 'peak',
-            'quarry', 'reef', 'strand', 'trail', 'vale', 'wharf', 'yard', 'zephyr'
-        ];
-        const prefix = projectName ? `${projectName} Thread ` : 'Thread ';
-        for (let attempt = 0; attempt < 12; attempt += 1) {
-            const word1 = wordsA[Math.floor(Math.random() * wordsA.length)];
-            const word2 = wordsB[Math.floor(Math.random() * wordsB.length)];
-            const candidate = `${prefix}${word1}-${word2}`;
-            if (!existingTitles.has(candidate)) {
-                return candidate;
+    generateThreadTitle(existingTitles) {
+        const threadNumRegex = /^thread-(\d+)$/i;
+        let maxNum = 0;
+        for (const title of existingTitles) {
+            const match = title.match(threadNumRegex);
+            if (match) {
+                const n = parseInt(match[1], 10);
+                if (n > maxNum)
+                    maxNum = n;
             }
         }
-        return `${prefix}${threadId.slice(0, 8)}`;
+        return `Thread ${maxNum + 1}`;
     }
     /**
      * Lists all files in a thread's directory (tracked and untracked, but not ignored)

package/dist/paths.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Centralized path configuration for Tarsk
+ *
+ * Application data is stored in ~/Library/Application Support/Tarsk/data/
+ * This includes projects.json, threads.json, state.json, and conversations.
+ */
+/**
+ * The root application support directory for Tarsk.
+ * On macOS: ~/Library/Application Support/Tarsk
+ */
+export declare const APP_SUPPORT_DIR: string;
+/**
+ * The data directory where metadata files are stored.
+ * ~/Library/Application Support/Tarsk/data
+ */
+export declare const DATA_DIR: string;
+/**
+ * Get the data directory path for storing metadata.
+ * @returns The absolute path to ~/Library/Application Support/Tarsk/data
+ */
+export declare function getDataDir(): string;
+//# sourceMappingURL=paths.d.ts.map