tarsk 0.4.4 → 0.4.6

package/dist/core/random-words.js

@@ -1,135 +0,0 @@
-/**
- * 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

@@ -1,50 +0,0 @@
-/**
- * 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

@@ -1,56 +0,0 @@
-/**
- * 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

@@ -1,47 +0,0 @@
-/**
- * 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

@@ -1,54 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,98 +0,0 @@
-/**
- * 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

@@ -1,44 +0,0 @@
-/**
- * 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

@@ -1,50 +0,0 @@
-/**
- * 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

@@ -1,43 +0,0 @@
-/**
- * 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