tarsk 0.4.4 → 0.4.6

package/dist/features/projects/projects.manager.js

@@ -1,426 +0,0 @@
-/**
- * ProjectManager handles project lifecycle and metadata management
- *
- * This manager is responsible for:
- * - Creating new projects from git URLs
- * - Managing project metadata
- * - Coordinating with GitManager for repository cloning
- * - Providing CRUD operations for projects
- */
-import { join } from "path";
-import { realpathSync } from "fs";
-import { rm } from "fs/promises";
-import { spawnShell } from "../../core/utils.js";
-import { CommitMethods } from "@tarsk/shared";
-import { ProcessManager } from "../../agent/agent.process-manager.js";
-import { suggestRunCommand } from "../../core/run-command-detector.js";
-import { OpenWithHandler } from "./projects.open-with.js";
-import { ProjectCreator } from "./projects.creator.js";
-import { TerminalSessionManager } from "./terminal-session-manager.js";
-/**
- * ProjectManagerImpl provides the implementation for project operations
- */
-export class ProjectManagerImpl {
-    rootFolder;
-    metadataManager;
-    processManager;
-    openWithHandler;
-    projectCreator;
-    terminalSessionManager;
-    /**
-     * 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, processingStateManager) {
-        this.rootFolder = rootFolder;
-        this.metadataManager = metadataManager;
-        this.processManager = new ProcessManager();
-        this.terminalSessionManager = new TerminalSessionManager();
-        this.openWithHandler = new OpenWithHandler((id) => this.getProject(id), metadataManager);
-        this.projectCreator = new ProjectCreator(rootFolder, metadataManager, gitManager, processingStateManager, {
-            suggestRunCommand: (id) => this.suggestRunCommand(id),
-            updateRunCommand: (id, cmd) => this.updateRunCommand(id, cmd),
-        });
-    }
-    /**
-     * Creates a new project from a git URL
-     *
-     * This method:
-     * 1. Validates the git URL
-     * 2. Generates a unique project ID
-     * 3. Derives the project name from the git URL
-     * 4. Generates the project path
-     * 5. Delegates to GitManager for cloning
-     * 6. Saves project metadata
-     * 7. Yields progress events during the operation
-     * 8. Creates an initial thread automatically
-     *
-     * @param gitUrl - The git repository URL
-     * @yields ProjectEvent objects during the creation process
-     *
-     * 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.2 - WHEN a Project is created, THE App SHALL display the Project in the Side_Panel with its associated Thread
-     * - 1.4 - THE CLI SHALL determine the storage path for each Project folder
-     * - 1.5 - WHEN a Project folder is created, THE System SHALL associate it with the provided git URL
-     */
-    async *createProject(gitUrl, commitMethod = CommitMethods.PullRequest) {
-        yield* this.projectCreator.createProject(gitUrl, commitMethod);
-    }
-    /**
-     * Creates a new project from a local folder via native OS dialog.
-     */
-    async *createProjectFromFolder() {
-        yield* this.projectCreator.createProjectFromFolder();
-    }
-    /**
-     * Creates a new project by scaffolding a web app, then git init and initial thread.
-     */
-    async *createProjectFromScaffold(projectName, templateId, packageManager) {
-        yield* this.projectCreator.createProjectFromScaffold(projectName, templateId, packageManager);
-    }
-    /**
-     * Gets a project by ID
-     * @param projectId - The project ID
-     * @returns The project or null if not found
-     */
-    async getProject(projectId) {
-        const projects = await this.metadataManager.loadProjects();
-        return projects.find((p) => p.id === projectId) ?? null;
-    }
-    /**
-     * Lists all projects
-     * @returns Array of all projects
-     */
-    async listProjects() {
-        return await this.metadataManager.loadProjects();
-    }
-    /**
-     * Deletes a project and all its threads (cascade delete)
-     *
-     * This method:
-     * 1. Finds the project by ID
-     * 2. Removes all associated threads from metadata
-     * 3. Removes the project directory from filesystem
-     * 4. Removes the project from metadata
-     *
-     * @param projectId - The project ID to delete
-     * @throws Error if project not found
-     *
-     * Requirements:
-     * - 1.1 - Cascade delete for projects (remove all threads)
-     */
-    async deleteProject(projectId) {
-        const projects = await this.metadataManager.loadProjects();
-        const projectIndex = projects.findIndex((p) => p.id === projectId);
-        if (projectIndex === -1) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        const project = projects[projectIndex];
-        // Load threads and remove all threads associated with this project
-        const threads = await this.metadataManager.loadThreads();
-        const remainingThreads = threads.filter((t) => t.projectId !== projectId);
-        await this.metadataManager.saveThreads(remainingThreads);
-        // Remove project directory from filesystem
-        try {
-            await rm(project.path, { recursive: true, force: true });
-        }
-        catch (error) {
-            throw new Error(`Failed to remove project directory: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        // Remove project from metadata
-        projects.splice(projectIndex, 1);
-        await this.metadataManager.saveProjects(projects);
-    }
-    /**
-     * Gets the root folder path
-     * @returns The root folder path
-     */
-    getRootFolder() {
-        return this.rootFolder;
-    }
-    async openWith(projectId, program) {
-        return this.openWithHandler.openWith(projectId, program);
-    }
-    async updateOpenWith(projectId, program) {
-        return this.openWithHandler.updateOpenWith(projectId, program);
-    }
-    /**
-     * Saves (adds or updates) a command for a project
-     * @param projectId - The project ID
-     * @param command - The command to save
-     */
-    async saveCommand(projectId, command) {
-        const projects = await this.metadataManager.loadProjects();
-        const projectIndex = projects.findIndex((p) => p.id === projectId);
-        if (projectIndex === -1) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        const project = projects[projectIndex];
-        project.commands ??= [];
-        const commandIndex = project.commands.findIndex((c) => c.id === command.id);
-        if (commandIndex !== -1) {
-            project.commands[commandIndex] = command;
-        }
-        else {
-            project.commands.push(command);
-        }
-        await this.metadataManager.saveProjects(projects);
-    }
-    /**
-     * Deletes a command from a project
-     * @param projectId - The project ID
-     * @param commandId - The ID of the command to delete
-     */
-    async deleteCommand(projectId, commandId) {
-        const projects = await this.metadataManager.loadProjects();
-        const projectIndex = projects.findIndex((p) => p.id === projectId);
-        if (projectIndex === -1) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        const project = projects[projectIndex];
-        if (project.commands) {
-            project.commands = project.commands.filter((c) => c.id !== commandId);
-        }
-        await this.metadataManager.saveProjects(projects);
-    }
-    /**
-     * 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);
-    }
-    /**
-     * Updates the project's name
-     * @param projectId - The project ID
-     * @param name - The new project name
-     */
-    async updateProjectName(projectId, name) {
-        const projects = await this.metadataManager.loadProjects();
-        const projectIndex = projects.findIndex((p) => p.id === projectId);
-        if (projectIndex === -1) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        if (!name || typeof name !== "string" || name.trim() === "") {
-            throw new Error("Project name cannot be empty");
-        }
-        projects[projectIndex].name = name.trim();
-        await this.metadataManager.saveProjects(projects);
-    }
-    /**
-     * Runs a command in a thread's directory
-     * @param threadId - The thread ID where to run the command
-     * @param commandLine - The command line to execute
-     * @param cwd - Optional working directory relative to thread path
-     */
-    async *runCommand(threadId, commandLine, cwd) {
-        const threads = await this.metadataManager.loadThreads();
-        const thread = threads.find((t) => t.id === threadId);
-        if (!thread) {
-            throw new Error(`Thread not found: ${threadId}`);
-        }
-        // Get or create terminal session for this thread
-        const session = this.terminalSessionManager.getOrCreateSession(threadId, thread.path);
-        // Determine the working directory for this command
-        let workingDir;
-        if (cwd) {
-            // If explicit cwd provided, use it (absolute or relative to thread path)
-            workingDir = cwd.startsWith("/") ? cwd : join(thread.path, cwd);
-            // Update the session's working directory when explicit cwd is provided
-            this.terminalSessionManager.updateWorkingDirectory(threadId, workingDir);
-        }
-        else {
-            // Use the session's current working directory
-            workingDir = session.currentWorkingDirectory;
-        }
-        // Emit the current working directory so the client always has an absolute path
-        yield { type: "cwd", path: workingDir };
-        // Use shell for complex command lines
-        // Append a command to output the final working directory after the command runs
-        const child = spawnShell(`${commandLine}; printf "\n___CWD___%s\n" "$(pwd)"`, {
-            cwd: workingDir,
-            stdio: ["pipe", "pipe", "pipe"],
-        });
-        const decoder = new TextDecoder();
-        const outputBuffer = [];
-        let isDone = false;
-        if (child.stdout) {
-            child.stdout.on("data", (data) => {
-                const text = decoder.decode(data);
-                // Check if this chunk contains our CWD marker
-                if (text.includes("___CWD___")) {
-                    const parts = text.split("___CWD___");
-                    if (parts[0])
-                        outputBuffer.push(parts[0]);
-                    const newCwd = parts[1].trim();
-                    if (newCwd) {
-                        try {
-                            const realNewCwd = realpathSync(newCwd);
-                            outputBuffer.push({ type: "cwd", path: realNewCwd });
-                            // Update the session's working directory when it changes
-                            this.terminalSessionManager.updateWorkingDirectory(threadId, realNewCwd);
-                        }
-                        catch {
-                            outputBuffer.push({ type: "cwd", path: newCwd });
-                            // Update the session's working directory even if realpath fails
-                            this.terminalSessionManager.updateWorkingDirectory(threadId, newCwd);
-                        }
-                    }
-                }
-                else {
-                    outputBuffer.push(text);
-                }
-            });
-        }
-        if (child.stderr) {
-            child.stderr.on("data", (data) => {
-                outputBuffer.push({ type: "error", message: decoder.decode(data) });
-            });
-        }
-        child.on("close", (code) => {
-            if (code !== 0) {
-                outputBuffer.push({ type: "error", message: `Process exited with code ${code}` });
-            }
-            isDone = true;
-        });
-        child.on("error", (err) => {
-            outputBuffer.push({ type: "error", message: err.message });
-            isDone = true;
-        });
-        while (!isDone || outputBuffer.length > 0) {
-            if (outputBuffer.length > 0) {
-                yield outputBuffer.shift();
-            }
-            else {
-                await new Promise((resolve) => setTimeout(resolve, 50));
-            }
-        }
-    }
-    /**
-     * Suggests a run command based on package.json
-     * @param projectId - The project ID
-     * @returns Suggested run command or null if none detected
-     */
-    async suggestRunCommand(projectId) {
-        const project = await this.getProject(projectId);
-        if (!project) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        // Get the first thread's path where the actual repository code lives
-        // (project.path is just a container for threads)
-        const threads = await this.metadataManager.loadThreads();
-        const projectThreads = threads.filter((t) => t.projectId === projectId);
-        if (projectThreads.length === 0) {
-            return null;
-        }
-        return suggestRunCommand(projectThreads[0].path);
-    }
-    /**
-     * Updates the project's run command
-     * @param projectId - The project ID
-     * @param runCommand - The run command (e.g., "npm run dev") or null to clear
-     */
-    async updateRunCommand(projectId, runCommand) {
-        const projects = await this.metadataManager.loadProjects();
-        const project = projects.find((p) => p.id === projectId);
-        if (!project) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        project.runCommand = runCommand ?? undefined;
-        await this.metadataManager.saveProjects(projects);
-    }
-    /**
-     * Updates the project's commit method
-     * @param projectId - The project ID
-     * @param commitMethod - The commit method (PullRequest or Direct)
-     */
-    async updateCommitMethod(projectId, commitMethod) {
-        const projects = await this.metadataManager.loadProjects();
-        const project = projects.find((p) => p.id === projectId);
-        if (!project) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        project.commitMethod = commitMethod;
-        await this.metadataManager.saveProjects(projects);
-    }
-    /**
-     * Starts running a dev server process for a project
-     * @param projectId - The project ID
-     * @yields ProcessOutput events during the process
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    async *startRunningProcess(projectId, threadId) {
-        console.log("CLI Manager: startRunningProcess called for project:", projectId, "thread:", threadId);
-        const project = await this.getProject(projectId);
-        if (!project) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        if (!project.runCommand) {
-            throw new Error(`No run command defined for project: ${projectId}`);
-        }
-        // Use the provided threadId or fall back to the first thread
-        const targetThreadId = threadId ?? project.threads?.[0];
-        if (!targetThreadId) {
-            throw new Error(`No thread specified and no threads found for project: ${projectId}`);
-        }
-        try {
-            const threads = await this.metadataManager.loadThreads();
-            const thread = threads.find((t) => t.id === targetThreadId);
-            if (!thread) {
-                console.warn("[start-running-process] Thread not found for project", projectId, "targetThreadId:", targetThreadId, "available:", project.threads);
-                throw new Error(`Thread not found for project: ${projectId} with threadId: ${targetThreadId}`);
-            }
-            console.log("[start-running-process] Starting process with command:", project.runCommand, "in thread path:", thread.path);
-            yield* this.processManager.runProcess(projectId, project.runCommand, thread.path, targetThreadId);
-        }
-        catch (error) {
-            console.error("[start-running-process] Error starting process:", error);
-            throw error;
-        }
-    }
-    /**
-     * Stops a running dev server process for a project
-     * @param projectId - The project ID
-     * @returns true if process was stopped, false if no process was running
-     */
-    async stopRunningProcess(projectId) {
-        // Try to get the thread ID for this project to clear the cache
-        const project = await this.getProject(projectId);
-        let threadId;
-        if (project) {
-            // Use the first thread associated with this project
-            threadId = project.threads?.[0];
-        }
-        return this.processManager.stopProcess(projectId, threadId);
-    }
-    /**
-     * Checks if a process is running for a project
-     * @param projectId - The project ID
-     * @returns true if a process is running
-     */
-    async isProcessRunning(projectId) {
-        return this.processManager.isRunning(projectId);
-    }
-}
-//# sourceMappingURL=projects.manager.js.map

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

@@ -1,27 +0,0 @@
-/**
- * Open-with: open a project in an external program (Cursor, VS Code, Terminal, etc.)
- * and persist the project's open-with preference.
- */
-import type { Project } from "@tarsk/shared";
-import type { MetadataManager } from "../metadata/metadata.manager.js";
-/**
- * Validates if a program is supported.
- * Returns null if valid, or an error message if invalid.
- */
-export declare function validateProgram(program: string | undefined): string | null;
-export type GetProject = (projectId: string) => Promise<Project | null>;
-/**
- * Handles opening a project in an external program and updating the open-with preference.
- */
-export declare class OpenWithHandler {
-    private getProject;
-    private metadataManager;
-    constructor(getProject: GetProject, metadataManager: MetadataManager);
-    openWith(projectId: string, program: string): Promise<void>;
-    /**
-     * Opens the OS default terminal in the specified directory.
-     */
-    private openTerminal;
-    updateOpenWith(projectId: string, program: string): Promise<void>;
-}
-//# sourceMappingURL=projects.open-with.d.ts.map

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

@@ -1,156 +0,0 @@
-/**
- * Open-with: open a project in an external program (Cursor, VS Code, Terminal, etc.)
- * and persist the project's open-with preference.
- */
-import { spawnProcess } from "../../core/utils.js";
-import open from "open";
-import { AVAILABLE_PROGRAMS, PROGRAM_APP_NAMES } from "@tarsk/shared";
-/**
- * Validates if a program is supported.
- * Returns null if valid, or an error message if invalid.
- */
-export function validateProgram(program) {
-    if (!program) {
-        return "Program is required";
-    }
-    if (!AVAILABLE_PROGRAMS.includes(program)) {
-        return `Invalid program. Must be one of: ${AVAILABLE_PROGRAMS.join(", ")}`;
-    }
-    return null;
-}
-/**
- * Handles opening a project in an external program and updating the open-with preference.
- */
-export class OpenWithHandler {
-    getProject;
-    metadataManager;
-    constructor(getProject, metadataManager) {
-        this.getProject = getProject;
-        this.metadataManager = metadataManager;
-    }
-    async openWith(projectId, program) {
-        console.log("[openWith] Request: projectId=%s program=%s", projectId, program);
-        const programError = validateProgram(program);
-        if (programError) {
-            throw new Error(programError);
-        }
-        const project = await this.getProject(projectId);
-        if (!project) {
-            console.error("[openWith] Project not found:", projectId);
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        const projectPath = project.path;
-        console.log(`[ai] Open with ${program}`);
-        if (program === "Terminal") {
-            await this.openTerminal(projectPath);
-            return;
-        }
-        const appNames = PROGRAM_APP_NAMES[program];
-        if (!appNames) {
-            throw new Error(`Unsupported program: ${program}`);
-        }
-        console.log("[openWith] projectPath=%s platform=%s app=%j", projectPath, process.platform, appNames);
-        try {
-            await open(projectPath, {
-                app: { name: appNames },
-            });
-            console.log("[openWith] open() completed successfully");
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error("[openWith] open() error:", message);
-            throw new Error(`Failed to open ${program}: ${message}`);
-        }
-    }
-    /**
-     * Opens the OS default terminal in the specified directory.
-     */
-    async openTerminal(projectPath) {
-        console.log("[openTerminal] Starting terminal launch...");
-        console.log("[openTerminal] Platform:", process.platform);
-        console.log("[openTerminal] Project path:", projectPath);
-        try {
-            if (process.platform === "darwin") {
-                console.log("[openTerminal] Detected macOS - spawning sh with open command");
-                const child = spawnProcess("sh", ["-c", `open -a Terminal '${projectPath}'`], {
-                    detached: true,
-                    stdio: "ignore",
-                });
-                console.log("[openTerminal] Spawn returned, pid:", child.pid);
-                child.unref();
-                console.log("[openTerminal] macOS Terminal opened successfully");
-            }
-            else if (process.platform === "linux") {
-                console.log("[openTerminal] Detected Linux - trying terminal emulators");
-                const terminals = [
-                    {
-                        cmd: "gnome-terminal",
-                        args: ["--working-directory=" + projectPath],
-                    },
-                    {
-                        cmd: "xfce4-terminal",
-                        args: ["--working-directory=" + projectPath],
-                    },
-                    { cmd: "konsole", args: ["--workdir", projectPath] },
-                    { cmd: "xterm", args: ["-e", `sh -c 'cd "${projectPath}" && bash'`] },
-                ];
-                let opened = false;
-                for (const terminal of terminals) {
-                    try {
-                        console.log("[openTerminal] Attempting to spawn:", terminal.cmd);
-                        const child = spawnProcess(terminal.cmd, terminal.args, {
-                            detached: true,
-                            stdio: "ignore",
-                        });
-                        console.log("[openTerminal] Spawn returned, pid:", child.pid);
-                        child.unref();
-                        console.log("[openTerminal] Linux terminal opened with:", terminal.cmd);
-                        opened = true;
-                        break;
-                    }
-                    catch (err) {
-                        console.log("[openTerminal] Failed to open with", terminal.cmd, ":", err instanceof Error ? err.message : String(err));
-                        continue;
-                    }
-                }
-                if (!opened) {
-                    throw new Error("No supported terminal found (gnome-terminal, xfce4-terminal, konsole, or xterm required)");
-                }
-            }
-            else if (process.platform === "win32") {
-                console.log("[openTerminal] Detected Windows - spawning cmd.exe");
-                const child = spawnProcess("cmd.exe", ["/k", `cd /d "${projectPath}"`], {
-                    detached: true,
-                    stdio: "ignore",
-                    shell: true,
-                });
-                console.log("[openTerminal] Spawn returned, pid:", child.pid);
-                child.unref();
-                console.log("[openTerminal] Windows terminal opened successfully");
-            }
-            else {
-                throw new Error(`Unsupported platform: ${process.platform}`);
-            }
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            console.error("[openTerminal] Fatal error:", message);
-            console.error("[openTerminal] Error stack:", error instanceof Error ? error.stack : "No stack trace");
-            throw new Error(`Failed to open terminal: ${message}`);
-        }
-    }
-    async updateOpenWith(projectId, program) {
-        const programError = validateProgram(program);
-        if (programError) {
-            throw new Error(programError);
-        }
-        const projects = await this.metadataManager.loadProjects();
-        const projectIndex = projects.findIndex((p) => p.id === projectId);
-        if (projectIndex === -1) {
-            throw new Error(`Project not found: ${projectId}`);
-        }
-        projects[projectIndex].openWith = program;
-        await this.metadataManager.saveProjects(projects);
-    }
-}
-//# sourceMappingURL=projects.open-with.js.map

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

@@ -1,20 +0,0 @@
-/**
- * Project routes for the REST API
- *
- * Handles all project-related operations:
- * - POST /api/projects - Create a new project
- * - GET /api/projects - List all projects
- * - GET /api/projects/:id - Get project details
- * - DELETE /api/projects/:id - Delete a project
- */
-import { Hono } from "hono";
-import { ProjectManager } from "../projects/projects.manager.js";
-import { ThreadManager } from "../threads/threads.manager.js";
-/**
- * Creates project routes
- * @param projectManager - The ProjectManager instance
- * @param threadManager - The ThreadManager instance
- * @returns Hono router with project routes
- */
-export declare function createProjectRoutes(projectManager: ProjectManager, threadManager: ThreadManager): Hono;
-//# sourceMappingURL=projects.routes.d.ts.map