tarsk 0.3.43 → 0.4.4

package/dist/core/random-words.js

@@ -0,0 +1,135 @@
+/**
+ * Random word generator for thread names
+ *
+ * Generates fun, quirky thread names using two random words
+ */
+/**
+ * List of 100 interesting, cute, funny, or quirky words for thread names
+ */
+const WORD_LIST = [
+    // Cute animals
+    "panda",
+    "koala",
+    "penguin",
+    "bunny",
+    "kitten",
+    "puppy",
+    "hamster",
+    "otter",
+    "hedgehog",
+    "sloth",
+    "dolphin",
+    "owl",
+    "fox",
+    "deer",
+    "koala",
+    "walrus",
+    // Fun adjectives
+    "bouncy",
+    "sparkly",
+    "fluffy",
+    "jolly",
+    "zesty",
+    "peppy",
+    "snappy",
+    "perky",
+    "breezy",
+    "chirpy",
+    "dizzy",
+    "fizzy",
+    "glossy",
+    "groggy",
+    "loopy",
+    "quirky",
+    // Quirky objects
+    "umbrella",
+    "taco",
+    "pickle",
+    "waffle",
+    "bubble",
+    "puzzle",
+    "rocket",
+    "tornado",
+    "volcano",
+    "rainbow",
+    "diamond",
+    "crystal",
+    "lantern",
+    "treasure",
+    "whisper",
+    "echo",
+    // Fun actions
+    "boing",
+    "splat",
+    "whoosh",
+    "crunch",
+    "splash",
+    "jingle",
+    "wiggle",
+    "giggle",
+    "scramble",
+    "tumble",
+    "fumble",
+    "jumble",
+    "rumble",
+    "mumble",
+    "stumble",
+    "hustle",
+    // Interesting places
+    "castle",
+    "island",
+    "mountain",
+    "forest",
+    "meadow",
+    "lagoon",
+    "canyon",
+    "geyser",
+    "oasis",
+    "glacier",
+    "waterfall",
+    "volcano",
+    "tundra",
+    "savanna",
+    "jungle",
+    "desert",
+    // Whimsical concepts
+    "magic",
+    "dream",
+    "wonder",
+    "spark",
+    "glow",
+    "shimmer",
+    "twinkle",
+    "radiance",
+    "harmony",
+    "melody",
+    "rhythm",
+    "symphony",
+    "adventure",
+    "journey",
+    "quest",
+    "odyssey",
+];
+/**
+ * Get a random word from the word list
+ * @returns A random word
+ */
+export function getRandomWord() {
+    return WORD_LIST[Math.floor(Math.random() * WORD_LIST.length)];
+}
+/**
+ * Generate a random thread name using two random words
+ * Format: {word1}-{word2}
+ *
+ * @returns A thread name like "bouncy-panda" or "sparkly-taco"
+ */
+export function generateRandomThreadName() {
+    const word1 = getRandomWord();
+    let word2 = getRandomWord();
+    // Ensure we don't get the same word twice
+    while (word2 === word1) {
+        word2 = getRandomWord();
+    }
+    return `${word1}-${word2}`;
+}
+//# sourceMappingURL=random-words.js.map

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

@@ -0,0 +1,50 @@
+/**
+ * Response builder utility for centralizing API response formatting
+ *
+ * Provides factory methods for creating consistent error and success responses
+ * across all route handlers. This eliminates duplication of response formatting
+ * logic and ensures consistent error handling throughout the API.
+ */
+import type { ErrorResponse } from "@tarsk/shared";
+/**
+ * Factory for building consistent API responses
+ */
+export declare class ResponseBuilder {
+    /**
+     * Creates an error response with standard error structure
+     *
+     * @param code - Machine-readable error code (e.g., 'INVALID_REQUEST', 'NOT_FOUND')
+     * @param message - Human-readable error message
+     * @param statusCode - HTTP status code to return
+     * @param details - Optional additional error context
+     * @returns Object containing both response data and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'Project ID is required', 400);
+     * return c.json(response, statusCode as any);
+     * ```
+     */
+    static error(code: string, message: string, statusCode: number, details?: unknown): {
+        response: ErrorResponse;
+        statusCode: number;
+    };
+    /**
+     * Creates a success response with optional data
+     *
+     * @param data - Response payload data
+     * @param statusCode - HTTP status code (default: 200)
+     * @returns Object containing both response data and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * const { response, statusCode } = ResponseBuilder.success(projects, 200);
+     * return c.json(response, statusCode as any);
+     * ```
+     */
+    static success(data: unknown, statusCode?: number): {
+        response: unknown;
+        statusCode: number;
+    };
+}
+//# sourceMappingURL=response-builder.d.ts.map

package/dist/core/response-builder.js

@@ -0,0 +1,56 @@
+/**
+ * Response builder utility for centralizing API response formatting
+ *
+ * Provides factory methods for creating consistent error and success responses
+ * across all route handlers. This eliminates duplication of response formatting
+ * logic and ensures consistent error handling throughout the API.
+ */
+/**
+ * Factory for building consistent API responses
+ */
+export class ResponseBuilder {
+    /**
+     * Creates an error response with standard error structure
+     *
+     * @param code - Machine-readable error code (e.g., 'INVALID_REQUEST', 'NOT_FOUND')
+     * @param message - Human-readable error message
+     * @param statusCode - HTTP status code to return
+     * @param details - Optional additional error context
+     * @returns Object containing both response data and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * const { response, statusCode } = ResponseBuilder.error('INVALID_REQUEST', 'Project ID is required', 400);
+     * return c.json(response, statusCode as any);
+     * ```
+     */
+    static error(code, message, statusCode, details) {
+        const error = {
+            code,
+            message,
+            timestamp: new Date().toISOString(),
+        };
+        if (details !== undefined) {
+            error.details = details;
+        }
+        const response = { error };
+        return { response, statusCode };
+    }
+    /**
+     * Creates a success response with optional data
+     *
+     * @param data - Response payload data
+     * @param statusCode - HTTP status code (default: 200)
+     * @returns Object containing both response data and HTTP status code
+     *
+     * @example
+     * ```typescript
+     * const { response, statusCode } = ResponseBuilder.success(projects, 200);
+     * return c.json(response, statusCode as any);
+     * ```
+     */
+    static success(data, statusCode = 200) {
+        return { response: data, statusCode };
+    }
+}
+//# sourceMappingURL=response-builder.js.map

package/dist/core/route-helpers.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Route helper utilities for reducing duplication in route handlers
+ *
+ * Provides convenience functions for returning consistent error and success responses
+ * across all API routes, eliminating the need to manually destructure ResponseBuilder
+ * results and cast status codes.
+ */
+import type { Context } from "hono";
+import { ErrorCode } from "./error-responses.js";
+/**
+ * Returns an error response with standard error structure
+ *
+ * @param c - Hono context
+ * @param code - Machine-readable error code from ErrorCodes constants
+ * @param message - Human-readable error message
+ * @param statusCode - HTTP status code to return
+ * @param details - Optional additional error context
+ * @returns Hono JSON response
+ *
+ * @example
+ * ```typescript
+ * return errorResponse(c, ErrorCodes.INVALID_REQUEST, 'Project ID is required', 400);
+ * ```
+ */
+export declare function errorResponse(c: Context, code: ErrorCode, message: string, statusCode: number, details?: unknown): Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">;
+/**
+ * Returns a success response with optional data
+ *
+ * @param c - Hono context
+ * @param data - Response payload data
+ * @param statusCode - HTTP status code (default: 200)
+ * @returns Hono JSON response
+ *
+ * @example
+ * ```typescript
+ * return successResponse(c, { projects });
+ * ```
+ */
+export declare function successResponse(c: Context, data: unknown, statusCode?: number): Response & import("hono").TypedResponse<import("hono/utils/types").JSONValue, any, "json">;
+//# sourceMappingURL=route-helpers.d.ts.map

package/dist/core/route-helpers.js

@@ -0,0 +1,54 @@
+/**
+ * Route helper utilities for reducing duplication in route handlers
+ *
+ * Provides convenience functions for returning consistent error and success responses
+ * across all API routes, eliminating the need to manually destructure ResponseBuilder
+ * results and cast status codes.
+ */
+import { ResponseBuilder } from "./response-builder.js";
+/**
+ * Returns an error response with standard error structure
+ *
+ * @param c - Hono context
+ * @param code - Machine-readable error code from ErrorCodes constants
+ * @param message - Human-readable error message
+ * @param statusCode - HTTP status code to return
+ * @param details - Optional additional error context
+ * @returns Hono JSON response
+ *
+ * @example
+ * ```typescript
+ * return errorResponse(c, ErrorCodes.INVALID_REQUEST, 'Project ID is required', 400);
+ * ```
+ */
+export function errorResponse(c, code, message, statusCode, details) {
+    // Log error to console for debugging
+    if (statusCode >= 500) {
+        console.error(`[${code}] ${message}`, details);
+    }
+    else if (statusCode >= 400) {
+        console.error(`[${code}] ${message}`);
+    }
+    const { response, statusCode: status } = ResponseBuilder.error(code, message, statusCode, details);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return c.json(response, status);
+}
+/**
+ * Returns a success response with optional data
+ *
+ * @param c - Hono context
+ * @param data - Response payload data
+ * @param statusCode - HTTP status code (default: 200)
+ * @returns Hono JSON response
+ *
+ * @example
+ * ```typescript
+ * return successResponse(c, { projects });
+ * ```
+ */
+export function successResponse(c, data, statusCode = 200) {
+    const { response, statusCode: status } = ResponseBuilder.success(data, statusCode);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return c.json(response, status);
+}
+//# sourceMappingURL=route-helpers.js.map

package/dist/core/run-command-detector.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Utility functions for detecting run commands from package.json
+ */
+/**
+ * Detects the package manager used in a project
+ * @param projectPath - Path to the project directory
+ * @returns The package manager name (npm, bun, pnpm, yarn) or 'npm' as default
+ */
+export declare function detectPackageManager(projectPath: string): Promise<string>;
+/**
+ * Detects available run scripts in package.json
+ * @param projectPath - Path to the project directory
+ * @returns Object with available scripts
+ */
+export declare function detectRunScripts(projectPath: string): Promise<{
+    scripts: Record<string, string>;
+    hasStart: boolean;
+    hasDev: boolean;
+}>;
+/**
+ * Suggests a run command based on package.json and detected package manager
+ * @param projectPath - Path to the project directory
+ * @returns Suggested run command or null if none can be detected
+ */
+export declare function suggestRunCommand(projectPath: string): Promise<string | null>;
+//# sourceMappingURL=run-command-detector.d.ts.map

package/dist/core/run-command-detector.js

@@ -0,0 +1,98 @@
+/**
+ * Utility functions for detecting run commands from package.json
+ */
+import { readFile } from "fs/promises";
+import { join } from "path";
+/**
+ * Detects the package manager used in a project
+ * @param projectPath - Path to the project directory
+ * @returns The package manager name (npm, bun, pnpm, yarn) or 'npm' as default
+ */
+export async function detectPackageManager(projectPath) {
+    try {
+        const packageJsonPath = join(projectPath, "package.json");
+        const content = await readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        // Check packageManager field (npm v7+, yarn berry, pnpm)
+        if (packageJson.packageManager) {
+            const pm = packageJson.packageManager.split("@")[0];
+            if (["npm", "yarn", "pnpm", "bun"].includes(pm)) {
+                return pm;
+            }
+        }
+        // Try to detect from lock files
+        // This would require file system checks, but for now we'll use heuristics
+        // from package.json structure
+        // Default to npm
+        return "npm";
+    }
+    catch {
+        // Default to npm if package.json doesn't exist or can't be read
+        return "npm";
+    }
+}
+/**
+ * Detects available run scripts in package.json
+ * @param projectPath - Path to the project directory
+ * @returns Object with available scripts
+ */
+export async function detectRunScripts(projectPath) {
+    try {
+        const packageJsonPath = join(projectPath, "package.json");
+        const content = await readFile(packageJsonPath, "utf-8");
+        const packageJson = JSON.parse(content);
+        const scripts = packageJson.scripts ?? {};
+        return {
+            scripts,
+            hasStart: "start" in scripts,
+            hasDev: "dev" in scripts,
+        };
+    }
+    catch {
+        return {
+            scripts: {},
+            hasStart: false,
+            hasDev: false,
+        };
+    }
+}
+/**
+ * Suggests a run command based on package.json and detected package manager
+ * @param projectPath - Path to the project directory
+ * @returns Suggested run command or null if none can be detected
+ */
+export async function suggestRunCommand(projectPath) {
+    try {
+        const pm = await detectPackageManager(projectPath);
+        const { hasDev, hasStart } = await detectRunScripts(projectPath);
+        // Prefer 'dev' script, then 'start' script
+        if (hasDev) {
+            if (pm === "npm" || pm === "yarn") {
+                return `${pm} run dev`;
+            }
+            else if (pm === "pnpm") {
+                return `pnpm dev`;
+            }
+            else if (pm === "bun") {
+                return `bun run dev`;
+            }
+        }
+        if (hasStart) {
+            if (pm === "npm" || pm === "yarn") {
+                return `${pm} start`;
+            }
+            else if (pm === "pnpm") {
+                return `pnpm start`;
+            }
+            else if (pm === "bun") {
+                return `bun run start`;
+            }
+        }
+        // If no dev or start script, return null
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=run-command-detector.js.map

package/dist/core/stream-helper.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Stream helper utilities for handling async generator streaming responses
+ *
+ * Centralizes streaming logic to avoid duplication across route handlers
+ */
+import { Context } from "hono";
+import { stream } from "hono/streaming";
+/**
+ * Options for streaming async generators
+ */
+export interface StreamOptions<T> {
+    /**
+     * Custom error event formatter
+     * If not provided, defaults to { type: 'error', message: ... }
+     */
+    onError?: (error: Error) => T;
+    /**
+     * Optional abort controller to support cancellation when client disconnects
+     * The controller will be aborted when the stream is closed by the client
+     */
+    abortController?: AbortController;
+}
+/**
+ * Streams an async generator as newline-delimited JSON
+ *
+ * Handles:
+ * - Iterating through async generator
+ * - Serializing each event to JSON
+ * - Writing newline-delimited format
+ * - Error handling and recovery
+ * - Proper stream cleanup
+ *
+ * @param c - Hono context
+ * @param generator - Async generator yielding events
+ * @param options - Optional configuration
+ * @returns Hono response
+ *
+ * @example
+ * ```typescript
+ * return StreamHelper.streamAsyncGenerator(c, projectManager.createProject(gitUrl));
+ * ```
+ */
+export declare function streamAsyncGenerator<T>(c: Context, generator: AsyncGenerator<T>, options?: StreamOptions<T>): ReturnType<typeof stream>;
+//# sourceMappingURL=stream-helper.d.ts.map

package/dist/core/stream-helper.js

@@ -0,0 +1,50 @@
+/**
+ * Stream helper utilities for handling async generator streaming responses
+ *
+ * Centralizes streaming logic to avoid duplication across route handlers
+ */
+import { stream } from "hono/streaming";
+/**
+ * Streams an async generator as newline-delimited JSON
+ *
+ * Handles:
+ * - Iterating through async generator
+ * - Serializing each event to JSON
+ * - Writing newline-delimited format
+ * - Error handling and recovery
+ * - Proper stream cleanup
+ *
+ * @param c - Hono context
+ * @param generator - Async generator yielding events
+ * @param options - Optional configuration
+ * @returns Hono response
+ *
+ * @example
+ * ```typescript
+ * return StreamHelper.streamAsyncGenerator(c, projectManager.createProject(gitUrl));
+ * ```
+ */
+export function streamAsyncGenerator(c, generator, options) {
+    return stream(c, async (writer) => {
+        // Set up abort handling if an abort controller was provided
+        if (options?.abortController) {
+            writer.onAbort(() => {
+                console.log("[stream] Client disconnected, aborting stream");
+                options.abortController?.abort();
+            });
+        }
+        try {
+            for await (const event of generator) {
+                await writer.write(JSON.stringify(event) + "\n");
+            }
+        }
+        catch (error) {
+            const errorEvent = options?.onError?.(error) ?? {
+                type: "error",
+                message: error instanceof Error ? error.message : String(error),
+            };
+            await writer.write(JSON.stringify(errorEvent) + "\n");
+        }
+    });
+}
+//# sourceMappingURL=stream-helper.js.map

package/dist/core/utils.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Utility functions for the CLI
+ */
+import { SpawnOptions } from "child_process";
+/**
+ * Delays execution for a specified number of milliseconds
+ * @param ms - Number of milliseconds to delay
+ * @returns Promise that resolves after the delay
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Spawns a child process with proper environment inheritance
+ * This ensures that processes like npm, git, etc. can be found in PATH
+ *
+ * @param command - The command to run
+ * @param args - Arguments for the command
+ * @param options - Additional spawn options
+ * @returns The spawned child process
+ */
+export declare function spawnProcess(command: string, args: string[], options?: SpawnOptions & {
+    env?: Record<string, string>;
+}): import("child_process").ChildProcess;
+/**
+ * Spawns a child process with shell option and proper environment inheritance
+ *
+ * @param command - The command to run (can include shell operators)
+ * @param options - Additional spawn options
+ * @returns The spawned child process
+ */
+export declare function spawnShell(command: string, options?: SpawnOptions & {
+    env?: Record<string, string>;
+}): import("child_process").ChildProcess;
+/**
+ * Spawns a synchronous child process with proper environment inheritance
+ * This ensures that processes like npm, git, etc. can be found in PATH
+ *
+ * @param command - The command to run
+ * @param args - Arguments for the command
+ * @param options - Additional spawnSync options
+ * @returns The result of the synchronous process
+ */
+export declare function spawnSyncProcess(command: string, args: string[], options?: import("child_process").SpawnSyncOptions): import("child_process").SpawnSyncReturns<string | NonSharedBuffer>;
+//# sourceMappingURL=utils.d.ts.map