tarsk 0.4.4 → 0.4.6

package/dist/tools/shell.js

@@ -1,143 +0,0 @@
-import { execSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { spawnProcess } from "../core/utils.js";
-import { spawnSyncProcess } from "../core/utils.js";
-let cachedShellConfig = null;
-let cachedLoginShellEnv = null;
-function findBashOnPath() {
-    if (process.platform === "win32") {
-        try {
-            const syncResult = spawnSyncProcess("where", ["bash.exe"], {
-                encoding: "utf-8",
-                timeout: 5000,
-            });
-            if (syncResult.status === 0 && typeof syncResult.stdout === "string") {
-                const firstMatch = syncResult.stdout.trim().split(/\r?\n/)[0];
-                if (firstMatch && existsSync(firstMatch)) {
-                    return firstMatch;
-                }
-            }
-        }
-        catch {
-            // ignore
-        }
-        return null;
-    }
-    try {
-        const syncResult = spawnSyncProcess("which", ["bash"], {
-            encoding: "utf-8",
-            timeout: 5000,
-        });
-        if (syncResult.status === 0 && typeof syncResult.stdout === "string") {
-            const firstMatch = syncResult.stdout.trim().split(/\r?\n/)[0];
-            if (firstMatch)
-                return firstMatch;
-        }
-    }
-    catch {
-        // ignore
-    }
-    return null;
-}
-export function getShellConfig() {
-    if (cachedShellConfig) {
-        return cachedShellConfig;
-    }
-    if (process.platform === "win32") {
-        const paths = [];
-        if (process.env.ProgramFiles) {
-            paths.push(`${process.env.ProgramFiles}\\Git\\bin\\bash.exe`);
-        }
-        if (process.env["ProgramFiles(x86)"]) {
-            paths.push(`${process.env["ProgramFiles(x86)"]}\\Git\\bin\\bash.exe`);
-        }
-        for (const p of paths) {
-            if (existsSync(p)) {
-                cachedShellConfig = { shell: p, args: ["-c"] };
-                return cachedShellConfig;
-            }
-        }
-        const bashOnPath = findBashOnPath();
-        if (bashOnPath) {
-            cachedShellConfig = { shell: bashOnPath, args: ["-c"] };
-            return cachedShellConfig;
-        }
-        throw new Error("No bash shell found. Install Git for Windows or add bash to PATH.");
-    }
-    if (existsSync("/bin/bash")) {
-        cachedShellConfig = { shell: "/bin/bash", args: ["-c"] };
-        return cachedShellConfig;
-    }
-    const bashOnPath = findBashOnPath();
-    if (bashOnPath) {
-        cachedShellConfig = { shell: bashOnPath, args: ["-c"] };
-        return cachedShellConfig;
-    }
-    cachedShellConfig = { shell: "sh", args: ["-c"] };
-    return cachedShellConfig;
-}
-function getLoginShellEnv() {
-    if (cachedLoginShellEnv) {
-        return cachedLoginShellEnv;
-    }
-    const shell = process.env.SHELL ?? (process.platform === "win32" ? undefined : "/bin/zsh");
-    if (!shell) {
-        cachedLoginShellEnv = { ...process.env };
-        return cachedLoginShellEnv;
-    }
-    try {
-        const quotedShell = shell.replace(/'/g, "'\\''");
-        const output = execSync(`'${quotedShell}' -ilc 'env'`, {
-            encoding: "utf-8",
-            timeout: 5000,
-            stdio: ["ignore", "pipe", "ignore"],
-            env: { ...process.env },
-        });
-        const loginEnv = { ...process.env };
-        for (const line of output.split(/\r?\n/)) {
-            const separatorIndex = line.indexOf("=");
-            if (separatorIndex <= 0) {
-                continue;
-            }
-            const key = line.slice(0, separatorIndex);
-            const value = line.slice(separatorIndex + 1);
-            loginEnv[key] = value;
-        }
-        cachedLoginShellEnv = loginEnv;
-        return cachedLoginShellEnv;
-    }
-    catch {
-        cachedLoginShellEnv = { ...process.env };
-        return cachedLoginShellEnv;
-    }
-}
-export function getShellEnv() {
-    return { ...getLoginShellEnv() };
-}
-export function killProcessTree(pid) {
-    if (process.platform === "win32") {
-        try {
-            spawnProcess("taskkill", ["/F", "/T", "/PID", String(pid)], {
-                stdio: "ignore",
-                detached: true,
-            });
-        }
-        catch {
-            // ignore
-        }
-    }
-    else {
-        try {
-            process.kill(-pid, "SIGKILL");
-        }
-        catch {
-            try {
-                process.kill(pid, "SIGKILL");
-            }
-            catch {
-                // already dead
-            }
-        }
-    }
-}
-//# sourceMappingURL=shell.js.map

package/dist/tools/skill-reference-tool.d.ts

@@ -1,30 +0,0 @@
-/**
- * Skill Reference Tool
- *
- * Loads reference files from activated skills' references/ directories on-demand.
- * This implements progressive disclosure - reference files are only loaded when needed.
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-import type { Skill } from "@tarsk/shared";
-/**
- * Schema for skill reference tool input
- */
-declare const skillReferenceSchema: import("@sinclair/typebox").TObject<{
-    skillName: import("@sinclair/typebox").TString;
-    referencePath: import("@sinclair/typebox").TString;
-}>;
-export type SkillReferenceToolInput = Static<typeof skillReferenceSchema>;
-/**
- * Create a skill reference reader tool
- */
-export declare function createSkillReferenceTool(skills: Skill[]): AgentTool<typeof skillReferenceSchema>;
-/**
- * List all available skill references (utility function)
- */
-export declare function listSkillReferences(skills: Skill[]): Promise<Array<{
-    skillName: string;
-    referencePath: string;
-}>>;
-export {};
-//# sourceMappingURL=skill-reference-tool.d.ts.map

package/dist/tools/skill-reference-tool.js

@@ -1,171 +0,0 @@
-/**
- * Skill Reference Tool
- *
- * Loads reference files from activated skills' references/ directories on-demand.
- * This implements progressive disclosure - reference files are only loaded when needed.
- */
-import { readFile, readdir } from "fs/promises";
-import { join, normalize, relative } from "path";
-import { existsSync } from "fs";
-import { Type } from "@sinclair/typebox";
-/**
- * Validate that a reference path is safe (no path traversal attacks)
- */
-function isPathSafe(basePath, requestedPath) {
-    const normalized = normalize(requestedPath);
-    const fullPath = join(basePath, normalized);
-    const relativePath = relative(basePath, fullPath);
-    // Check if the relative path tries to escape the base directory
-    return !relativePath.startsWith("..") && !relativePath.startsWith("/");
-}
-/**
- * Schema for skill reference tool input
- */
-const skillReferenceSchema = Type.Object({
-    skillName: Type.String({ description: "Name of the skill" }),
-    referencePath: Type.String({
-        description: 'Path to the reference file relative to the skill\'s references/ directory (e.g., "api-reference.md" or "guides/setup.md")',
-    }),
-});
-/**
- * Create a skill reference reader tool
- */
-export function createSkillReferenceTool(skills) {
-    return {
-        name: "read_skill_reference",
-        label: "read_skill_reference",
-        description: "Read a reference file from an activated skill. Skills provide additional documentation in their references/ directory.",
-        parameters: skillReferenceSchema,
-        execute: async (_toolCallId, { skillName, referencePath }) => {
-            // Find the skill
-            const skill = skills.find((s) => s.name === skillName);
-            if (!skill) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Skill not found: ${skillName}. Available skills: ${skills.map((s) => s.name).join(", ")}`,
-                        },
-                    ],
-                    details: undefined,
-                };
-            }
-            // Check if references directory exists
-            const referencesDir = join(skill.skillPath, "references");
-            if (!existsSync(referencesDir)) {
-                return {
-                    content: [
-                        { type: "text", text: `Skill '${skillName}' has no references directory` },
-                    ],
-                    details: undefined,
-                };
-            }
-            // Validate path safety (prevent path traversal)
-            if (!isPathSafe(referencesDir, referencePath)) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Invalid reference path: ${referencePath}. Path must be within the skill's references directory.`,
-                        },
-                    ],
-                    details: undefined,
-                };
-            }
-            // Read the reference file
-            const fullPath = join(referencesDir, referencePath);
-            if (!existsSync(fullPath)) {
-                // List available references for better error message
-                try {
-                    const availableRefs = await listReferencesRecursive(referencesDir);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Reference file '${referencePath}' not found in skill '${skillName}'. Available references:\n${availableRefs.join("\n")}`,
-                            },
-                        ],
-                        details: undefined,
-                    };
-                }
-                catch {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Reference file '${referencePath}' not found in skill '${skillName}'`,
-                            },
-                        ],
-                        details: undefined,
-                    };
-                }
-            }
-            try {
-                const content = await readFile(fullPath, "utf-8");
-                return {
-                    content: [{ type: "text", text: content }],
-                    details: undefined,
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Failed to read reference file: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    details: undefined,
-                };
-            }
-        },
-    };
-}
-/**
- * Recursively list all reference files in a directory
- */
-async function listReferencesRecursive(dir, prefix = "") {
-    const files = [];
-    try {
-        const entries = await readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const relativePath = prefix ? join(prefix, entry.name) : entry.name;
-            if (entry.isDirectory()) {
-                const subFiles = await listReferencesRecursive(join(dir, entry.name), relativePath);
-                files.push(...subFiles);
-            }
-            else {
-                files.push(relativePath);
-            }
-        }
-    }
-    catch (error) {
-        console.error(`Failed to list references in ${dir}:`, error);
-    }
-    return files;
-}
-/**
- * List all available skill references (utility function)
- */
-export async function listSkillReferences(skills) {
-    const references = [];
-    for (const skill of skills) {
-        const referencesDir = join(skill.skillPath, "references");
-        if (!existsSync(referencesDir))
-            continue;
-        try {
-            const files = await listReferencesRecursive(referencesDir);
-            for (const file of files) {
-                references.push({
-                    skillName: skill.name,
-                    referencePath: file,
-                });
-            }
-        }
-        catch (error) {
-            console.error(`Failed to list references for skill ${skill.name}:`, error);
-        }
-    }
-    return references;
-}
-//# sourceMappingURL=skill-reference-tool.js.map

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

@@ -1,33 +0,0 @@
-/**
- * Skill Script Tool
- *
- * Executes scripts from activated skills' scripts/ directories.
- * Scripts can be written in any supported language (.sh, .py, .js, etc.)
- */
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-import type { Skill } from "@tarsk/shared";
-/**
- * Schema for skill script tool input
- */
-declare const skillScriptSchema: import("@sinclair/typebox").TObject<{
-    skillName: import("@sinclair/typebox").TString;
-    scriptName: import("@sinclair/typebox").TString;
-    args: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
-}>;
-export type SkillScriptToolInput = Static<typeof skillScriptSchema>;
-/**
- * Create a skill script executor tool
- */
-export declare function createSkillScriptTool(skills: Skill[], cwd: string): AgentTool<typeof skillScriptSchema>;
-/**
- * List all available skill scripts
- */
-export declare function listSkillScripts(skills: Skill[]): Promise<Array<{
-    skillName: string;
-    scriptName: string;
-    path: string;
-}>>;
-export {};
-//# sourceMappingURL=skill-tool.d.ts.map

package/dist/tools/skill-tool.js

@@ -1,213 +0,0 @@
-/**
- * Skill Script Tool
- *
- * Executes scripts from activated skills' scripts/ directories.
- * Scripts can be written in any supported language (.sh, .py, .js, etc.)
- */
-import { readdir } from "fs/promises";
-import { join, extname } from "path";
-import { existsSync, statSync } from "fs";
-import { Type } from "@sinclair/typebox";
-import { spawnProcess } from "../core/utils.js";
-/**
- * Get the interpreter for a script based on its extension
- */
-function getInterpreter(scriptPath) {
-    const ext = extname(scriptPath);
-    switch (ext) {
-        case ".sh":
-        case ".bash":
-            return { command: "bash", args: [scriptPath] };
-        case ".py":
-            return { command: "python3", args: [scriptPath] };
-        case ".js":
-            return { command: "node", args: [scriptPath] };
-        case ".ts":
-            // Use bun to run TypeScript directly
-            return { command: "bun", args: ["run", scriptPath] };
-        default:
-            // Try to execute directly if it's executable
-            try {
-                const stats = statSync(scriptPath);
-                if (stats.mode & 0o111) {
-                    // File is executable
-                    return { command: scriptPath, args: [] };
-                }
-            }
-            catch {
-                // Ignore stat errors
-            }
-            return null;
-    }
-}
-/**
- * Execute a skill script
- */
-async function executeScript(scriptPath, args, cwd, timeout = 30) {
-    const interpreter = getInterpreter(scriptPath);
-    if (!interpreter) {
-        throw new Error(`Unsupported script type: ${scriptPath}`);
-    }
-    return new Promise((resolve, reject) => {
-        const child = spawnProcess(interpreter.command, [...interpreter.args, ...args], {
-            cwd,
-            timeout: timeout * 1000,
-        });
-        let stdout = "";
-        let stderr = "";
-        let timedOut = false;
-        if (child.stdout) {
-            child.stdout.on("data", (data) => {
-                stdout += data.toString();
-            });
-        }
-        if (child.stderr) {
-            child.stderr.on("data", (data) => {
-                stderr += data.toString();
-            });
-        }
-        const timeoutHandle = setTimeout(() => {
-            timedOut = true;
-            child.kill("SIGTERM");
-        }, timeout * 1000);
-        child.on("error", (err) => {
-            clearTimeout(timeoutHandle);
-            reject(err);
-        });
-        child.on("close", (code) => {
-            clearTimeout(timeoutHandle);
-            if (timedOut) {
-                reject(new Error(`Script execution timed out after ${timeout}s`));
-                return;
-            }
-            resolve({ stdout, stderr, exitCode: code });
-        });
-    });
-}
-/**
- * Schema for skill script tool input
- */
-const skillScriptSchema = Type.Object({
-    skillName: Type.String({ description: "Name of the skill" }),
-    scriptName: Type.String({ description: "Name of the script to execute (without path)" }),
-    args: Type.Optional(Type.Array(Type.String(), { description: "Arguments to pass to the script" })),
-    timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (default: 30)" })),
-});
-/**
- * Create a skill script executor tool
- */
-export function createSkillScriptTool(skills, cwd) {
-    return {
-        name: "execute_skill_script",
-        label: "execute_skill_script",
-        description: "Execute a script from an activated skill. Skills provide executable scripts in their scripts/ directory.",
-        parameters: skillScriptSchema,
-        execute: async (_toolCallId, { skillName, scriptName, args = [], timeout = 30 }) => {
-            // Find the skill
-            const skill = skills.find((s) => s.name === skillName);
-            if (!skill) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Skill not found: ${skillName}. Available skills: ${skills.map((s) => s.name).join(", ")}`,
-                        },
-                    ],
-                    details: undefined,
-                };
-            }
-            // Check if scripts directory exists
-            const scriptsDir = join(skill.skillPath, "scripts");
-            if (!existsSync(scriptsDir)) {
-                return {
-                    content: [
-                        { type: "text", text: `Skill '${skillName}' has no scripts directory` },
-                    ],
-                    details: undefined,
-                };
-            }
-            // Find the script
-            const scriptPath = join(scriptsDir, scriptName);
-            if (!existsSync(scriptPath)) {
-                // List available scripts for better error message
-                try {
-                    const availableScripts = await readdir(scriptsDir);
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Script '${scriptName}' not found in skill '${skillName}'. Available scripts: ${availableScripts.join(", ")}`,
-                            },
-                        ],
-                        details: undefined,
-                    };
-                }
-                catch {
-                    return {
-                        content: [
-                            {
-                                type: "text",
-                                text: `Script '${scriptName}' not found in skill '${skillName}'`,
-                            },
-                        ],
-                        details: undefined,
-                    };
-                }
-            }
-            try {
-                const result = await executeScript(scriptPath, args, cwd, timeout);
-                // Format output
-                let output = "";
-                if (result.stdout) {
-                    output += `STDOUT:\n${result.stdout}\n`;
-                }
-                if (result.stderr) {
-                    output += `STDERR:\n${result.stderr}\n`;
-                }
-                output += `Exit code: ${result.exitCode}\n`;
-                return {
-                    content: [{ type: "text", text: output }],
-                    details: undefined,
-                };
-            }
-            catch (error) {
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: `Failed to execute script: ${error instanceof Error ? error.message : String(error)}`,
-                        },
-                    ],
-                    details: undefined,
-                };
-            }
-        },
-    };
-}
-/**
- * List all available skill scripts
- */
-export async function listSkillScripts(skills) {
-    const scripts = [];
-    for (const skill of skills) {
-        const scriptsDir = join(skill.skillPath, "scripts");
-        if (!existsSync(scriptsDir))
-            continue;
-        try {
-            const files = await readdir(scriptsDir);
-            for (const file of files) {
-                const fullPath = join(scriptsDir, file);
-                scripts.push({
-                    skillName: skill.name,
-                    scriptName: file,
-                    path: fullPath,
-                });
-            }
-        }
-        catch (error) {
-            console.error(`Failed to list scripts for skill ${skill.name}:`, error);
-        }
-    }
-    return scripts;
-}
-//# sourceMappingURL=skill-tool.js.map

package/dist/tools/todo.d.ts

@@ -1,20 +0,0 @@
-import type { AgentTool } from "@mariozechner/pi-agent-core";
-import { type Static } from "@sinclair/typebox";
-declare const todoSchema: import("@sinclair/typebox").TObject<{
-    action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"add">, import("@sinclair/typebox").TLiteral<"update">, import("@sinclair/typebox").TLiteral<"list">, import("@sinclair/typebox").TLiteral<"delete">]>;
-    descriptions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    ids: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"working">, import("@sinclair/typebox").TLiteral<"done">]>>;
-    assignedTo: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>;
-export type TodoToolInput = Static<typeof todoSchema>;
-export declare function createTodoTool(threadId: string): AgentTool<typeof todoSchema>;
-export declare const todoTool: AgentTool<import("@sinclair/typebox").TObject<{
-    action: import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"add">, import("@sinclair/typebox").TLiteral<"update">, import("@sinclair/typebox").TLiteral<"list">, import("@sinclair/typebox").TLiteral<"delete">]>;
-    descriptions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    ids: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>>;
-    status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TLiteral<"pending">, import("@sinclair/typebox").TLiteral<"working">, import("@sinclair/typebox").TLiteral<"done">]>>;
-    assignedTo: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
-}>, any>;
-export {};
-//# sourceMappingURL=todo.d.ts.map