@llmtune/cli 0.1.0 → 0.1.2

package/dist/repl/repl.js

@@ -0,0 +1,375 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startRepl = startRepl;
+const chalk_1 = __importDefault(require("chalk"));
+const readline_1 = require("readline");
+const conversation_1 = require("../agent/conversation");
+const registry_1 = require("../tools/registry");
+const loop_1 = require("../agent/loop");
+const read_1 = require("../tools/tools/read");
+const write_1 = require("../tools/tools/write");
+const edit_1 = require("../tools/tools/edit");
+const bash_1 = require("../tools/tools/bash");
+const glob_1 = require("../tools/tools/glob");
+const grep_1 = require("../tools/tools/grep");
+const web_fetch_1 = require("../tools/tools/web-fetch");
+const ask_user_1 = require("../tools/tools/ask-user");
+const service_1 = require("../compact/service");
+const analyzer_1 = require("../context/analyzer");
+const loader_1 = require("../skills/loader");
+const trust_1 = require("../skills/trust");
+const service_2 = require("../memory/service");
+const logger_1 = require("../telemetry/logger");
+const config_1 = require("../auth/config");
+const version_1 = require("../version");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const HELP_TEXT = `
+${chalk_1.default.bold("LLMTune CLI - Commands:")}
+
+  ${chalk_1.default.cyan("/help")}            Show this help
+  ${chalk_1.default.cyan("/clear")}          Clear conversation history
+  ${chalk_1.default.cyan("/context")}        Show detailed context usage breakdown
+  ${chalk_1.default.cyan("/compact")}        Compact conversation (LLM summary)
+  ${chalk_1.default.cyan("/uncompact")}      Restore conversation from before compaction
+  ${chalk_1.default.cyan("/model <name>")}   Switch model
+  ${chalk_1.default.cyan("/stream")}         Toggle streaming mode
+  ${chalk_1.default.cyan("/verbose")}        Toggle verbose tool output
+  ${chalk_1.default.cyan("/trust <tool>")}   Trust a tool (skip confirmations)
+  ${chalk_1.default.cyan("/skills")}         List available skills
+  ${chalk_1.default.cyan("/memory")}         Show memory contents
+  ${chalk_1.default.cyan("/save")}           Save conversation to file
+  ${chalk_1.default.cyan("/exit")}           Exit REPL
+
+  ${chalk_1.default.gray("Type your message and press Enter to chat.")}
+  ${chalk_1.default.gray("Multi-line: end a line with '\\' to continue.")}
+`.trim();
+async function startRepl(options) {
+    const registry = new registry_1.ToolRegistry();
+    const cwd = process.cwd();
+    const trustedTools = new Set();
+    registry.register(read_1.readTool);
+    registry.register(write_1.writeTool);
+    registry.register(edit_1.editTool);
+    registry.register(bash_1.bashTool);
+    registry.register(glob_1.globTool);
+    registry.register(grep_1.grepTool);
+    registry.register(web_fetch_1.webFetchTool);
+    registry.register(ask_user_1.askUserTool);
+    const conversation = new conversation_1.Conversation(options.model);
+    // Load skills
+    const skills = (0, loader_1.loadAllSkills)(cwd);
+    const skillList = skills.listUserInvocable();
+    // Initialize memory
+    (0, service_2.initMemoryFiles)();
+    // Start telemetry
+    (0, logger_1.startSessionLog)(conversation.id, {
+        model: options.model,
+        tools: registry.listSpecs().map((s) => s.name),
+        cwd,
+    });
+    let currentModel = options.model;
+    let streamMode = options.stream;
+    let verbose = false;
+    console.log(chalk_1.default.cyan(`\nLLMTune CLI v${version_1.CLI_VERSION}`));
+    console.log(chalk_1.default.dim(`Model: ${currentModel}`));
+    console.log(chalk_1.default.dim(`Tools: ${registry.listSpecs().map((s) => s.name).join(", ")}`));
+    if (skillList.length > 0) {
+        console.log(chalk_1.default.dim(`Skills: ${skillList.map((s) => s.name).join(", ")}`));
+    }
+    console.log(chalk_1.default.dim(`Type /help for commands, /exit to quit.\n`));
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: chalk_1.default.blue("> "),
+    });
+    rl.prompt();
+    let multiLineBuffer = "";
+    rl.on("line", async (line) => {
+        const trimmed = line.trim();
+        if (trimmed.endsWith("\\")) {
+            multiLineBuffer += trimmed.slice(0, -1) + "\n";
+            process.stdout.write(chalk_1.default.dim("... "));
+            return;
+        }
+        const fullInput = multiLineBuffer + trimmed;
+        multiLineBuffer = "";
+        if (!fullInput) {
+            rl.prompt();
+            return;
+        }
+        // Check for skill execution: /skill-name [args]
+        if (fullInput.startsWith("/") && !fullInput.startsWith("/help") && !fullInput.startsWith("/exit") && !fullInput.startsWith("/quit") && !fullInput.startsWith("/clear") && !fullInput.startsWith("/context") && !fullInput.startsWith("/compact") && !fullInput.startsWith("/uncompact") && !fullInput.startsWith("/model") && !fullInput.startsWith("/stream") && !fullInput.startsWith("/verbose") && !fullInput.startsWith("/trust") && !fullInput.startsWith("/skills") && !fullInput.startsWith("/memory") && !fullInput.startsWith("/save")) {
+            const parts = fullInput.slice(1).split(/\s+/);
+            const skillName = parts[0];
+            const skillArgs = parts.slice(1);
+            const execution = skills.prepareExecution(skillName, skillArgs);
+            if (execution) {
+                const skill = skills.get(skillName);
+                console.log(chalk_1.default.magenta(`Executing skill: ${skill.name}`));
+                const trustLevel = (0, trust_1.resolveTrustLevel)(skill);
+                const toolNames = registry.listSpecs().map((s) => s.name);
+                for (const toolName of toolNames) {
+                    if (!(0, trust_1.isToolAllowedForSkill)(toolName, trustLevel)) {
+                        console.log(chalk_1.default.yellow(`  Warning: tool "${toolName}" not allowed for skill trust level "${trustLevel}"`));
+                    }
+                }
+                // Add skill system prompt and user message
+                conversation.addSystemMessage(execution.systemPrompt);
+                conversation.addUserMessage(execution.userMessage);
+                try {
+                    const result = await (0, loop_1.runAgentLoop)(options.client, conversation, registry, execution.userMessage, {
+                        model: currentModel,
+                        maxTurns: 50,
+                        verbose,
+                        cwd,
+                        workspaceRoot: cwd,
+                    });
+                    (0, logger_1.logEvent)({ event: "tool_call", tool: skillName, latency_ms: 0 });
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    console.log(chalk_1.default.red(`\nSkill error: ${msg}`));
+                }
+                console.log("");
+                rl.prompt();
+                return;
+            }
+        }
+        if (fullInput.startsWith("/")) {
+            await handleCommand(fullInput, {
+                rl,
+                conversation,
+                registry,
+                skills,
+                trustedTools,
+                cwd,
+                client: options.client,
+                getModel: () => currentModel,
+                setModel: (m) => {
+                    currentModel = m;
+                },
+                getStream: () => streamMode,
+                setStream: (s) => {
+                    streamMode = s;
+                },
+                getVerbose: () => verbose,
+                setVerbose: (v) => {
+                    verbose = v;
+                },
+            });
+            rl.prompt();
+            return;
+        }
+        // Normal chat
+        try {
+            const result = await (0, loop_1.runAgentLoop)(options.client, conversation, registry, fullInput, {
+                model: currentModel,
+                maxTurns: 50,
+                verbose,
+                cwd,
+                workspaceRoot: cwd,
+            });
+            if (result.totalTokensIn > 0 || result.totalTokensOut > 0) {
+                const cost = estimateCostFromUsage(result.totalTokensIn, result.totalTokensOut);
+                console.log(chalk_1.default.dim(`  [${result.turns} turn${result.turns !== 1 ? "s" : ""} | ` +
+                    `${result.totalToolCalls} tool calls | ` +
+                    `${result.totalTokensIn + result.totalTokensOut} tokens | ` +
+                    `~$${cost.toFixed(4)}]`));
+                (0, logger_1.logEvent)({
+                    event: "llm_response",
+                    model: currentModel,
+                    tokens_in: result.totalTokensIn,
+                    tokens_out: result.totalTokensOut,
+                    cost,
+                    latency_ms: 0,
+                });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(chalk_1.default.red(`\nError: ${msg}`));
+            (0, logger_1.logEvent)({ event: "error", source: "agent_loop", error: msg });
+        }
+        console.log("");
+        rl.prompt();
+    });
+    rl.on("close", () => {
+        (0, logger_1.endSessionLog)({ totalToolCalls: 0, totalTokens: 0 });
+        console.log(chalk_1.default.dim("\nGoodbye!"));
+        process.exit(0);
+    });
+}
+async function handleCommand(input, ctx) {
+    const parts = input.split(/\s+/);
+    const cmd = parts[0].toLowerCase();
+    const args = parts.slice(1);
+    switch (cmd) {
+        case "/help":
+        case "/h":
+        case "/?":
+            console.log(HELP_TEXT);
+            break;
+        case "/exit":
+        case "/quit":
+        case "/q":
+            console.log(chalk_1.default.dim("Goodbye!"));
+            process.exit(0);
+        case "/clear":
+            ctx.conversation.messages.length = 0;
+            console.log(chalk_1.default.green("Conversation cleared."));
+            break;
+        case "/context": {
+            const analysis = (0, analyzer_1.analyzeContextUsage)({
+                systemPrompt: "LLMTune coding agent",
+                toolSpecs: ctx.registry.listSpecs(),
+                messages: ctx.conversation.getApiMessages().map((m) => ({
+                    role: m.role,
+                    content: m.content,
+                })),
+                skillsContent: ctx.skills.list().map((s) => s.content).join("\n") || undefined,
+                memoryContent: (0, service_2.buildMemoryPrompt)() || undefined,
+                model: ctx.getModel(),
+            });
+            console.log((0, analyzer_1.formatContextAnalysis)(analysis));
+            break;
+        }
+        case "/compact": {
+            if (ctx.conversation.messages.length < 3) {
+                console.log(chalk_1.default.yellow("Not enough messages to compact (need at least 3)."));
+                break;
+            }
+            console.log(chalk_1.default.dim("Compacting conversation..."));
+            try {
+                const result = await (0, service_1.compactConversation)(ctx.client, ctx.getModel(), ctx.conversation);
+                console.log(chalk_1.default.green(`\nCompacted: ${result.preCompactMessages} -> ${result.postCompactMessages} messages`));
+                console.log(chalk_1.default.dim(`  Tokens saved: ~${result.tokensSaved.toLocaleString()}`));
+                console.log(chalk_1.default.dim(`  Use /uncompact to restore full history.`));
+                (0, logger_1.logEvent)({ event: "compaction", tokens_saved: result.tokensSaved, messages_before: result.preCompactMessages, messages_after: result.postCompactMessages, trigger: "manual" });
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.log(chalk_1.default.red(`Compaction failed: ${msg}`));
+            }
+            break;
+        }
+        case "/uncompact": {
+            const restored = (0, service_1.uncompactConversation)(ctx.conversation);
+            if (restored) {
+                console.log(chalk_1.default.green(`Restored conversation from before compaction (${ctx.conversation.messages.length} messages).`));
+            }
+            else {
+                console.log(chalk_1.default.yellow("No raw history found to restore."));
+            }
+            break;
+        }
+        case "/model":
+            if (args[0]) {
+                ctx.setModel(args[0]);
+                console.log(chalk_1.default.green(`Model set to: ${args[0]}`));
+            }
+            else {
+                console.log(chalk_1.default.dim(`Current model: ${ctx.getModel()}`));
+            }
+            break;
+        case "/stream":
+            ctx.setStream(!ctx.getStream());
+            console.log(chalk_1.default.green(`Streaming: ${ctx.getStream() ? "on" : "off"}`));
+            break;
+        case "/verbose":
+            ctx.setVerbose(!ctx.getVerbose());
+            console.log(chalk_1.default.green(`Verbose: ${ctx.getVerbose() ? "on" : "off"}`));
+            break;
+        case "/trust":
+            if (args[0]) {
+                ctx.trustedTools.add(args[0].toLowerCase());
+                console.log(chalk_1.default.green(`Trusting tool: ${args[0]} (no confirmation needed)`));
+            }
+            else {
+                console.log(chalk_1.default.dim("Usage: /trust <tool-name>"));
+            }
+            break;
+        case "/skills": {
+            const allSkills = ctx.skills.listUserInvocable();
+            if (allSkills.length === 0) {
+                console.log(chalk_1.default.dim("No skills loaded. Create skills in ~/.llmtune/skills/ or .llmtune/skills/"));
+                console.log(chalk_1.default.dim("Each skill is a directory with a SKILL.md file."));
+            }
+            else {
+                console.log(chalk_1.default.bold("\nAvailable Skills:"));
+                for (const skill of allSkills) {
+                    const trustLabel = skill.trustLevel;
+                    console.log(`  ${chalk_1.default.cyan(`/${skill.name}`)} - ${skill.description} ${chalk_1.default.dim(`[${trustLabel}]`)}`);
+                }
+                console.log("");
+            }
+            break;
+        }
+        case "/memory": {
+            const entries = (0, service_2.readAllMemory)();
+            if (entries.length === 0) {
+                console.log(chalk_1.default.dim("\nNo memory entries. The agent will auto-populate memory as you chat."));
+                console.log(chalk_1.default.dim(`Memory directory: ${(0, config_1.getConfigDir)()}/memory/\n`));
+            }
+            else {
+                console.log(chalk_1.default.bold("\nMemory:"));
+                for (const entry of entries) {
+                    if (entry.content.trim()) {
+                        const preview = entry.content.slice(0, 100).replace(/\n/g, " ");
+                        console.log(`  ${chalk_1.default.cyan(entry.category)}: ${chalk_1.default.dim(preview)}${entry.content.length > 100 ? "..." : ""}`);
+                    }
+                }
+                console.log("");
+            }
+            break;
+        }
+        case "/save": {
+            const savePath = path.join(process.cwd(), `llmtune-session-${Date.now()}.json`);
+            fs.writeFileSync(savePath, JSON.stringify(ctx.conversation.getApiMessages(), null, 2), "utf-8");
+            console.log(chalk_1.default.green(`Session saved to: ${savePath}`));
+            break;
+        }
+        default:
+            console.log(chalk_1.default.yellow(`Unknown command: ${cmd}. Type /help for available commands.`));
+    }
+}
+function estimateCostFromUsage(inputTokens, outputTokens) {
+    return (inputTokens * 3 + outputTokens * 15) / 1_000_000;
+}
+//# sourceMappingURL=repl.js.map

package/dist/skills/args.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parse argument names from a skill's frontmatter "arguments" field.
+ * Supports: "arg1 arg2", "arg1, arg2", "$arg1 $arg2"
+ */
+export declare function parseArgumentNames(raw: unknown): string[];
+/**
+ * Substitute {{arg}} placeholders in skill content with provided values.
+ */
+export declare function substituteArguments(content: string, args: Record<string, string>): string;
+//# sourceMappingURL=args.d.ts.map

package/dist/skills/args.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgumentNames = parseArgumentNames;
+exports.substituteArguments = substituteArguments;
+/**
+ * Parse argument names from a skill's frontmatter "arguments" field.
+ * Supports: "arg1 arg2", "arg1, arg2", "$arg1 $arg2"
+ */
+function parseArgumentNames(raw) {
+    if (!raw)
+        return [];
+    const str = String(raw).trim();
+    if (!str)
+        return [];
+    // Split by comma or space, strip $ prefixes
+    return str
+        .split(/[,\s]+/)
+        .map((s) => s.trim().replace(/^\$/, ""))
+        .filter(Boolean);
+}
+/**
+ * Substitute {{arg}} placeholders in skill content with provided values.
+ */
+function substituteArguments(content, args) {
+    let result = content;
+    for (const [key, value] of Object.entries(args)) {
+        const patterns = [
+            new RegExp(`\\{\\{${key}\\}\\}`, "g"),
+            new RegExp(`\\$\\{${key}\\}`, "g"),
+        ];
+        for (const pattern of patterns) {
+            result = result.replace(pattern, value);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=args.js.map

package/dist/skills/frontmatter.d.ts

@@ -0,0 +1,6 @@
+export interface FrontmatterResult {
+    frontmatter: Record<string, unknown>;
+    body: string;
+}
+export declare function parseFrontmatter(content: string): FrontmatterResult;
+//# sourceMappingURL=frontmatter.d.ts.map

package/dist/skills/frontmatter.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFrontmatter = parseFrontmatter;
+function parseFrontmatter(content) {
+    const trimmed = content.trimStart();
+    if (!trimmed.startsWith("---")) {
+        return { frontmatter: {}, body: content };
+    }
+    const endMatch = trimmed.indexOf("---", 3);
+    if (endMatch === -1 || endMatch < 4) {
+        return { frontmatter: {}, body: content };
+    }
+    const frontmatterStr = trimmed.slice(3, endMatch).trim();
+    const body = trimmed.slice(endMatch + 3).trimStart();
+    const frontmatter = {};
+    for (const line of frontmatterStr.split("\n")) {
+        const colonIdx = line.indexOf(":");
+        if (colonIdx === -1)
+            continue;
+        const key = line.slice(0, colonIdx).trim();
+        let value = line.slice(colonIdx + 1).trim();
+        if (typeof value === "string") {
+            if (value === "true")
+                value = true;
+            else if (value === "false")
+                value = false;
+            else if (/^\d+$/.test(value))
+                value = Number(value);
+            else if (value.startsWith("[") && value.endsWith("]")) {
+                value = value
+                    .slice(1, -1)
+                    .split(",")
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+            }
+            else {
+                value = value.replace(/^["']|["']$/g, "");
+            }
+        }
+        frontmatter[key] = value;
+    }
+    return { frontmatter, body };
+}
+//# sourceMappingURL=frontmatter.js.map

package/dist/skills/loader.d.ts

@@ -0,0 +1,5 @@
+import { SkillRegistry } from "./registry";
+export declare function loadAllSkills(projectRoot?: string): SkillRegistry;
+export declare function getDefaultSkillsDirs(): string[];
+export declare function getProjectSkillsDir(projectRoot: string): string;
+//# sourceMappingURL=loader.d.ts.map

package/dist/skills/loader.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAllSkills = loadAllSkills;
+exports.getDefaultSkillsDirs = getDefaultSkillsDirs;
+exports.getProjectSkillsDir = getProjectSkillsDir;
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const registry_1 = require("./registry");
+function loadAllSkills(projectRoot) {
+    const registry = new registry_1.SkillRegistry();
+    registry.loadAll(projectRoot);
+    return registry;
+}
+function getDefaultSkillsDirs() {
+    const dirs = [];
+    const home = os.homedir();
+    const envDir = process.env.LLMTUNE_SKILLS_DIR;
+    if (envDir)
+        dirs.push(path.resolve(envDir));
+    dirs.push(path.join(home, ".llmtune", "skills"));
+    return dirs;
+}
+function getProjectSkillsDir(projectRoot) {
+    return path.join(projectRoot, ".llmtune", "skills");
+}
+//# sourceMappingURL=loader.js.map

package/dist/skills/registry.d.ts

@@ -0,0 +1,27 @@
+export interface Skill {
+    name: string;
+    description: string;
+    content: string;
+    loadedFrom: "user" | "project" | "managed";
+    userInvocable: boolean;
+    allowedTools: string[];
+    argNames: string[];
+    trustLevel: TrustLevel;
+    skillRoot: string;
+}
+export type TrustLevel = "local" | "community" | "verified" | "signed";
+export interface SkillExecution {
+    systemPrompt: string;
+    userMessage: string;
+    allowedTools?: string[];
+}
+export declare class SkillRegistry {
+    private skills;
+    loadAll(projectRoot?: string): void;
+    private loadFromDir;
+    get(name: string): Skill | undefined;
+    list(): Skill[];
+    listUserInvocable(): Skill[];
+    prepareExecution(name: string, args: string[]): SkillExecution | null;
+}
+//# sourceMappingURL=registry.d.ts.map