tarsk 0.4.4 → 0.4.6

package/dist/features/projects/projects.creator.js

@@ -1,555 +0,0 @@
-/**
- * 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 { randomUUID } from "crypto";
-import { basename, join, relative } from "path";
-import { access, stat, readdir } from "fs/promises";
-import { spawnSyncProcess } from "../../core/utils.js";
-import { CommitMethods } from "@tarsk/shared";
-import { getSetupScriptForPackageManager, isValidPackageManager } from "@tarsk/shared";
-import { createScaffoldedProjectStreaming } from "../scaffold/scaffold.runner.js";
-import { generateRandomThreadName } from "../../core/random-words.js";
-let Utils = null;
-let utilsLoaded = false;
-// Lazy load Utils from electrobun (optional - may not be available in pure server mode)
-async function loadUtils() {
-    if (utilsLoaded)
-        return;
-    utilsLoaded = true;
-    try {
-        const electrobun = await import("electrobun/bun");
-        Utils = electrobun.Utils;
-    }
-    catch {
-        // electrobun not available in pure server mode - that's OK
-    }
-}
-export class ProjectCreator {
-    rootFolder;
-    metadataManager;
-    gitManager;
-    processingStateManager;
-    runCommandCallbacks;
-    constructor(rootFolder, metadataManager, gitManager, processingStateManager, runCommandCallbacks) {
-        this.rootFolder = rootFolder;
-        this.metadataManager = metadataManager;
-        this.gitManager = gitManager;
-        this.processingStateManager = processingStateManager;
-        this.runCommandCallbacks = runCommandCallbacks;
-    }
-    async *createProject(gitUrl, commitMethod = CommitMethods.PullRequest) {
-        if (!this.gitManager.validateGitUrl(gitUrl)) {
-            yield {
-                type: "error",
-                message: `Invalid git URL format: ${gitUrl}`,
-            };
-            return;
-        }
-        let initialThreadId;
-        try {
-            const projectId = randomUUID();
-            const existingProjects = await this.metadataManager.loadProjects();
-            const existingNames = existingProjects.map((p) => p.name);
-            const projectName = this.ensureUniqueProjectName(this.deriveProjectName(gitUrl), existingNames);
-            initialThreadId = randomUUID();
-            const initialThreadTitle = generateRandomThreadName();
-            const firstThreadPath = this.generateThreadPath(projectId, initialThreadId);
-            this.processingStateManager?.setProcessing(initialThreadId);
-            yield {
-                type: "progress",
-                message: `Creating project "${projectName}" from ${gitUrl}...`,
-                threadId: initialThreadId,
-                projectId,
-            };
-            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}`,
-                    };
-                    return;
-                }
-                else if (gitEvent.type === "stdout" || gitEvent.type === "stderr") {
-                    yield {
-                        type: "progress",
-                        message: gitEvent.data,
-                    };
-                }
-            }
-            let branchName = "main";
-            if (commitMethod === CommitMethods.PullRequest) {
-                const initialThreadTitle = generateRandomThreadName();
-                branchName = this.gitManager.sanitizeBranchName(initialThreadTitle);
-                yield {
-                    type: "progress",
-                    message: `Creating initial branch "${branchName}"...`,
-                };
-                let branchExists = await this.gitManager.checkBranchExists(firstThreadPath, branchName);
-                let counter = 2;
-                const baseBranchName = branchName;
-                while (branchExists) {
-                    branchName = `${baseBranchName}-${counter}`;
-                    branchExists = await this.gitManager.checkBranchExists(firstThreadPath, branchName);
-                    counter++;
-                }
-                if (branchName !== baseBranchName) {
-                    yield {
-                        type: "progress",
-                        message: `Branch "${baseBranchName}" exists, using "${branchName}" instead`,
-                    };
-                }
-                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}`,
-                        };
-                        return;
-                    }
-                    else if (gitEvent.type === "stdout" || gitEvent.type === "stderr") {
-                        yield {
-                            type: "progress",
-                            message: gitEvent.data,
-                        };
-                    }
-                }
-                yield {
-                    type: "progress",
-                    message: `Branch "${branchName}" created and checked out`,
-                };
-            }
-            else {
-                yield {
-                    type: "progress",
-                    message: `Direct commit mode enabled - commits will go to the main branch`,
-                };
-            }
-            const suggestedSetupScript = await this.detectSetupScript(firstThreadPath);
-            // Collect all setup scripts for multiple installations
-            const allSetupScripts = [];
-            await this.findAllPackageJsonFiles(firstThreadPath, firstThreadPath, allSetupScripts);
-            const project = {
-                id: projectId,
-                name: projectName,
-                gitUrl,
-                path: firstThreadPath,
-                createdAt: new Date(),
-                threads: [initialThreadId],
-                commitMethod,
-                setupScript: suggestedSetupScript ?? undefined,
-                pendingSetupScripts: allSetupScripts.length > 1 ? allSetupScripts.slice(1) : undefined,
-            };
-            const initialThread = {
-                id: initialThreadId,
-                projectId,
-                title: initialThreadTitle,
-                path: firstThreadPath,
-                currentBranch: branchName,
-                createdAt: new Date(),
-            };
-            const projects = await this.metadataManager.loadProjects();
-            projects.push(project);
-            await this.metadataManager.saveProjects(projects);
-            const threads = await this.metadataManager.loadThreads();
-            threads.push(initialThread);
-            await this.metadataManager.saveThreads(threads);
-            try {
-                const suggestedRun = await this.runCommandCallbacks?.suggestRunCommand(projectId);
-                if (suggestedRun) {
-                    await this.runCommandCallbacks?.updateRunCommand(projectId, suggestedRun);
-                    project.runCommand = suggestedRun;
-                }
-            }
-            catch {
-                // Non-fatal
-            }
-            yield {
-                type: "progress",
-                message: `Project "${projectName}" created successfully with initial thread`,
-            };
-            this.processingStateManager?.clearProcessing(initialThreadId);
-            yield {
-                type: "complete",
-                message: "Project creation complete",
-                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)}`,
-            };
-        }
-    }
-    async *createProjectFromScaffold(projectName, templateId, packageManager) {
-        if (!isValidPackageManager(packageManager)) {
-            yield {
-                type: "error",
-                message: `Invalid package manager: ${packageManager}`,
-            };
-            return;
-        }
-        const projectId = randomUUID();
-        const initialThreadId = randomUUID();
-        const initialThreadTitle = generateRandomThreadName();
-        this.processingStateManager?.setProcessing(initialThreadId);
-        try {
-            const existingProjects = await this.metadataManager.loadProjects();
-            const existingNames = existingProjects.map((p) => p.name);
-            const uniqueProjectName = this.ensureUniqueProjectName(projectName, existingNames);
-            yield {
-                type: "progress",
-                message: `Scaffolding project "${uniqueProjectName}"...`,
-                threadId: initialThreadId,
-                projectId,
-            };
-            let result = null;
-            for await (const event of createScaffoldedProjectStreaming({
-                parentDir: this.rootFolder,
-                projectName: uniqueProjectName, // Use the actual project name, not thread ID
-                threadId: initialThreadId,
-                templateId,
-                packageManager: packageManager,
-            })) {
-                if (event.type === "progress") {
-                    yield {
-                        type: "progress",
-                        message: event.message,
-                        threadId: initialThreadId,
-                        projectId,
-                    };
-                }
-                else {
-                    result = event.result;
-                    break;
-                }
-            }
-            if (!result?.success) {
-                this.processingStateManager?.clearProcessing(initialThreadId);
-                yield {
-                    type: "error",
-                    message: result?.error ?? "Scaffold failed",
-                };
-                return;
-            }
-            const firstThreadPath = this.generateThreadPath(projectId, initialThreadId);
-            yield {
-                type: "progress",
-                message: `Scaffolding project in folder: ${firstThreadPath}`,
-            };
-            yield {
-                type: "progress",
-                message: "Initializing git repository...",
-            };
-            await this.gitManager.initRepository(firstThreadPath);
-            const project = {
-                id: projectId,
-                name: uniqueProjectName,
-                gitUrl: "",
-                path: firstThreadPath,
-                createdAt: new Date(),
-                threads: [initialThreadId],
-                setupScript: getSetupScriptForPackageManager(packageManager),
-            };
-            const initialThread = {
-                id: initialThreadId,
-                projectId,
-                title: initialThreadTitle,
-                path: firstThreadPath,
-                currentBranch: "main",
-                createdAt: new Date(),
-            };
-            const projects = await this.metadataManager.loadProjects();
-            projects.push(project);
-            await this.metadataManager.saveProjects(projects);
-            const threads = await this.metadataManager.loadThreads();
-            threads.push(initialThread);
-            await this.metadataManager.saveThreads(threads);
-            try {
-                const suggestedRun = await this.runCommandCallbacks?.suggestRunCommand(projectId);
-                if (suggestedRun) {
-                    await this.runCommandCallbacks?.updateRunCommand(projectId, suggestedRun);
-                    project.runCommand = suggestedRun;
-                }
-            }
-            catch {
-                // Non-fatal
-            }
-            this.processingStateManager?.clearProcessing(initialThreadId);
-            yield {
-                type: "progress",
-                message: `Project "${uniqueProjectName}" created successfully with initial thread`,
-            };
-            yield {
-                type: "complete",
-                message: "Project creation complete",
-                project,
-            };
-        }
-        catch (error) {
-            this.processingStateManager?.clearProcessing(initialThreadId);
-            yield {
-                type: "error",
-                message: `Failed to create project: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    ensureUniqueProjectName(proposedName, existingNames) {
-        const normalized = (s) => s.trim().toLowerCase();
-        const taken = new Set(existingNames.map(normalized));
-        const name = proposedName.trim();
-        if (!taken.has(normalized(name)))
-            return name;
-        let counter = 2;
-        let candidate;
-        do {
-            candidate = `${name} ${counter}`;
-            counter++;
-        } while (taken.has(normalized(candidate)));
-        return candidate;
-    }
-    deriveProjectName(gitUrl) {
-        let name = gitUrl.replace(/\.git$/, "");
-        const parts = name.split(/[/:]/).filter((p) => p.length > 0);
-        name = parts[parts.length - 1] || "project";
-        name = name.replace(/[^a-zA-Z0-9._-]/g, "-");
-        return name;
-    }
-    generateThreadPath(_projectId, threadId) {
-        return join(this.rootFolder, threadId);
-    }
-    async *createProjectFromFolder() {
-        // Load utils (may fail gracefully if electrobun not available)
-        await loadUtils();
-        if (!Utils) {
-            yield { type: "error", message: "File dialog not available in server mode" };
-            return;
-        }
-        const chosenPaths = await Utils.openFileDialog({
-            canChooseFiles: false,
-            canChooseDirectory: true,
-            allowsMultipleSelection: false,
-        });
-        if (!chosenPaths || chosenPaths.length === 0) {
-            yield { type: "error", message: "No folder selected" };
-            return;
-        }
-        const folderPath = chosenPaths[0];
-        // Verify the path is a valid directory
-        try {
-            const stats = await stat(folderPath);
-            if (!stats.isDirectory()) {
-                yield { type: "error", message: `Selected path is not a directory: ${folderPath}` };
-                return;
-            }
-        }
-        catch {
-            yield { type: "error", message: `Cannot access folder: ${folderPath}` };
-            return;
-        }
-        const projectId = randomUUID();
-        const initialThreadId = randomUUID();
-        const initialThreadTitle = generateRandomThreadName();
-        this.processingStateManager?.setProcessing(initialThreadId);
-        try {
-            const existingProjects = await this.metadataManager.loadProjects();
-            const existingNames = existingProjects.map((p) => p.name);
-            const projectName = this.ensureUniqueProjectName(basename(folderPath) || "project", existingNames);
-            yield {
-                type: "progress",
-                message: `Opening folder "${projectName}"...`,
-                threadId: initialThreadId,
-                projectId,
-            };
-            // Check if the folder is already a git repo
-            const isGitRepo = this.isGitRepository(folderPath);
-            if (!isGitRepo) {
-                yield { type: "progress", message: "Initializing git repository..." };
-                await this.gitManager.initRepository(folderPath);
-            }
-            else {
-                yield { type: "progress", message: "Git repository detected" };
-            }
-            // Detect current branch
-            let branchName = "main";
-            if (isGitRepo) {
-                try {
-                    const result = spawnSyncProcess("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
-                        cwd: folderPath,
-                        encoding: "utf-8",
-                    });
-                    if (result.status === 0 &&
-                        (typeof result.stdout === "string"
-                            ? result.stdout
-                            : result.stdout?.toString() || "").trim()) {
-                        branchName = (typeof result.stdout === "string" ? result.stdout : result.stdout?.toString() || "").trim();
-                    }
-                }
-                catch {
-                    // Use default
-                }
-            }
-            // Detect if there's a remote git URL
-            let gitUrl = "";
-            if (isGitRepo) {
-                try {
-                    const result = spawnSyncProcess("git", ["remote", "get-url", "origin"], {
-                        cwd: folderPath,
-                        encoding: "utf-8",
-                    });
-                    if (result.status === 0 &&
-                        (typeof result.stdout === "string"
-                            ? result.stdout
-                            : result.stdout?.toString() || "").trim()) {
-                        gitUrl = (typeof result.stdout === "string" ? result.stdout : result.stdout?.toString() || "").trim();
-                    }
-                }
-                catch {
-                    // No remote
-                }
-            }
-            const suggestedSetupScript = await this.detectSetupScript(folderPath);
-            // Collect all setup scripts for multiple installations
-            const allSetupScripts = [];
-            await this.findAllPackageJsonFiles(folderPath, folderPath, allSetupScripts);
-            const project = {
-                id: projectId,
-                name: projectName,
-                gitUrl,
-                path: folderPath,
-                createdAt: new Date(),
-                threads: [initialThreadId],
-                commitMethod: CommitMethods.Direct,
-                setupScript: suggestedSetupScript ?? undefined,
-                pendingSetupScripts: allSetupScripts.length > 1 ? allSetupScripts.slice(1) : undefined,
-            };
-            const initialThread = {
-                id: initialThreadId,
-                projectId,
-                title: initialThreadTitle,
-                path: folderPath,
-                currentBranch: branchName,
-                createdAt: new Date(),
-            };
-            const projects = await this.metadataManager.loadProjects();
-            projects.push(project);
-            await this.metadataManager.saveProjects(projects);
-            const threads = await this.metadataManager.loadThreads();
-            threads.push(initialThread);
-            await this.metadataManager.saveThreads(threads);
-            try {
-                const suggestedRun = await this.runCommandCallbacks?.suggestRunCommand(projectId);
-                if (suggestedRun) {
-                    await this.runCommandCallbacks?.updateRunCommand(projectId, suggestedRun);
-                    project.runCommand = suggestedRun;
-                }
-            }
-            catch {
-                // Non-fatal
-            }
-            yield {
-                type: "progress",
-                message: `Project "${projectName}" created successfully from folder`,
-            };
-            this.processingStateManager?.clearProcessing(initialThreadId);
-            yield {
-                type: "complete",
-                message: "Project creation complete",
-                project,
-                suggestedSetupScript: suggestedSetupScript ?? undefined,
-            };
-        }
-        catch (error) {
-            this.processingStateManager?.clearProcessing(initialThreadId);
-            yield {
-                type: "error",
-                message: `Failed to create project from folder: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    }
-    isGitRepository(dirPath) {
-        const result = spawnSyncProcess("git", ["rev-parse", "--is-inside-work-tree"], {
-            cwd: dirPath,
-            encoding: "utf-8",
-        });
-        return result.status === 0;
-    }
-    async detectSetupScript(chrootPath) {
-        // Find all package.json files recursively
-        const allSetupScripts = [];
-        await this.findAllPackageJsonFiles(chrootPath, chrootPath, allSetupScripts);
-        // Return null if no package.json files found
-        if (allSetupScripts.length === 0) {
-            return null;
-        }
-        // Return the first one for immediate use
-        return allSetupScripts[0];
-    }
-    async findAllPackageJsonFiles(rootPath, currentPath, setupScripts) {
-        try {
-            // Check if package.json exists in current directory
-            await access(join(currentPath, "package.json"));
-            // Determine relative path from root
-            const relativePath = relative(rootPath, currentPath);
-            // Detect package manager for this package.json
-            let installCommand = "";
-            try {
-                await access(join(currentPath, "yarn.lock"));
-                installCommand = "yarn install";
-            }
-            catch {
-                try {
-                    await access(join(currentPath, "bun.lock"));
-                    installCommand = "bun install";
-                }
-                catch {
-                    try {
-                        await access(join(currentPath, "pnpm-lock.yaml"));
-                        installCommand = "pnpm install";
-                    }
-                    catch {
-                        installCommand = "npm install";
-                    }
-                }
-            }
-            // Add command with path if not in root
-            if (relativePath) {
-                setupScripts.push(`cd "${relativePath}" && ${installCommand}`);
-            }
-            else {
-                setupScripts.push(installCommand);
-            }
-        }
-        catch {
-            // No package.json in this directory, continue searching subdirectories
-        }
-        // Recursively search subdirectories
-        try {
-            const entries = await readdir(currentPath);
-            for (const entry of entries) {
-                const entryPath = join(currentPath, entry);
-                try {
-                    const stats = await stat(entryPath);
-                    if (stats.isDirectory() && !entry.startsWith(".") && entry !== "node_modules") {
-                        await this.findAllPackageJsonFiles(rootPath, entryPath, setupScripts);
-                    }
-                }
-                catch {
-                    // Skip directories that can't be accessed
-                    continue;
-                }
-            }
-        }
-        catch {
-            // Skip directories that can't be read
-        }
-    }
-}
-//# sourceMappingURL=projects.creator.js.map

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

@@ -1,61 +0,0 @@
-/**
- * SQLite Database Operations for Projects
- *
- * This module handles all CRUD operations for projects in the SQLite database.
- * Includes transaction support for atomic operations.
- */
-import { Project } from "@tarsk/shared";
-import { Database } from "../../database/database.types";
-/**
- * Insert a new project into the database
- * @param db SQLite database instance
- * @param project Project to insert
- */
-export declare function insertProject(db: Database, project: Project): Promise<void>;
-/**
- * Update an existing project in the database
- * @param db SQLite database instance
- * @param id Project ID
- * @param updates Partial project object with fields to update
- */
-export declare function updateProject(db: Database, id: string, updates: Partial<Project>): Promise<void>;
-/**
- * Delete a project and cascade delete associated threads
- * @param db SQLite database instance
- * @param id Project ID
- */
-export declare function deleteProject(db: Database, id: string): Promise<void>;
-/**
- * Get a single project by ID
- * @param db SQLite database instance
- * @param id Project ID
- * @returns Project object or null if not found
- */
-export declare function getProject(db: Database, id: string): Promise<Project | null>;
-/**
- * Get all projects from the database
- * @param db SQLite database instance
- * @returns Array of all projects
- */
-export declare function getAllProjects(db: Database): Promise<Project[]>;
-/**
- * Get threads for a specific project
- * @param db SQLite database instance
- * @param projectId Project ID
- * @returns Array of thread IDs
- */
-export declare function getProjectThreadIds(db: Database, projectId: string): Promise<string[]>;
-/**
- * Check if a project exists
- * @param db SQLite database instance
- * @param id Project ID
- * @returns True if project exists
- */
-export declare function projectExists(db: Database, id: string): Promise<boolean>;
-/**
- * Get project count
- * @param db SQLite database instance
- * @returns Number of projects
- */
-export declare function getProjectCount(db: Database): Promise<number>;
-//# sourceMappingURL=projects.database.d.ts.map