tarsk 0.3.43 → 0.4.4

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

@@ -0,0 +1,24 @@
+/**
+ * PUT /api/projects/:id/run-command
+ * Update the run command for a project
+ */
+import { errorResponse, successResponse } from "../../core/route-helpers.js";
+import { ErrorCodes } from "../../core/error-responses.js";
+export async function putRunCommand(c, projectManager) {
+    try {
+        const projectId = c.req.param("id");
+        if (!projectId) {
+            return errorResponse(c, ErrorCodes.INVALID_REQUEST, "Project ID is required", 400);
+        }
+        const body = await c.req.json();
+        const { runCommand } = body;
+        const normalizedRunCommand = typeof runCommand === "string" && runCommand.trim().length > 0 ? runCommand.trim() : null;
+        await projectManager.updateRunCommand(projectId, normalizedRunCommand);
+        return successResponse(c, { success: true, message: "Run command updated" });
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return errorResponse(c, ErrorCodes.UPDATE_RUN_COMMAND_ERROR, "Failed to update run command", 500, errorMessage);
+    }
+}
+//# sourceMappingURL=run-put-command.route.js.map

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

@@ -0,0 +1,19 @@
+/**
+ * Run/Stop routes for managing dev server processes
+ *
+ * Handles:
+ * - POST /api/projects/:id/run-suggest - Suggest a run command
+ * - POST /api/projects/:id/run - Start the dev server
+ * - POST /api/projects/:id/stop - Stop the dev server
+ * - GET /api/projects/:id/running - Check if a process is running
+ * - PUT /api/projects/:id/run-command - Update the run command
+ */
+import { Hono } from "hono";
+import type { ProjectManager } from "../projects/projects.manager.js";
+/**
+ * Creates run/stop routes
+ * @param projectManager - The ProjectManager instance
+ * @returns Hono router with run/stop routes
+ */
+export declare function createRunRoutes(projectManager: ProjectManager): Hono;
+//# sourceMappingURL=run.routes.d.ts.map

package/dist/features/run/run.routes.js

@@ -0,0 +1,31 @@
+/**
+ * Run/Stop routes for managing dev server processes
+ *
+ * Handles:
+ * - POST /api/projects/:id/run-suggest - Suggest a run command
+ * - POST /api/projects/:id/run - Start the dev server
+ * - POST /api/projects/:id/stop - Stop the dev server
+ * - GET /api/projects/:id/running - Check if a process is running
+ * - PUT /api/projects/:id/run-command - Update the run command
+ */
+import { Hono } from "hono";
+import { postRunSuggest } from "./run-post-suggest.route.js";
+import { postRunStart } from "./run-post-start.route.js";
+import { postRunStop } from "./run-post-stop.route.js";
+import { getRunning } from "./run-get-running.route.js";
+import { putRunCommand } from "./run-put-command.route.js";
+/**
+ * Creates run/stop routes
+ * @param projectManager - The ProjectManager instance
+ * @returns Hono router with run/stop routes
+ */
+export function createRunRoutes(projectManager) {
+    const router = new Hono();
+    router.post("/:id/run-suggest", (c) => postRunSuggest(c, projectManager));
+    router.post("/:id/run", (c) => postRunStart(c, projectManager));
+    router.post("/:id/stop", (c) => postRunStop(c, projectManager));
+    router.get("/:id/running", (c) => getRunning(c, projectManager));
+    router.put("/:id/run-command", (c) => putRunCommand(c, projectManager));
+    return router;
+}
+//# sourceMappingURL=run.routes.js.map

package/dist/features/scaffold/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Scaffold (create project) module
+ */
+export { createScaffoldedProject, getScaffoldTemplates, registerScaffoldHandler, } from "./scaffold.runner.js";
+export type { CreateScaffoldedProjectResult } from "./scaffold.runner.js";
+export type { TemplateEntry, ScaffoldOptions, ScaffoldHandler } from "./scaffold.types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/features/scaffold/index.js

@@ -0,0 +1,5 @@
+/**
+ * Scaffold (create project) module
+ */
+export { createScaffoldedProject, getScaffoldTemplates, registerScaffoldHandler, } from "./scaffold.runner.js";
+//# sourceMappingURL=index.js.map

package/dist/features/scaffold/scaffold-get-templates.route.d.ts

@@ -0,0 +1,27 @@
+/**
+ * GET /api/scaffold/templates
+ * List available scaffold templates
+ */
+import type { Context } from "hono";
+export declare function getScaffoldTemplatesRoute(c: Context): Promise<(Response & import("hono").TypedResponse<{
+    templates: {
+        id: string;
+        type: string;
+        typeName: string;
+        variation: string;
+        variationName: string;
+        description: string;
+        url?: string | undefined;
+        commands?: string[] | undefined;
+        handler?: string | undefined;
+        threadId?: string | undefined;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, 500, "json">)>;
+//# sourceMappingURL=scaffold-get-templates.route.d.ts.map

package/dist/features/scaffold/scaffold-get-templates.route.js

@@ -0,0 +1,17 @@
+/**
+ * GET /api/scaffold/templates
+ * List available scaffold templates
+ */
+import { ResponseBuilder } from "../../core/response-builder.js";
+import { getScaffoldTemplates } from "./scaffold.runner.js";
+export async function getScaffoldTemplatesRoute(c) {
+    try {
+        const templates = getScaffoldTemplates();
+        return c.json({ templates });
+    }
+    catch (error) {
+        const { response, statusCode } = ResponseBuilder.error("SCAFFOLD_ERROR", error instanceof Error ? error.message : String(error), 500);
+        return c.json(response, statusCode);
+    }
+}
+//# sourceMappingURL=scaffold-get-templates.route.js.map

package/dist/features/scaffold/scaffold-post.route.d.ts

@@ -0,0 +1,8 @@
+/**
+ * POST /api/scaffold
+ * Create project from scaffold (streams ProjectEvent)
+ */
+import type { Context } from "hono";
+import type { ProjectManager } from "../projects/projects.manager.js";
+export declare function postScaffold(c: Context, projectManager: ProjectManager): Promise<Response>;
+//# sourceMappingURL=scaffold-post.route.d.ts.map

package/dist/features/scaffold/scaffold-post.route.js

@@ -0,0 +1,30 @@
+/**
+ * POST /api/scaffold
+ * Create project from scaffold (streams ProjectEvent)
+ */
+import { streamAsyncGenerator } from "../../core/stream-helper.js";
+import { ResponseBuilder } from "../../core/response-builder.js";
+export async function postScaffold(c, projectManager) {
+    try {
+        const body = await c.req.json();
+        const { projectName, templateId, packageManager } = body;
+        if (!projectName || typeof projectName !== "string" || !projectName.trim()) {
+            const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "projectName is required and must be a non-empty string", 400);
+            return c.json(response, statusCode);
+        }
+        if (!templateId || typeof templateId !== "string") {
+            const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "templateId is required and must be a string", 400);
+            return c.json(response, statusCode);
+        }
+        if (!packageManager || typeof packageManager !== "string") {
+            const { response, statusCode } = ResponseBuilder.error("INVALID_REQUEST", "packageManager is required and must be a string", 400);
+            return c.json(response, statusCode);
+        }
+        return streamAsyncGenerator(c, projectManager.createProjectFromScaffold(projectName.trim(), templateId, packageManager));
+    }
+    catch (error) {
+        const { response, statusCode } = ResponseBuilder.error("REQUEST_PARSE_ERROR", "Failed to parse request body", 400, error instanceof Error ? error.message : String(error));
+        return c.json(response, statusCode);
+    }
+}
+//# sourceMappingURL=scaffold-post.route.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Scaffold routes for creating web apps from templates
+ *
+ * - GET /api/scaffold/templates - List available scaffold templates
+ * - POST /api/scaffold - Create project from scaffold (streams ProjectEvent)
+ */
+import { Hono } from "hono";
+import type { ProjectManager } from "../projects/projects.manager.js";
+export declare function createScaffoldRoutes(projectManager: ProjectManager): Hono;
+//# sourceMappingURL=scaffold.routes.d.ts.map

package/dist/features/scaffold/scaffold.routes.js

@@ -0,0 +1,16 @@
+/**
+ * Scaffold routes for creating web apps from templates
+ *
+ * - GET /api/scaffold/templates - List available scaffold templates
+ * - POST /api/scaffold - Create project from scaffold (streams ProjectEvent)
+ */
+import { Hono } from "hono";
+import { getScaffoldTemplatesRoute } from "./scaffold-get-templates.route.js";
+import { postScaffold } from "./scaffold-post.route.js";
+export function createScaffoldRoutes(projectManager) {
+    const router = new Hono();
+    router.get("/templates", (c) => getScaffoldTemplatesRoute(c));
+    router.post("/", (c) => postScaffold(c, projectManager));
+    return router;
+}
+//# sourceMappingURL=scaffold.routes.js.map

package/dist/features/scaffold/scaffold.runner.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Scaffold runner: creates projects from the template catalog
+ * with placeholder substitution, package manager rewriting, and optional handlers.
+ */
+import type { PackageManager } from "@tarsk/shared";
+import type { TemplateEntry, ScaffoldHandler } from "./scaffold.types.js";
+/**
+ * Register a handler for templates that use the given handler name.
+ * When a template has `handler` set, the runner calls this callback to get the command list.
+ */
+export declare function registerScaffoldHandler(handlerName: string, callback: ScaffoldHandler): void;
+export interface CreateScaffoldedProjectResult {
+    success: boolean;
+    projectPath: string;
+    error?: string;
+}
+/**
+ * Create a project from a template. Runs scaffold commands then install in the project folder.
+ */
+export declare function createScaffoldedProject(options: {
+    parentDir: string;
+    projectName: string;
+    threadId: string;
+    templateId: string;
+    packageManager: PackageManager;
+}): Promise<CreateScaffoldedProjectResult>;
+export type ScaffoldStreamEvent = {
+    type: "progress";
+    message: string;
+} | {
+    type: "result";
+    result: CreateScaffoldedProjectResult;
+};
+/**
+ * Create a project from a template with streaming command output. Yields progress for each line of stdout/stderr, then result.
+ */
+export declare function createScaffoldedProjectStreaming(options: {
+    parentDir: string;
+    projectName: string;
+    threadId: string;
+    templateId: string;
+    packageManager: PackageManager;
+}): AsyncGenerator<ScaffoldStreamEvent>;
+/**
+ * Load catalog and return all template entries (for API/UI listing).
+ */
+export declare function getScaffoldTemplates(): TemplateEntry[];
+//# sourceMappingURL=scaffold.runner.d.ts.map