tarsk 0.3.43 → 0.4.4

package/dist/features/onboarding/onboarding-get-status.route.d.ts

@@ -0,0 +1,12 @@
+/**
+ * GET /api/onboarding/status
+ * Check if onboarding has been completed
+ */
+import type { Context } from "hono";
+import type { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function getOnboardingStatus(c: Context, metadataManager: MetadataManager): Promise<(Response & import("hono").TypedResponse<{
+    onboardingCompleted: boolean;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=onboarding-get-status.route.d.ts.map

package/dist/features/onboarding/onboarding-get-status.route.js

@@ -0,0 +1,15 @@
+/**
+ * GET /api/onboarding/status
+ * Check if onboarding has been completed
+ */
+export async function getOnboardingStatus(c, metadataManager) {
+    try {
+        const onboardingCompleted = await metadataManager.getOnboardingCompleted();
+        return c.json({ onboardingCompleted });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to check onboarding status";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=onboarding-get-status.route.js.map

package/dist/features/onboarding/onboarding-post-complete.route.d.ts

@@ -0,0 +1,12 @@
+/**
+ * POST /api/onboarding/complete
+ * Mark onboarding as complete
+ */
+import type { Context } from "hono";
+import type { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function postOnboardingComplete(c: Context, metadataManager: MetadataManager): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=onboarding-post-complete.route.d.ts.map

package/dist/features/onboarding/onboarding-post-complete.route.js

@@ -0,0 +1,15 @@
+/**
+ * POST /api/onboarding/complete
+ * Mark onboarding as complete
+ */
+export async function postOnboardingComplete(c, metadataManager) {
+    try {
+        await metadataManager.setOnboardingCompleted(true);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to complete onboarding";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=onboarding-post-complete.route.js.map

package/dist/features/onboarding/onboarding-post-reset.route.d.ts

@@ -0,0 +1,12 @@
+/**
+ * POST /api/onboarding/reset
+ * Reset onboarding so the flow can be run again (hidden feature)
+ */
+import type { Context } from "hono";
+import type { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function postOnboardingReset(c: Context, metadataManager: MetadataManager): Promise<(Response & import("hono").TypedResponse<{
+    success: true;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: string;
+}, 500, "json">)>;
+//# sourceMappingURL=onboarding-post-reset.route.d.ts.map

package/dist/features/onboarding/onboarding-post-reset.route.js

@@ -0,0 +1,15 @@
+/**
+ * POST /api/onboarding/reset
+ * Reset onboarding so the flow can be run again (hidden feature)
+ */
+export async function postOnboardingReset(c, metadataManager) {
+    try {
+        await metadataManager.setOnboardingCompleted(false);
+        return c.json({ success: true });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Failed to reset onboarding";
+        return c.json({ error: message }, 500);
+    }
+}
+//# sourceMappingURL=onboarding-post-reset.route.js.map

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

@@ -0,0 +1,18 @@
+/**
+ * Onboarding routes for the REST API
+ *
+ * Handles onboarding flow for first-time users:
+ * - GET /api/onboarding/status - Check if onboarding is complete
+ * - GET /api/onboarding/git-check - Check if git is installed
+ * - POST /api/onboarding/complete - Mark onboarding as complete
+ * - POST /api/onboarding/reset - Reset onboarding (hidden feature)
+ */
+import { Hono } from "hono";
+import type { MetadataManager } from "../metadata/metadata.manager.js";
+/**
+ * Creates onboarding routes
+ * @param metadataManager - Manager for metadata persistence
+ * @returns Hono router with onboarding routes
+ */
+export declare function createOnboardingRoutes(metadataManager: MetadataManager): Hono;
+//# sourceMappingURL=onboarding.routes.d.ts.map

package/dist/features/onboarding/onboarding.routes.js

@@ -0,0 +1,28 @@
+/**
+ * Onboarding routes for the REST API
+ *
+ * Handles onboarding flow for first-time users:
+ * - GET /api/onboarding/status - Check if onboarding is complete
+ * - GET /api/onboarding/git-check - Check if git is installed
+ * - POST /api/onboarding/complete - Mark onboarding as complete
+ * - POST /api/onboarding/reset - Reset onboarding (hidden feature)
+ */
+import { Hono } from "hono";
+import { getOnboardingStatus } from "./onboarding-get-status.route.js";
+import { getGitCheck } from "./onboarding-get-git-check.route.js";
+import { postOnboardingComplete } from "./onboarding-post-complete.route.js";
+import { postOnboardingReset } from "./onboarding-post-reset.route.js";
+/**
+ * Creates onboarding routes
+ * @param metadataManager - Manager for metadata persistence
+ * @returns Hono router with onboarding routes
+ */
+export function createOnboardingRoutes(metadataManager) {
+    const router = new Hono();
+    router.get("/status", (c) => getOnboardingStatus(c, metadataManager));
+    router.get("/git-check", (c) => getGitCheck(c));
+    router.post("/complete", (c) => postOnboardingComplete(c, metadataManager));
+    router.post("/reset", (c) => postOnboardingReset(c, metadataManager));
+    return router;
+}
+//# sourceMappingURL=onboarding.routes.js.map

package/dist/features/project-todos/project-todos.database.d.ts

@@ -0,0 +1,38 @@
+import type { Database } from "../../database/database.types.js";
+import type { ProjectTodoStatus } from "@tarsk/shared";
+export interface ProjectTodoRecord {
+    id: string;
+    projectId: string;
+    title: string;
+    description: string;
+    status: string;
+    working: number;
+    threadId: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function serializeTodo(row: ProjectTodoRecord): {
+    working: boolean;
+    id: string;
+    projectId: string;
+    title: string;
+    description: string;
+    status: string;
+    threadId: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export declare function getTodosByProject(db: Database, projectId: string): Promise<ProjectTodoRecord[]>;
+export declare function getTodoById(db: Database, todoId: string): Promise<ProjectTodoRecord | null>;
+export declare function insertTodo(projectId: string, title: string, description: string): Promise<ProjectTodoRecord>;
+export declare function updateTodo(db: Database, todoId: string, updates: {
+    title?: string;
+    description?: string;
+    status?: ProjectTodoStatus;
+    working?: boolean;
+    threadId?: string | null;
+}): Promise<ProjectTodoRecord | null>;
+export declare function deleteTodoById(db: Database, todoId: string): Promise<void>;
+export declare function getTodoByThreadId(db: Database, threadId: string): Promise<ProjectTodoRecord | null>;
+export declare function clearWorkingByThreadId(db: Database, threadId: string): Promise<void>;
+//# sourceMappingURL=project-todos.database.d.ts.map

package/dist/features/project-todos/project-todos.database.js

@@ -0,0 +1,91 @@
+import { randomUUID } from "crypto";
+import { getDatabase } from "../../database/database.js";
+export function serializeTodo(row) {
+    return {
+        ...row,
+        working: row.working === 1,
+    };
+}
+export async function getTodosByProject(db, projectId) {
+    const result = await db.execute({
+        sql: `SELECT id, projectId, title, description, status, working, threadId, createdAt, updatedAt
+		      FROM project_todos WHERE projectId = ? ORDER BY createdAt ASC`,
+        args: [projectId],
+    });
+    return result.rows;
+}
+export async function getTodoById(db, todoId) {
+    const result = await db.execute({
+        sql: `SELECT id, projectId, title, description, status, working, threadId, createdAt, updatedAt
+		      FROM project_todos WHERE id = ?`,
+        args: [todoId],
+    });
+    return result.rows[0] ?? null;
+}
+export async function insertTodo(projectId, title, description) {
+    const db = await getDatabase();
+    const id = randomUUID();
+    const now = new Date().toISOString();
+    await db.execute({
+        sql: `INSERT INTO project_todos (id, projectId, title, description, status, working, createdAt, updatedAt)
+		      VALUES (?, ?, ?, ?, 'Ready', 0, ?, ?)`,
+        args: [id, projectId, title, description, now, now],
+    });
+    return (await getTodoById(db, id));
+}
+export async function updateTodo(db, todoId, updates) {
+    const fields = [];
+    const values = [];
+    if (updates.title !== undefined) {
+        fields.push("title = ?");
+        values.push(updates.title);
+    }
+    if (updates.description !== undefined) {
+        fields.push("description = ?");
+        values.push(updates.description);
+    }
+    if (updates.status !== undefined) {
+        fields.push("status = ?");
+        values.push(updates.status);
+    }
+    if (updates.working !== undefined) {
+        fields.push("working = ?");
+        values.push(updates.working ? 1 : 0);
+    }
+    if (updates.threadId !== undefined) {
+        fields.push("threadId = ?");
+        values.push(updates.threadId);
+    }
+    if (fields.length === 0) {
+        return getTodoById(db, todoId);
+    }
+    fields.push("updatedAt = ?");
+    const now = new Date().toISOString();
+    values.push(now, todoId);
+    await db.execute({
+        sql: `UPDATE project_todos SET ${fields.join(", ")} WHERE id = ?`,
+        args: values,
+    });
+    return getTodoById(db, todoId);
+}
+export async function deleteTodoById(db, todoId) {
+    await db.execute({
+        sql: "DELETE FROM project_todos WHERE id = ?",
+        args: [todoId],
+    });
+}
+export async function getTodoByThreadId(db, threadId) {
+    const result = await db.execute({
+        sql: `SELECT id, projectId, title, description, status, working, threadId, createdAt, updatedAt
+		      FROM project_todos WHERE threadId = ? LIMIT 1`,
+        args: [threadId],
+    });
+    return result.rows[0] ?? null;
+}
+export async function clearWorkingByThreadId(db, threadId) {
+    await db.execute({
+        sql: `UPDATE project_todos SET working = 0, updatedAt = ? WHERE threadId = ?`,
+        args: [new Date().toISOString(), threadId],
+    });
+}
+//# sourceMappingURL=project-todos.database.js.map

package/dist/features/project-todos/project-todos.routes.d.ts

@@ -0,0 +1,4 @@
+import { Hono } from "hono";
+import type { MetadataManager } from "../metadata/metadata.manager.js";
+export declare function createProjectTodosRoutes(metadataManager: MetadataManager): Hono;
+//# sourceMappingURL=project-todos.routes.d.ts.map

package/dist/features/project-todos/project-todos.routes.js

@@ -0,0 +1,94 @@
+import { Hono } from "hono";
+import { getDatabase } from "../../database/database.js";
+import { getTodosByProject, insertTodo, updateTodo, deleteTodoById, serializeTodo, } from "./project-todos.database.js";
+import { resolveProviderAndKey, resolveModelForGit, DEFAULT_MODEL_MAP } from "../git/git.utils.js";
+import { completeSimple } from "@mariozechner/pi-ai";
+const VALID_STATUSES = ["Ready", "Plan", "Build", "Test", "Review", "Done"];
+async function generateTodoTitle(description, metadataManager) {
+    const prompt = `Generate a concise 5-8 word title for this todo item.
+Return ONLY the title text, nothing else.
+
+Todo description: ${description}`;
+    try {
+        const providerKeys = await metadataManager.getProviderKeys();
+        const resolved = await resolveProviderAndKey(providerKeys);
+        if (!resolved?.provider.api)
+            return description.slice(0, 60);
+        const selectedModel = DEFAULT_MODEL_MAP[resolved.provider.name] || "default";
+        const resolvedModel = resolveModelForGit(resolved.provider.name, selectedModel, resolved.provider.api);
+        const response = await completeSimple(resolvedModel, {
+            messages: [{ role: "user", content: prompt, timestamp: Date.now() }],
+        }, { apiKey: resolved.apiKey });
+        const title = response.content
+            .filter((b) => b.type === "text")
+            .map((b) => b.text)
+            .join("")
+            .trim()
+            .replace(/^["']|["']$/g, "");
+        return title || description.slice(0, 60);
+    }
+    catch {
+        return description.slice(0, 60);
+    }
+}
+export function createProjectTodosRoutes(metadataManager) {
+    const router = new Hono();
+    // GET /api/projects/:projectId/todos
+    router.get("/:projectId/todos", async (c) => {
+        const projectId = c.req.param("projectId");
+        const db = await getDatabase();
+        const rows = await getTodosByProject(db, projectId);
+        return c.json(rows.map(serializeTodo));
+    });
+    // POST /api/projects/:projectId/todos
+    // Body: { description: string }
+    router.post("/:projectId/todos", async (c) => {
+        const projectId = c.req.param("projectId");
+        const body = await c.req.json();
+        if (!body.description?.trim()) {
+            return c.json({ error: "description is required" }, 400);
+        }
+        const title = await generateTodoTitle(body.description.trim(), metadataManager);
+        const todo = await insertTodo(projectId, title, body.description.trim());
+        return c.json(serializeTodo(todo), 201);
+    });
+    // PATCH /api/projects/:projectId/todos/:todoId
+    // Body: { description?, status?, working? }
+    router.patch("/:projectId/todos/:todoId", async (c) => {
+        const todoId = c.req.param("todoId");
+        const body = await c.req.json();
+        const updates = {};
+        if (body.description !== undefined) {
+            updates.description = body.description.trim();
+            updates.working = false; // editing description always resets working
+        }
+        if (body.status !== undefined) {
+            if (!VALID_STATUSES.includes(body.status)) {
+                return c.json({ error: `Invalid status: ${body.status}` }, 400);
+            }
+            updates.status = body.status;
+            updates.working = body.working === true;
+        }
+        else if (body.working !== undefined && body.description === undefined) {
+            updates.working = body.working;
+        }
+        if (body.threadId !== undefined) {
+            updates.threadId = body.threadId;
+        }
+        const db = await getDatabase();
+        const updated = await updateTodo(db, todoId, updates);
+        if (!updated) {
+            return c.json({ error: "Todo not found" }, 404);
+        }
+        return c.json(serializeTodo(updated));
+    });
+    // DELETE /api/projects/:projectId/todos/:todoId
+    router.delete("/:projectId/todos/:todoId", async (c) => {
+        const todoId = c.req.param("todoId");
+        const db = await getDatabase();
+        await deleteTodoById(db, todoId);
+        return c.json({ success: true });
+    });
+    return router;
+}
+//# sourceMappingURL=project-todos.routes.js.map

package/dist/features/projects/projects-ai-files.route.d.ts

@@ -0,0 +1,148 @@
+/**
+ * AI Files routes for the REST API
+ *
+ * Handles listing and editing AI-related files in a project:
+ * - GET /api/projects/:id/ai-files - List AI file tree (skills, rules, commands, markdown files)
+ * - GET /api/projects/:id/ai-file?path=... - Read file content
+ * - PUT /api/projects/:id/ai-file - Write file content
+ * - DELETE /api/projects/:id/ai-file?path=... - Delete file or folder
+ * - POST /api/projects/:id/ai-files/skill - Create a new skill
+ */
+import { type Context } from "hono";
+import { ProjectManager } from "../projects/projects.manager.js";
+export interface AIFileNode {
+    id: string;
+    name: string;
+    type: "file" | "folder";
+    path: string;
+    children?: AIFileNode[];
+    virtual?: boolean;
+}
+/**
+ * Build the full AI file tree for a project or thread.
+ * - Always shows .agents/skills, .agents/rules, .agents/commands (virtual if missing)
+ * - Shows markdown files at root level
+ * - Shows folders that contain markdown files
+ */
+export declare function buildAIFileTree(projectPath: string): Promise<AIFileNode[]>;
+/**
+ * Validate that a file path is safe (no path traversal, within project or thread)
+ */
+export declare function validateFilePath(projectPath: string, filePath: string): string | null;
+/**
+ * GET /api/projects/:id/ai-files
+ */
+export declare function handleGetAIFiles(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    nodes: {
+        id: string;
+        name: string;
+        type: "file" | "folder";
+        path: string;
+        children?: /*elided*/ any[] | undefined;
+        virtual?: boolean | undefined;
+    }[];
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+/**
+ * GET /api/projects/:id/ai-file?path=...
+ */
+export declare function handleGetAIFile(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    content: string;
+    path: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">) | (Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">)>;
+/**
+ * PUT /api/projects/:id/ai-file
+ * Body: { path: string, content: string }
+ */
+export declare function handleSaveAIFile(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    path: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+/**
+ * DELETE /api/projects/:id/ai-file?path=...
+ * Deletes a file or folder at the specified path
+ */
+export declare function handleDeleteAIFile(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+    };
+}, 404, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    path: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+/**
+ * POST /api/projects/:id/ai-files/skill
+ * Body: { name: string, description: string, isGlobal?: boolean }
+ * Creates .agents/skills/{name}/SKILL.md
+ */
+export declare function handleCreateSkill(c: Context, projectManager: ProjectManager): Promise<(Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+        details?: import("hono/utils/types").JSONValue | undefined;
+        timestamp: string;
+    };
+}, any, "json">) | (Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+    };
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    error: {
+        code: string;
+        message: string;
+    };
+}, 409, "json">) | (Response & import("hono").TypedResponse<{
+    success: true;
+    path: string;
+    content: string;
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">)>;
+//# sourceMappingURL=projects-ai-files.route.d.ts.map