tarsk 0.4.4 → 0.4.6

package/dist/server.js

@@ -1,142 +0,0 @@
-import { serve } from "@hono/node-server";
-import { serveStatic } from "@hono/node-server/serve-static";
-import { AVAILABLE_PROGRAMS } from "@tarsk/shared";
-import fs from "fs";
-import { Hono } from "hono";
-import { cors } from "hono/cors";
-import open from "open";
-import path from "path";
-import { fileURLToPath } from "url";
-import { PiExecutorImpl } from "./agent/agent.executor.js";
-import { ProcessingStateManagerImpl } from "./agent/agent.processing-state-manager.js";
-import { getDataDir } from "./core/paths.js";
-import { createAskUserRoutes } from "./features/ask-user/ask-user.routes.js";
-import { createChatRoutes } from "./features/chat/chat.routes.js";
-import { ConversationManagerImpl } from "./features/conversations/conversations.manager.js";
-import { createConversationRoutes } from "./features/conversations/conversations.routes.js";
-import { MetadataManager } from "./features/metadata/metadata.manager.js";
-import { createModelRoutes } from "./features/models/models.routes.js";
-import { createOnboardingRoutes } from "./features/onboarding/onboarding.routes.js";
-import { createProjectRoutes } from "./features/projects/projects.routes.js";
-import { ProjectManagerImpl } from "./features/projects/projects.manager.js";
-import { createProviderRoutes } from "./features/providers/providers.routes.js";
-import { createRunRoutes } from "./features/run/run.routes.js";
-import { createScaffoldRoutes } from "./features/scaffold/scaffold.routes.js";
-import { createSlashCommandRoutes } from "./features/slash-commands/slash-commands.routes.js";
-import { createRuleRoutes } from "./features/rules/rules.routes.js";
-import { ThreadManagerImpl } from "./features/threads/threads.manager.js";
-import { createThreadRoutes } from "./features/threads/threads.routes.js";
-import { GitManagerImpl } from "./features/git/git.manager.js";
-import { createGitRoutes } from "./features/git/git.routes.js";
-import { createUpdateRoutes } from "./features/updates/updates.routes.js";
-import { createMCPRoutes } from "./features/mcp/mcp.routes.js";
-import { createProjectTodosRoutes } from "./features/project-todos/project-todos.routes.js";
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-export async function startTarskServer(options) {
-    const { isDebug, publicDir: publicDirOverride } = options;
-    const port = isDebug ? 462 : process.env.PORT ? parseInt(process.env.PORT) : 641;
-    const app = new Hono();
-    app.use("/*", cors());
-    app.use("/*", async (c, next) => {
-        if (c.req.path.startsWith("/api/")) {
-            const method = c.req.method;
-            const reqPath = c.req.path;
-            const fullUrl = `http://localhost:${port}${reqPath}`;
-            if (!fullUrl.includes("processing")) {
-                console.log(`${method} ${fullUrl}`);
-            }
-        }
-        return next();
-    });
-    const dataDir = getDataDir();
-    const metadataManager = new MetadataManager(dataDir);
-    const gitManager = new GitManagerImpl();
-    const processingStateManager = new ProcessingStateManagerImpl();
-    const projectManager = new ProjectManagerImpl(dataDir, metadataManager, gitManager, processingStateManager);
-    const threadManager = new ThreadManagerImpl(metadataManager, gitManager, processingStateManager, dataDir);
-    const conversationManager = new ConversationManagerImpl(dataDir);
-    const agentExecutor = new PiExecutorImpl(metadataManager);
-    await metadataManager.initialize();
-    await conversationManager.initialize();
-    app.get("/health", (c) => {
-        return c.json({
-            status: "ok",
-            timestamp: new Date().toISOString(),
-            service: "project-threads-manager-cli",
-        });
-    });
-    app.get("/api/programs", (c) => {
-        return c.json({
-            programs: AVAILABLE_PROGRAMS,
-        });
-    });
-    app.get("/api/threads/processing", (c) => {
-        return c.json({
-            processingThreadIds: processingStateManager.getProcessingThreadIds(),
-        });
-    });
-    app.route("/api/projects", createProjectRoutes(projectManager, threadManager));
-    app.route("/api/projects", createRunRoutes(projectManager));
-    app.route("/api/projects", createProjectTodosRoutes(metadataManager));
-    app.route("/api/threads", createThreadRoutes(threadManager, gitManager, conversationManager));
-    app.route("/api/chat", createChatRoutes(threadManager, agentExecutor, conversationManager, processingStateManager));
-    app.route("/api/conversations", createConversationRoutes(conversationManager, threadManager));
-    app.route("/api/providers", createProviderRoutes(metadataManager));
-    app.route("/api/models", createModelRoutes(metadataManager));
-    app.route("/api/mcp", createMCPRoutes());
-    app.route("/api/git", createGitRoutes(metadataManager));
-    app.route("/api/onboarding", createOnboardingRoutes(metadataManager));
-    app.route("/api/scaffold", createScaffoldRoutes(projectManager));
-    app.route("/api/ask-user", createAskUserRoutes());
-    app.route("/api/update", createUpdateRoutes(options.updater));
-    createSlashCommandRoutes(app, threadManager);
-    createRuleRoutes(app, projectManager);
-    const prodPublicDir = path.join(__dirname, "public");
-    const devCopiedPublicDir = path.join(process.cwd(), "dist", "public");
-    const appDistDir = path.join(process.cwd(), "..", "app", "dist");
-    const resolvedPublicDir = publicDirOverride ??
-        [prodPublicDir, devCopiedPublicDir, appDistDir].find((dirPath) => fs.existsSync(dirPath));
-    if (!resolvedPublicDir) {
-        throw new Error("No static frontend assets found. Expected one of: " +
-            `${prodPublicDir}, ${devCopiedPublicDir}, ${appDistDir}. ` +
-            "Build the app first with `cd ../app && bun run build`.");
-    }
-    const staticRoot = path.relative(process.cwd(), resolvedPublicDir);
-    app.use("/*", async (c, next) => {
-        if (c.req.path.startsWith("/api/")) {
-            return next();
-        }
-        return serveStatic({ root: staticRoot })(c, next);
-    });
-    app.get("*", async (c, next) => {
-        if (c.req.path.startsWith("/api/")) {
-            return next();
-        }
-        return serveStatic({
-            path: path.relative(process.cwd(), path.join(resolvedPublicDir, "index.html")),
-        })(c, next);
-    });
-    app.all("*", (c) => {
-        const errorResponse = {
-            error: {
-                code: "NOT_FOUND",
-                message: `Route not found: ${c.req.method} ${c.req.path}`,
-                timestamp: new Date().toISOString(),
-            },
-        };
-        return c.json(errorResponse, 404);
-    });
-    const url = `http://localhost:${port}`;
-    process.stdout.write(`Tarsk started on ${url}\n`);
-    serve({
-        fetch: app.fetch,
-        port,
-    }, () => {
-        if (options.openBrowser) {
-            open(url).catch(() => { });
-        }
-    });
-    return { url, port };
-}
-//# sourceMappingURL=server.js.map

package/dist/tools/agent-tool.d.ts

@@ -1,49 +0,0 @@
-/**
- * Agent Tool
- *
- * Allows the running agent to spawn focused subagents for isolated subtasks.
- * Subagents have their own execution context and controlled tool access.
- *
- * Inspired by VS Code Copilot's subagent model:
- * https://code.visualstudio.com/docs/copilot/agents/subagents
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-import type { AgentDefinition, AgentEvent } from "@tarsk/shared";
-import type { MetadataManager } from "../features/metadata/metadata.manager.js";
-import type { Tool } from "./index.js";
-/** Maximum subagent nesting depth (enforced by the caller via tool registration) */
-export declare const MAX_SUBAGENT_DEPTH = 2;
-declare const agentToolSchema: import("@sinclair/typebox").TObject<{
-    prompt: import("@sinclair/typebox").TString;
-    agentName: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-export type AgentToolInput = Static<typeof agentToolSchema>;
-export interface AgentToolOptions {
-    /** Defined agents available for invocation */
-    agents: AgentDefinition[];
-    /** The full base tool set (will be filtered per agent definition) */
-    baseTools: Tool[];
-    /** MetadataManager for API key resolution */
-    metadataManager: MetadataManager;
-    /** Parent context model (used as default if agent definition doesn't override) */
-    parentModel: string;
-    /** Parent context provider (used as default if agent definition doesn't override) */
-    parentProvider: string;
-    /** Default system prompt for unnamed subagents */
-    defaultSystemPrompt: string;
-    /** Callback to forward subagent events into the parent's stream */
-    onEvent: (event: AgentEvent) => void;
-    /** Optional abort signal from the parent */
-    signal?: AbortSignal;
-}
-/**
- * Create the `agent` tool that allows the running agent to spawn subagents.
- *
- * @param options - Configuration including agents list, tools, metadata manager, etc.
- * @returns AgentTool for registration with the Pi agent
- */
-export declare function createAgentTool(options: AgentToolOptions): AgentTool<typeof agentToolSchema>;
-export {};
-//# sourceMappingURL=agent-tool.d.ts.map

package/dist/tools/agent-tool.js

@@ -1,131 +0,0 @@
-/**
- * Agent Tool
- *
- * Allows the running agent to spawn focused subagents for isolated subtasks.
- * Subagents have their own execution context and controlled tool access.
- *
- * Inspired by VS Code Copilot's subagent model:
- * https://code.visualstudio.com/docs/copilot/agents/subagents
- */
-import { Type } from "@sinclair/typebox";
-import { executeSubagent } from "../agent/agent.subagent-executor.js";
-/** Maximum subagent nesting depth (enforced by the caller via tool registration) */
-export const MAX_SUBAGENT_DEPTH = 2;
-const agentToolSchema = Type.Object({
-    prompt: Type.String({ description: "The task or question for the subagent to work on" }),
-    agentName: Type.Optional(Type.String({
-        description: "Name of a defined agent (from AGENT.md) to use. If omitted, a general-purpose subagent is created.",
-    })),
-    description: Type.Optional(Type.String({
-        description: "A short (3-5 word) label describing what the subagent will do",
-    })),
-});
-/**
- * Filter a base tool set to only tools whose names appear in the whitelist.
- * Returns all tools if allowedToolNames is undefined/empty.
- */
-function filterTools(baseTools, allowedToolNames) {
-    if (!allowedToolNames || !allowedToolNames.trim())
-        return baseTools;
-    const allowed = new Set(allowedToolNames
-        .split(/\s+/)
-        .map((s) => s.trim())
-        .filter(Boolean));
-    return baseTools.filter((t) => allowed.has(t.name));
-}
-/**
- * Create the `agent` tool that allows the running agent to spawn subagents.
- *
- * @param options - Configuration including agents list, tools, metadata manager, etc.
- * @returns AgentTool for registration with the Pi agent
- */
-export function createAgentTool(options) {
-    const { agents, baseTools, metadataManager, parentModel, parentProvider, defaultSystemPrompt, onEvent, signal, } = options;
-    return {
-        name: "agent",
-        label: "agent",
-        description: "Launch a specialized subagent to handle a focused subtask in an isolated context. " +
-            "The subagent runs autonomously and returns its result. " +
-            "Use this to delegate research, analysis, or parallel work without polluting the current context. " +
-            "If agentName is provided, that agent's system prompt and tool restrictions are applied.",
-        parameters: agentToolSchema,
-        execute: async (_toolCallId, { prompt, agentName, description }) => {
-            // Resolve agent definition if named
-            const agentDef = agentName
-                ? agents.find((a) => a.name === agentName && !a.disableModelInvocation)
-                : undefined;
-            if (agentName && !agentDef) {
-                const available = agents
-                    .filter((a) => !a.disableModelInvocation)
-                    .map((a) => a.name)
-                    .join(", ");
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Agent '${agentName}' not found or is not invocable. Available agents: ${available || "none"}`,
-                        },
-                    ],
-                    details: undefined,
-                };
-            }
-            const label = description ?? agentName ?? "subagent";
-            const systemPrompt = agentDef?.systemPrompt ?? defaultSystemPrompt;
-            const model = agentDef?.model ?? parentModel;
-            const provider = agentDef?.provider ?? parentProvider;
-            const subTools = filterTools(baseTools, agentDef?.tools);
-            console.log(`[agent-tool] Spawning subagent '${label}' with model=${model}, tools=${subTools.map((t) => t.name).join(",")}`);
-            // Emit subagent_start so the UI can render a collapsible block
-            onEvent({
-                type: "subagent_start",
-                subagentName: label,
-                subagentDescription: agentDef?.description,
-                subagentPrompt: prompt,
-            });
-            let result = "";
-            try {
-                result = await executeSubagent({
-                    prompt,
-                    systemPrompt,
-                    tools: subTools,
-                    model,
-                    provider,
-                    metadataManager,
-                    onEvent: (event) => {
-                        // Wrap nested events in subagent_event envelope
-                        onEvent({
-                            type: "subagent_event",
-                            subagentName: label,
-                            subagentEvent: event,
-                        });
-                    },
-                    signal,
-                });
-            }
-            catch (err) {
-                const message = err instanceof Error ? err.message : String(err);
-                console.error(`[agent-tool] Subagent '${label}' failed:`, message);
-                onEvent({
-                    type: "subagent_complete",
-                    subagentName: label,
-                    subagentResult: `Error: ${message}`,
-                });
-                return {
-                    content: [{ type: "text", text: `Subagent failed: ${message}` }],
-                    details: undefined,
-                };
-            }
-            onEvent({
-                type: "subagent_complete",
-                subagentName: label,
-                subagentResult: result,
-            });
-            console.log(`[agent-tool] Subagent '${label}' completed, result length=${result.length}`);
-            return {
-                content: [{ type: "text", text: result || "(subagent produced no output)" }],
-                details: undefined,
-            };
-        },
-    };
-}
-//# sourceMappingURL=agent-tool.js.map

package/dist/tools/ask-user.d.ts

@@ -1,25 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-declare const askUserSchema: import("@sinclair/typebox").TObject<{
-    question: import("@sinclair/typebox").TString;
-    options: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-export type AskUserToolInput = Static<typeof askUserSchema>;
-/**
- * Submit a user's answer for a pending question.
- * Called by the API route when the frontend posts a response.
- */
-export declare function submitAnswer(toolCallId: string, answer: string): boolean;
-/**
- * Cancel a pending question (e.g. when the stream is aborted).
- */
-export declare function cancelPendingQuestion(toolCallId: string): boolean;
-export declare function createAskUserTool(): AgentTool<typeof askUserSchema>;
-export declare const askUserTool: AgentTool<import("@sinclair/typebox").TObject<{
-    question: import("@sinclair/typebox").TString;
-    options: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    context: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>, any>;
-export {};
-//# sourceMappingURL=ask-user.d.ts.map

package/dist/tools/ask-user.js

@@ -1,74 +0,0 @@
-import { Type } from "@sinclair/typebox";
-const askUserSchema = Type.Object({
-    question: Type.String({
-        description: "A clear, specific question to ask the user. Frame it to help clarify ambiguous requirements, confirm decisions, or gather preferences needed to proceed.",
-    }),
-    options: Type.Optional(Type.Array(Type.String(), {
-        description: "Optional list of predefined answer choices. The user can pick one or type a custom response. Use when there are a small number of clear alternatives.",
-    })),
-    context: Type.Optional(Type.String({
-        description: "Optional brief context explaining why this question is being asked, so the user understands the impact of their answer.",
-    })),
-});
-/**
- * Registry of pending questions awaiting user responses.
- * Keyed by toolCallId so the HTTP endpoint can resolve the correct Promise.
- */
-const pendingQuestions = new Map();
-/**
- * Submit a user's answer for a pending question.
- * Called by the API route when the frontend posts a response.
- */
-export function submitAnswer(toolCallId, answer) {
-    const pending = pendingQuestions.get(toolCallId);
-    if (!pending)
-        return false;
-    pending.resolve(answer);
-    pendingQuestions.delete(toolCallId);
-    return true;
-}
-/**
- * Cancel a pending question (e.g. when the stream is aborted).
- */
-export function cancelPendingQuestion(toolCallId) {
-    const pending = pendingQuestions.get(toolCallId);
-    if (!pending)
-        return false;
-    pending.reject(new Error("Question cancelled"));
-    pendingQuestions.delete(toolCallId);
-    return true;
-}
-export function createAskUserTool() {
-    return {
-        name: "ask_user",
-        label: "ask_user",
-        description: "Ask the user a question when you need clarification, confirmation, or a decision when there is ambiguity or multiple choices.",
-        parameters: askUserSchema,
-        execute: async (toolCallId, { question, options, context }, signal) => {
-            console.log(`[ai] ask_user: "${question}" (options: ${options?.join(", ") ?? "free-text"})`);
-            if (signal?.aborted) {
-                throw new Error("Operation aborted");
-            }
-            const answer = await new Promise((resolve, reject) => {
-                pendingQuestions.set(toolCallId, {
-                    resolve,
-                    reject,
-                    question,
-                    options,
-                    context,
-                });
-                const onAbort = () => {
-                    cancelPendingQuestion(toolCallId);
-                };
-                signal?.addEventListener("abort", onAbort, { once: true });
-            });
-            console.log(`[ai] ask_user response: "${answer}"`);
-            return {
-                content: [{ type: "text", text: answer }],
-                details: undefined,
-            };
-        },
-    };
-}
-export const askUserTool = createAskUserTool();
-//# sourceMappingURL=ask-user.js.map

package/dist/tools/ast-grep.d.ts

@@ -1,28 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-import { type TruncationResult } from "./truncate.js";
-declare const astGrepSchema: import("@sinclair/typebox").TObject<{
-    command: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"run">, import("@sinclair/typebox").TLiteral<"scan">]>;
-    pattern: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    lang: import("@sinclair/typebox").TString;
-    rule: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>;
-export type AstGrepToolInput = Static<typeof astGrepSchema>;
-export interface AstGrepToolDetails {
-    truncation?: TruncationResult;
-    matchLimitReached?: number;
-    linesTruncated?: boolean;
-}
-export declare function createAstGrepTool(cwd: string): AgentTool<typeof astGrepSchema>;
-export declare const astGrepTool: AgentTool<import("@sinclair/typebox").TObject<{
-    command: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"run">, import("@sinclair/typebox").TLiteral<"scan">]>;
-    pattern: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    lang: import("@sinclair/typebox").TString;
-    rule: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    path: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>, any>;
-export {};
-//# sourceMappingURL=ast-grep.d.ts.map