tarsk 0.3.43 → 0.4.4

package/dist/features/projects/projects-get.route.js

@@ -0,0 +1,36 @@
+/**
+ * GET /api/projects/:id
+ * Get project details by ID
+ *
+ * Response:
+ * {
+ *   "id": "uuid",
+ *   "name": "project-name",
+ *   "gitUrl": "https://github.com/user/repo.git",
+ *   "path": "/path/to/project",
+ *   "createdAt": "2024-01-01T00:00:00Z",
+ *   "threads": ["thread-id-1", "thread-id-2"]
+ * }
+ *
+ * Requirements:
+ * - 6.2 - THE CLI SHALL expose REST API endpoints for Project operations
+ */
+import { errorResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleGetProject(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        const project = await projectManager.getProject(projectId);
+        if (!project) {
+            return errorResponse(c, ErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${projectId}`, 404);
+        }
+        return c.json(project);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.GET_PROJECT_ERROR, "Failed to get project", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=projects-get.route.js.map

package/dist/features/projects/projects-list.route.d.ts

@@ -0,0 +1,58 @@
+/**
+ * GET /api/projects
+ * List all projects with expanded threads
+ *
+ * Response:
+ * [
+ *   {
+ *     "projectId": "uuid",
+ *     "gitUrl": "https://github.com/user/repo.git",
+ *     "projectPath": "/path/to/project",
+ *     "threads": [
+ *       {
+ *         "threadId": "uuid",
+ *         "title": "thread-title",
+ *         "path": "/path/to/thread",
+ *         "isSelected": false
+ *       }
+ *     ]
+ *   }
+ * ]
+ *
+ * Requirements:
+ * - 6.2 - THE CLI SHALL expose REST API endpoints for Project operations
+ */
+import { Context } from "hono";
+import { ProjectManager } from "../projects/projects.manager.js";
+import { ThreadManager } from "../threads/threads.manager.js";
+export declare function handleListProjects(c: Context, projectManager: ProjectManager, threadManager: ThreadManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    projectId: string;
+    name: string;
+    gitUrl: string;
+    projectPath: string;
+    openWith: string | undefined;
+    commands: {
+        id: string;
+        name: string;
+        icon: string;
+        commandLine: string;
+        relativeFolder?: string | undefined;
+    }[];
+    setupScript: string | undefined;
+    runCommand: string | undefined;
+    commitMethod: import("@tarsk/shared").CommitMethods | undefined;
+    threads: {
+        threadId: string;
+        title: string;
+        path: string;
+        isSelected: boolean;
+    }[];
+}[], import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+//# sourceMappingURL=projects-list.route.d.ts.map

package/dist/features/projects/projects-list.route.js

@@ -0,0 +1,59 @@
+/**
+ * GET /api/projects
+ * List all projects with expanded threads
+ *
+ * Response:
+ * [
+ *   {
+ *     "projectId": "uuid",
+ *     "gitUrl": "https://github.com/user/repo.git",
+ *     "projectPath": "/path/to/project",
+ *     "threads": [
+ *       {
+ *         "threadId": "uuid",
+ *         "title": "thread-title",
+ *         "path": "/path/to/thread",
+ *         "isSelected": false
+ *       }
+ *     ]
+ *   }
+ * ]
+ *
+ * Requirements:
+ * - 6.2 - THE CLI SHALL expose REST API endpoints for Project operations
+ */
+import { errorResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleListProjects(c, projectManager, threadManager) {
+    try {
+        const projects = await projectManager.listProjects();
+        // Get the currently selected thread
+        const selectedThreadId = await threadManager.getSelectedThreadId();
+        // Expand threads for each project
+        const expandedProjects = await Promise.all(projects.map(async (project) => {
+            const threads = await threadManager.listThreads(project.id);
+            return {
+                projectId: project.id,
+                name: project.name,
+                gitUrl: project.gitUrl,
+                projectPath: project.path,
+                openWith: project.openWith,
+                commands: project.commands ?? [],
+                setupScript: project.setupScript,
+                runCommand: project.runCommand,
+                commitMethod: project.commitMethod,
+                threads: threads.map((thread) => ({
+                    threadId: thread.id,
+                    title: thread.title,
+                    path: thread.path,
+                    isSelected: thread.id === selectedThreadId,
+                })),
+            };
+        }));
+        return c.json(expandedProjects);
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.LIST_PROJECTS_ERROR, "Failed to list projects", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=projects-list.route.js.map

package/dist/features/projects/projects-open-folder.route.d.ts

@@ -0,0 +1,10 @@
+/**
+ * POST /api/projects/open-folder
+ * Create a new project by selecting a local folder via native OS dialog
+ *
+ * Response: Newline-delimited JSON stream of ProjectEvent objects
+ */
+import { Context } from "hono";
+import { ProjectManager } from "../projects/projects.manager.js";
+export declare function handleOpenFolderProject(c: Context, projectManager: ProjectManager): Promise<Response>;
+//# sourceMappingURL=projects-open-folder.route.d.ts.map

package/dist/features/projects/projects-open-folder.route.js

@@ -0,0 +1,11 @@
+/**
+ * POST /api/projects/open-folder
+ * Create a new project by selecting a local folder via native OS dialog
+ *
+ * Response: Newline-delimited JSON stream of ProjectEvent objects
+ */
+import { streamAsyncGenerator } from "../../core/stream-helper.js";
+export async function handleOpenFolderProject(c, projectManager) {
+    return streamAsyncGenerator(c, projectManager.createProjectFromFolder());
+}
+//# sourceMappingURL=projects-open-folder.route.js.map

package/dist/features/projects/projects-open.route.d.ts

@@ -0,0 +1,26 @@
+/**
+ * POST /api/projects/:id/open
+ * Open a project in the specified program
+ *
+ * Request body:
+ * {
+ *   "program": "VS Code" | "Cursor" | "Windsurf" | "Xcode" | "Android Studio" | "Kiro"
+ * }
+ *
+ * Response:
+ * {
+ *   "success": true,
+ *   "message": "Project opened in VS Code"
+ * }
+ */
+import { Context } from "hono";
+import { ProjectManager } from "../projects/projects.manager.js";
+export declare function handleOpenProject(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+//# sourceMappingURL=projects-open.route.d.ts.map

package/dist/features/projects/projects-open.route.js

@@ -0,0 +1,49 @@
+/**
+ * POST /api/projects/:id/open
+ * Open a project in the specified program
+ *
+ * Request body:
+ * {
+ *   "program": "VS Code" | "Cursor" | "Windsurf" | "Xcode" | "Android Studio" | "Kiro"
+ * }
+ *
+ * Response:
+ * {
+ *   "success": true,
+ *   "message": "Project opened in VS Code"
+ * }
+ */
+import { validateProgram } from "./projects.open-with.js";
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleOpenProject(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        const body = await c.req.json();
+        const { program } = body;
+        console.log("[POST /api/projects/:id/open] projectId=%s program=%s", projectId, program);
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        const programError = validateProgram(program ?? "");
+        if (programError) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, programError, 400);
+        }
+        const project = await projectManager.getProject(projectId);
+        if (!project) {
+            return errorResponse(c, ErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${projectId}`, 404);
+        }
+        console.log("[POST /api/projects/:id/open] Calling projectManager.openWith");
+        await projectManager.openWith(projectId, program ?? "");
+        console.log("[POST /api/projects/:id/open] openWith completed successfully");
+        return successResponse(c, {
+            success: true,
+            message: `Project opened in ${program ?? "default program"}`,
+        });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return errorResponse(c, ErrorCodes.OPEN_PROGRAM_ERROR, errorMessage, 500);
+    }
+}
+//# sourceMappingURL=projects-open.route.js.map

package/dist/features/projects/projects-package-scripts.route.d.ts

@@ -0,0 +1,15 @@
+/**
+ * GET /api/projects/:id/package-scripts
+ * Get available npm scripts from package.json files in the project
+ */
+import { Context } from "hono";
+import { ProjectManager } from "../projects/projects.manager.js";
+export declare function handleGetPackageScripts(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">)>;
+//# sourceMappingURL=projects-package-scripts.route.d.ts.map

package/dist/features/projects/projects-package-scripts.route.js

@@ -0,0 +1,96 @@
+/**
+ * GET /api/projects/:id/package-scripts
+ * Get available npm scripts from package.json files in the project
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+import { detectPackageManager } from "../../core/run-command-detector.js";
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { glob } from "glob";
+/**
+ * Convert script name to title case
+ * Replaces hyphens, colons, and underscores with spaces and capitalizes each word
+ */
+function formatScriptName(scriptName) {
+    return scriptName.replace(/[-:_]/g, " ").replace(/\b\w/g, (l) => l.toUpperCase());
+}
+/**
+ * Generate command line based on package manager and script name
+ */
+function generateCommandLine(packageManager, scriptName) {
+    switch (packageManager) {
+        case "npm":
+        case "yarn":
+            return `${packageManager} run ${scriptName}`;
+        case "pnpm":
+            return `pnpm ${scriptName}`;
+        case "bun":
+            return `bun run ${scriptName}`;
+        default:
+            return `npm run ${scriptName}`;
+    }
+}
+/**
+ * Search for package.json files recursively and extract scripts
+ */
+async function findPackageScripts(projectPath) {
+    const scripts = [];
+    try {
+        // Find all package.json files recursively
+        const packageJsonFiles = await glob("**/package.json", {
+            cwd: projectPath,
+            ignore: ["**/node_modules/**", "**/dist/**", "**/build/**"],
+        });
+        const packageManager = await detectPackageManager(projectPath);
+        for (const filePath of packageJsonFiles) {
+            try {
+                const fullPath = join(projectPath, filePath);
+                const content = await readFile(fullPath, "utf-8");
+                const packageJson = JSON.parse(content);
+                if (packageJson.scripts) {
+                    for (const [scriptName] of Object.entries(packageJson.scripts)) {
+                        // Skip common internal scripts
+                        if (scriptName.startsWith("pre") || scriptName.startsWith("post")) {
+                            continue;
+                        }
+                        scripts.push({
+                            name: formatScriptName(scriptName),
+                            commandLine: generateCommandLine(packageManager, scriptName),
+                            relativePath: filePath.replace(/\/package\.json$/, ""),
+                        });
+                    }
+                }
+            }
+            catch {
+                // Skip invalid package.json files
+                continue;
+            }
+        }
+    }
+    catch {
+        // Return empty array if glob fails
+        return [];
+    }
+    return scripts;
+}
+export async function handleGetPackageScripts(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        // Get project path
+        const project = await projectManager.getProject(projectId);
+        if (!project?.path) {
+            return errorResponse(c, ErrorCodes.PROJECT_NOT_FOUND, "Project not found", 404);
+        }
+        // Find all package.json scripts
+        const scripts = await findPackageScripts(project.path);
+        return successResponse(c, { scripts });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.GET_PROJECT_ERROR, "Failed to get package scripts", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=projects-package-scripts.route.js.map

package/dist/features/projects/projects-run-command.route.d.ts

@@ -0,0 +1,8 @@
+/**
+ * POST /api/projects/:projectId/threads/:threadId/commands/run
+ * Run a command in a thread's directory
+ */
+import { Context } from "hono";
+import { ProjectManager } from "../projects/projects.manager.js";
+export declare function handleRunCommand(c: Context, projectManager: ProjectManager): Promise<Response>;
+//# sourceMappingURL=projects-run-command.route.d.ts.map

package/dist/features/projects/projects-run-command.route.js

@@ -0,0 +1,21 @@
+/**
+ * POST /api/projects/:projectId/threads/:threadId/commands/run
+ * Run a command in a thread's directory
+ */
+import { streamAsyncGenerator } from "../../core/stream-helper.js";
+import { errorResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleRunCommand(c, projectManager) {
+    try {
+        const threadId = c.req.param("threadId");
+        const { commandLine, cwd } = await c.req.json();
+        if (!threadId || !commandLine) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Thread ID and commandLine are required", 400);
+        }
+        return streamAsyncGenerator(c, projectManager.runCommand(threadId, commandLine, cwd));
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.RUN_COMMAND_ERROR, "Failed to run command", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=projects-run-command.route.js.map

package/dist/features/projects/projects-run.route.d.ts

@@ -0,0 +1,51 @@
+/**
+ * POST /api/projects/:id/run
+ * Start the dev server process for a project
+ */
+import { Context } from "hono";
+import { ProjectManager } from "../projects/projects.manager.js";
+export declare function handleStartRun(c: Context, projectManager: ProjectManager): Promise<Response>;
+/**
+ * POST /api/projects/:id/run-suggest
+ * Suggest a run command for a project based on package.json
+ */
+export declare function handleSuggestRun(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    runCommand: string | null;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+/**
+ * POST /api/projects/:id/stop
+ * Stop the dev server process for a project
+ */
+export declare function handleStopRun(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    message: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+/**
+ * GET /api/projects/:id/running
+ * Check if a dev server process is running for a project
+ */
+export declare function handleCheckRunning(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    isRunning: boolean;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+//# sourceMappingURL=projects-run.route.d.ts.map

package/dist/features/projects/projects-run.route.js

@@ -0,0 +1,74 @@
+/**
+ * POST /api/projects/:id/run
+ * Start the dev server process for a project
+ */
+import { streamAsyncGenerator } from "../../core/stream-helper.js";
+import { errorResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleStartRun(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        const body = await c.req.json();
+        const { threadId } = body;
+        console.log("CLI Route: handleStartRun called for project:", projectId, "thread:", threadId);
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        return streamAsyncGenerator(c, projectManager.startRunningProcess(projectId, threadId));
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.START_PROCESS_ERROR, "Failed to start dev server", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * POST /api/projects/:id/run-suggest
+ * Suggest a run command for a project based on package.json
+ */
+export async function handleSuggestRun(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        const runCommand = await projectManager.suggestRunCommand(projectId);
+        return c.json({ runCommand });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.SUGGEST_RUN_COMMAND_ERROR, "Failed to suggest run command", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * POST /api/projects/:id/stop
+ * Stop the dev server process for a project
+ */
+export async function handleStopRun(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        await projectManager.stopRunningProcess(projectId);
+        return c.json({ success: true, message: "Dev server stopped" });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.STOP_PROCESS_ERROR, "Failed to stop dev server", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+/**
+ * GET /api/projects/:id/running
+ * Check if a dev server process is running for a project
+ */
+export async function handleCheckRunning(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        const isRunning = await projectManager.isProcessRunning(projectId);
+        return c.json({ isRunning });
+    }
+    catch (error) {
+        return errorResponse(c, ErrorCodes.CHECK_PROCESS_ERROR, "Failed to check process status", 500, error instanceof Error ? error.message : String(error));
+    }
+}
+//# sourceMappingURL=projects-run.route.js.map

package/dist/features/projects/projects-update.route.d.ts

@@ -0,0 +1,24 @@
+/**
+ * PUT /api/projects/:id
+ * Update project properties (unified endpoint)
+ *
+ * Request body (all fields optional):
+ * {
+ *   "program": "VS Code" | "Cursor" | "Windsurf" | "Xcode" | "Android Studio" | "Kiro",
+ *   "setupScript": "npm install" | null,
+ *   "name": "new-project-name",
+ *   "runCommand": "npm run dev" | null,
+ *   "commitMethod": "pull-request" | "direct",
+ *   "runNow": boolean (optional) - if true, run the setup script in the first thread
+ * }
+ *
+ * Response:
+ * {
+ *   "success": true,
+ *   "message": "Project updated"
+ * }
+ */
+import { Context } from "hono";
+import { ProjectManager } from "../projects/projects.manager.js";
+export declare function handleUpdateProject(c: Context, projectManager: ProjectManager): Promise<Response>;
+//# sourceMappingURL=projects-update.route.d.ts.map

package/dist/features/projects/projects-update.route.js

@@ -0,0 +1,81 @@
+/**
+ * PUT /api/projects/:id
+ * Update project properties (unified endpoint)
+ *
+ * Request body (all fields optional):
+ * {
+ *   "program": "VS Code" | "Cursor" | "Windsurf" | "Xcode" | "Android Studio" | "Kiro",
+ *   "setupScript": "npm install" | null,
+ *   "name": "new-project-name",
+ *   "runCommand": "npm run dev" | null,
+ *   "commitMethod": "pull-request" | "direct",
+ *   "runNow": boolean (optional) - if true, run the setup script in the first thread
+ * }
+ *
+ * Response:
+ * {
+ *   "success": true,
+ *   "message": "Project updated"
+ * }
+ */
+import { validateProgram } from "./projects.open-with.js";
+import { streamAsyncGenerator } from "../../core/stream-helper.js";
+import { CommitMethods, isValidCommitMethod } from "@tarsk/shared";
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function handleUpdateProject(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        const body = await c.req.json();
+        const { program, setupScript, name, runCommand, commitMethod, runNow } = body;
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        const project = await projectManager.getProject(projectId);
+        if (!project) {
+            return errorResponse(c, ErrorCodes.PROJECT_NOT_FOUND, `Project not found: ${projectId}`, 404);
+        }
+        // Update program (open-with) if provided
+        if (program !== undefined) {
+            const programError = validateProgram(program ?? "");
+            if (programError) {
+                return errorResponse(c, ErrorCodes.INVALID_REQUEST, programError, 400);
+            }
+            await projectManager.updateOpenWith(projectId, program ?? "");
+        }
+        // Update setup script if provided
+        if (setupScript !== undefined) {
+            const scriptToSave = setupScript === "" ? null : setupScript;
+            await projectManager.updateSetupScript(projectId, scriptToSave);
+            if (runNow && scriptToSave && project.threads.length > 0) {
+                const firstThreadId = project.threads[0];
+                return streamAsyncGenerator(c, projectManager.runCommand(firstThreadId, scriptToSave));
+            }
+        }
+        // Update run command if provided
+        if (runCommand !== undefined) {
+            await projectManager.updateRunCommand(projectId, runCommand);
+        }
+        // Update commit method if provided
+        if (commitMethod !== undefined) {
+            if (!isValidCommitMethod(commitMethod)) {
+                const validMethods = Object.values(CommitMethods).join('", "');
+                return errorResponse(c, ErrorCodes.INVALID_REQUEST, `Commit method must be one of: "${validMethods}"`, 400);
+            }
+            await projectManager.updateCommitMethod(projectId, commitMethod);
+        }
+        // Update name if provided
+        if (name !== undefined) {
+            if (!name?.trim()) {
+                return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project name is required", 400);
+            }
+            await projectManager.updateProjectName(projectId, name);
+        }
+        return successResponse(c, { success: true, message: "Project updated" });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return errorResponse(c, ErrorCodes.UPDATE_PROJECT_ERROR, "Failed to update project", 500, errorMessage);
+    }
+}
+//# sourceMappingURL=projects-update.route.js.map

package/dist/features/projects/projects.creator.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Project creation: create projects from a git URL or from a scaffold template.
+ * Contains creation flow logic and helpers (naming, paths, setup script detection).
+ */
+import type { ProjectEvent } from "@tarsk/shared";
+import { CommitMethods } from "@tarsk/shared";
+import type { MetadataManager } from "../metadata/metadata.manager.js";
+import type { GitManager } from "../git/git.manager.js";
+import type { ProcessingStateManager } from "../../agent/agent.processing-state-manager.js";
+export type SuggestRunCommand = (projectId: string) => Promise<string | null>;
+export type UpdateRunCommand = (projectId: string, runCommand: string | null) => Promise<void>;
+export interface ProjectCreatorRunCommandCallbacks {
+    suggestRunCommand: SuggestRunCommand;
+    updateRunCommand: UpdateRunCommand;
+}
+export declare class ProjectCreator {
+    private rootFolder;
+    private metadataManager;
+    private gitManager;
+    private processingStateManager?;
+    private runCommandCallbacks?;
+    constructor(rootFolder: string, metadataManager: MetadataManager, gitManager: GitManager, processingStateManager?: ProcessingStateManager | undefined, runCommandCallbacks?: ProjectCreatorRunCommandCallbacks | undefined);
+    createProject(gitUrl: string, commitMethod?: CommitMethods): AsyncGenerator<ProjectEvent>;
+    createProjectFromScaffold(projectName: string, templateId: string, packageManager: string): AsyncGenerator<ProjectEvent>;
+    private ensureUniqueProjectName;
+    private deriveProjectName;
+    private generateThreadPath;
+    createProjectFromFolder(): AsyncGenerator<ProjectEvent>;
+    private isGitRepository;
+    private detectSetupScript;
+    private findAllPackageJsonFiles;
+}
+//# sourceMappingURL=projects.creator.d.ts.map