tarsk 0.3.43 → 0.4.4

package/dist/features/slash-commands/slash-commands.manager.js

@@ -0,0 +1,265 @@
+/**
+ * Slash Command Manager
+ *
+ * Loads and manages slash commands from markdown files with frontmatter.
+ * Commands can be stored in:
+ * - Project-specific: ./.agents/commands/ (relative to thread path)
+ * - Global: ~/.agents/commands/
+ */
+import { readdir, readFile, mkdir, writeFile, unlink } from "fs/promises";
+import { join, basename, extname } from "path";
+import { existsSync } from "fs";
+import { homedir } from "os";
+/**
+ * Slugify a filename to a command name
+ * - Convert to lowercase
+ * - Replace spaces with dashes
+ * - Remove special characters (except dashes)
+ * - Collapse multiple dashes
+ * - Trim leading/trailing dashes
+ */
+function slugify(filename) {
+    return filename
+        .toLowerCase()
+        .replace(/\s+/g, "-")
+        .replace(/[^a-z0-9-]/g, "")
+        .replace(/-+/g, "-")
+        .replace(/^-+|-+$/g, "");
+}
+/**
+ * Parse frontmatter from markdown content
+ * Returns { metadata, content } where content is the body after frontmatter
+ */
+function parseFrontmatter(markdown) {
+    const lines = markdown.split("\n");
+    // Check if file starts with ---
+    if (lines[0]?.trim() !== "---") {
+        return {
+            metadata: {},
+            content: markdown.trim(),
+        };
+    }
+    // Find the closing ---
+    let endIndex = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i]?.trim() === "---") {
+            endIndex = i;
+            break;
+        }
+    }
+    // No closing --- found
+    if (endIndex === -1) {
+        return {
+            metadata: {},
+            content: markdown.trim(),
+        };
+    }
+    // Parse frontmatter
+    const frontmatterLines = lines.slice(1, endIndex);
+    const metadata = {};
+    for (const line of frontmatterLines) {
+        const colonIndex = line.indexOf(":");
+        if (colonIndex === -1)
+            continue;
+        const key = line.slice(0, colonIndex).trim();
+        const value = line.slice(colonIndex + 1).trim();
+        // Map YAML keys to TypeScript property names
+        if (key === "description") {
+            metadata.description = value;
+        }
+        else if (key === "argument-hint") {
+            metadata.argumentHint = value;
+        }
+        else if (key === "mode") {
+            metadata.mode = value;
+        }
+    }
+    // Content is everything after the closing ---
+    const content = lines
+        .slice(endIndex + 1)
+        .join("\n")
+        .trim();
+    return { metadata, content };
+}
+/**
+ * Get the global commands directory path
+ */
+function getGlobalCommandsDir() {
+    return join(homedir(), ".agents", "commands");
+}
+/**
+ * Get the project-specific commands directory path
+ */
+function getProjectCommandsDir(threadPath) {
+    return join(threadPath, ".agents", "commands");
+}
+/**
+ * SlashCommandManager handles loading, creating, and managing slash commands
+ */
+export class SlashCommandManager {
+    /**
+     * Built-in commands that cannot be overridden
+     */
+    static BUILT_IN_COMMANDS = new Set(["init"]);
+    /**
+     * Load all available commands for a given thread
+     * Project commands override global ones with the same name
+     * Built-in commands cannot be overridden
+     */
+    async loadCommands(threadPath) {
+        const commands = new Map();
+        // Load global commands first
+        const globalDir = getGlobalCommandsDir();
+        if (existsSync(globalDir)) {
+            const globalCommands = await this.loadCommandsFromDir(globalDir, "global");
+            for (const cmd of globalCommands) {
+                commands.set(cmd.name, cmd);
+            }
+        }
+        // Load project commands (override global)
+        const projectDir = getProjectCommandsDir(threadPath);
+        if (existsSync(projectDir)) {
+            const projectCommands = await this.loadCommandsFromDir(projectDir, "project");
+            for (const cmd of projectCommands) {
+                // Don't allow overriding built-in commands
+                if (!SlashCommandManager.BUILT_IN_COMMANDS.has(cmd.name)) {
+                    commands.set(cmd.name, cmd);
+                }
+            }
+        }
+        return Array.from(commands.values());
+    }
+    /**
+     * Load commands from a specific directory
+     */
+    async loadCommandsFromDir(dir, scope) {
+        const commands = [];
+        try {
+            const files = await readdir(dir);
+            for (const file of files) {
+                if (!file.endsWith(".md"))
+                    continue;
+                const filePath = join(dir, file);
+                const fileContent = await readFile(filePath, "utf-8");
+                // Parse frontmatter and content
+                const { metadata, content } = parseFrontmatter(fileContent);
+                // Generate command name from filename
+                const nameWithoutExt = basename(file, extname(file));
+                const commandName = slugify(nameWithoutExt);
+                // Skip if name becomes empty after slugification
+                if (!commandName)
+                    continue;
+                commands.push({
+                    name: commandName,
+                    content,
+                    metadata,
+                    scope,
+                    filePath,
+                });
+            }
+        }
+        catch (error) {
+            // Directory doesn't exist or can't be read - that's okay
+            console.error(`Failed to load commands from ${dir}:`, error);
+        }
+        return commands;
+    }
+    /**
+     * Create a new command
+     * Creates the directory if it doesn't exist
+     */
+    async createCommand(name, content, metadata, scope, threadPath) {
+        // Validate name
+        if (SlashCommandManager.BUILT_IN_COMMANDS.has(name)) {
+            throw new Error(`Cannot create built-in command: ${name}`);
+        }
+        // Determine directory
+        const dir = scope === "global"
+            ? getGlobalCommandsDir()
+            : threadPath
+                ? getProjectCommandsDir(threadPath)
+                : null;
+        if (!dir) {
+            throw new Error("threadPath required for project-scoped commands");
+        }
+        // Ensure directory exists
+        if (!existsSync(dir)) {
+            await mkdir(dir, { recursive: true });
+        }
+        // Generate filename from name (reverse slugify)
+        const filename = `${name}.md`;
+        const filePath = join(dir, filename);
+        // Check if file already exists
+        if (existsSync(filePath)) {
+            throw new Error(`Command already exists: ${name}`);
+        }
+        // Build markdown with frontmatter
+        let markdown = "";
+        // Add frontmatter if metadata exists
+        if (metadata.description || metadata.argumentHint || metadata.mode) {
+            markdown += "---\n";
+            if (metadata.description) {
+                markdown += `description: ${metadata.description}\n`;
+            }
+            if (metadata.argumentHint) {
+                markdown += `argument-hint: ${metadata.argumentHint}\n`;
+            }
+            if (metadata.mode) {
+                markdown += `mode: ${metadata.mode}\n`;
+            }
+            markdown += "---\n\n";
+        }
+        markdown += content;
+        // Write file
+        await writeFile(filePath, markdown, "utf-8");
+        return {
+            name,
+            content,
+            metadata,
+            scope,
+            filePath,
+        };
+    }
+    /**
+     * Update an existing command
+     */
+    async updateCommand(filePath, content, metadata) {
+        if (!existsSync(filePath)) {
+            throw new Error(`Command file not found: ${filePath}`);
+        }
+        // Build markdown with frontmatter
+        let markdown = "";
+        if (metadata.description || metadata.argumentHint || metadata.mode) {
+            markdown += "---\n";
+            if (metadata.description) {
+                markdown += `description: ${metadata.description}\n`;
+            }
+            if (metadata.argumentHint) {
+                markdown += `argument-hint: ${metadata.argumentHint}\n`;
+            }
+            if (metadata.mode) {
+                markdown += `mode: ${metadata.mode}\n`;
+            }
+            markdown += "---\n\n";
+        }
+        markdown += content;
+        await writeFile(filePath, markdown, "utf-8");
+    }
+    /**
+     * Delete a command
+     */
+    async deleteCommand(filePath) {
+        if (!existsSync(filePath)) {
+            throw new Error(`Command file not found: ${filePath}`);
+        }
+        await unlink(filePath);
+    }
+    /**
+     * Get a specific command by name
+     */
+    async getCommand(name, threadPath) {
+        const commands = await this.loadCommands(threadPath);
+        return commands.find((cmd) => cmd.name === name) ?? null;
+    }
+}
+//# sourceMappingURL=slash-commands.manager.js.map

package/dist/features/slash-commands/slash-commands.routes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Slash Commands API Routes
+ *
+ * Endpoints for managing and querying slash commands
+ */
+import { Hono } from "hono";
+import type { ThreadManager } from "../threads/threads.manager.js";
+/**
+ * Create slash command routes
+ * @param threadManager - The ThreadManager instance
+ */
+export declare function createSlashCommandRoutes(router: Hono, threadManager: ThreadManager): void;
+//# sourceMappingURL=slash-commands.routes.d.ts.map

package/dist/features/slash-commands/slash-commands.routes.js

@@ -0,0 +1,20 @@
+/**
+ * Slash Commands API Routes
+ *
+ * Endpoints for managing and querying slash commands
+ */
+import { getSlashCommands } from "./slash-commands-get.route.js";
+import { createSlashCommand } from "./slash-commands-post.route.js";
+import { updateSlashCommand } from "./slash-commands-put.route.js";
+import { deleteSlashCommand } from "./slash-commands-delete.route.js";
+/**
+ * Create slash command routes
+ * @param threadManager - The ThreadManager instance
+ */
+export function createSlashCommandRoutes(router, threadManager) {
+    router.get("/api/slash-commands", (c) => getSlashCommands(c, threadManager));
+    router.post("/api/slash-commands", (c) => createSlashCommand(c, threadManager));
+    router.put("/api/slash-commands", (c) => updateSlashCommand(c));
+    router.delete("/api/slash-commands", (c) => deleteSlashCommand(c));
+}
+//# sourceMappingURL=slash-commands.routes.js.map

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

@@ -0,0 +1,153 @@
+/**
+ * AI Files routes for threads REST API
+ *
+ * Handles listing and editing AI-related files in a thread's path:
+ * - GET /api/threads/:id/ai-files - List AI file tree (skills, rules, commands, markdown files)
+ * - GET /api/threads/:id/ai-file?path=... - Read file content
+ * - PUT /api/threads/:id/ai-file - Write file content
+ * - DELETE /api/threads/:id/ai-file?path=... - Delete file or folder
+ * - POST /api/threads/:id/ai-files/skill - Create a new skill
+ */
+import { type Context } from "hono";
+import type { ThreadManager } from "./threads.manager.js";
+/**
+ * GET /api/threads/:id/ai-files
+ */
+export declare function handleGetThreadAIFiles(c: Context, threadManager: ThreadManager): 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/threads/:id/ai-file?path=...
+ */
+export declare function handleGetThreadAIFile(c: Context, threadManager: ThreadManager): 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/threads/:id/ai-file
+ * Body: { path: string, content: string }
+ */
+export declare function handleSaveThreadAIFile(c: Context, threadManager: ThreadManager): 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/threads/:id/ai-file?path=...
+ */
+export declare function handleDeleteThreadAIFile(c: Context, threadManager: ThreadManager): 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/threads/:id/ai-files/agent
+ * Body: { name: string, description: string, tools?: string }
+ */
+export declare function handleCreateThreadAgent(c: Context, threadManager: ThreadManager): 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">)>;
+/**
+ * POST /api/threads/:id/ai-files/skill
+ * Body: { name: string, description: string }
+ */
+export declare function handleCreateThreadSkill(c: Context, threadManager: ThreadManager): 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=threads-ai-files.route.d.ts.map