@llmtune/cli 0.1.0 → 0.1.2

package/README.md

@@ -1,6 +1,6 @@
 # LLMTune CLI
 
-AI coding agent for your terminal, powered by [api.llmtune.io](https://api.llmtune.io).
+AI CLI Agent for your terminal, powered by [llmtune.io](https://llmtune.io).
 
 ## Quick Start
 

package/dist/agent/conversation.d.ts

@@ -0,0 +1,42 @@
+export interface Message {
+    role: "system" | "user" | "assistant" | "tool";
+    content: string;
+    toolCalls?: ToolCallMessage[];
+    toolCallId?: string;
+}
+export interface ToolCallMessage {
+    id: string;
+    type: "function";
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+export interface ConversationMeta {
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+    model: string;
+    messageCount: number;
+    totalTokens?: number;
+}
+export declare class Conversation {
+    messages: Message[];
+    id: string;
+    model: string;
+    createdAt: Date;
+    totalTokens: number;
+    constructor(model: string);
+    addSystemMessage(content: string): void;
+    addUserMessage(content: string): void;
+    addAssistantMessage(content: string, toolCalls?: ToolCallMessage[]): void;
+    addToolResult(toolCallId: string, content: string | Record<string, unknown>, isError?: boolean): void;
+    clear(): void;
+    getApiMessages(): Message[];
+    getTokenEstimate(): number;
+    getMeta(): ConversationMeta;
+    save(sessionsDir?: string): string;
+    static load(filePath: string): Conversation;
+    static listSessions(sessionsDir?: string): ConversationMeta[];
+}
+//# sourceMappingURL=conversation.d.ts.map

package/dist/agent/conversation.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Conversation = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+class Conversation {
+    messages = [];
+    id;
+    model;
+    createdAt;
+    totalTokens = 0;
+    constructor(model) {
+        this.id = crypto_1.default.randomUUID();
+        this.model = model;
+        this.createdAt = new Date();
+    }
+    addSystemMessage(content) {
+        this.messages.push({ role: "system", content });
+    }
+    addUserMessage(content) {
+        this.messages.push({ role: "user", content });
+    }
+    addAssistantMessage(content, toolCalls) {
+        this.messages.push({ role: "assistant", content, toolCalls });
+    }
+    addToolResult(toolCallId, content, isError) {
+        const text = typeof content === "string" ? content : JSON.stringify(content);
+        this.messages.push({
+            role: "tool",
+            content: isError ? `Error: ${text}` : text,
+            toolCallId,
+        });
+    }
+    clear() {
+        this.messages = [];
+    }
+    getApiMessages() {
+        return [...this.messages];
+    }
+    getTokenEstimate() {
+        return this.messages.reduce((total, msg) => {
+            const content = typeof msg.content === "string"
+                ? msg.content
+                : JSON.stringify(msg.content);
+            return total + Math.ceil(content.length / 4);
+        }, 0);
+    }
+    getMeta() {
+        return {
+            id: this.id,
+            createdAt: this.createdAt.toISOString(),
+            updatedAt: new Date().toISOString(),
+            model: this.model,
+            messageCount: this.messages.length,
+            totalTokens: this.totalTokens || undefined,
+        };
+    }
+    save(sessionsDir) {
+        const dir = sessionsDir || path_1.default.join(os_1.default.homedir(), ".llmtune", "sessions");
+        fs_1.default.mkdirSync(dir, { recursive: true });
+        const filePath = path_1.default.join(dir, `${this.id}.json`);
+        const data = {
+            meta: this.getMeta(),
+            messages: this.messages,
+        };
+        fs_1.default.writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+        return filePath;
+    }
+    static load(filePath) {
+        const raw = fs_1.default.readFileSync(filePath, "utf-8");
+        const data = JSON.parse(raw);
+        const conv = new Conversation(data.meta.model);
+        conv.id = data.meta.id;
+        conv.createdAt = new Date(data.meta.createdAt);
+        conv.messages = data.messages;
+        conv.totalTokens = data.meta.totalTokens || 0;
+        return conv;
+    }
+    static listSessions(sessionsDir) {
+        const dir = sessionsDir || path_1.default.join(os_1.default.homedir(), ".llmtune", "sessions");
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        return fs_1.default
+            .readdirSync(dir)
+            .filter((f) => f.endsWith(".json"))
+            .map((f) => {
+            try {
+                const raw = fs_1.default.readFileSync(path_1.default.join(dir, f), "utf-8");
+                return JSON.parse(raw).meta;
+            }
+            catch {
+                return null;
+            }
+        })
+            .filter((m) => m !== null)
+            .sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+    }
+}
+exports.Conversation = Conversation;
+//# sourceMappingURL=conversation.js.map

package/dist/agent/loop.d.ts

@@ -0,0 +1,19 @@
+import OpenAI from "openai";
+import { ToolRegistry } from "../tools/registry";
+import { Conversation } from "./conversation";
+export interface AgentLoopConfig {
+    model?: string;
+    maxTurns?: number;
+    verbose?: boolean;
+    cwd: string;
+    workspaceRoot: string;
+}
+export interface AgentLoopResult {
+    finalText: string;
+    totalToolCalls: number;
+    totalTokensIn: number;
+    totalTokensOut: number;
+    turns: number;
+}
+export declare function runAgentLoop(client: OpenAI, conversation: Conversation, registry: ToolRegistry, userInput: string, config: AgentLoopConfig, onTextChunk?: (text: string) => void): Promise<AgentLoopResult>;
+//# sourceMappingURL=loop.d.ts.map

package/dist/agent/loop.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgentLoop = runAgentLoop;
+const builder_1 = require("../context/builder");
+const chalk_1 = __importDefault(require("chalk"));
+async function runAgentLoop(client, conversation, registry, userInput, config, onTextChunk) {
+    const model = config.model ?? "z-ai/GLM-5.1";
+    const maxTurns = config.maxTurns ?? 20;
+    conversation.addUserMessage(userInput);
+    const toolSpecs = registry.listSpecs();
+    const openaiTools = toolSpecs.map((spec) => ({
+        type: "function",
+        function: {
+            name: spec.name,
+            description: spec.description,
+            parameters: spec.inputSchema,
+        },
+    }));
+    const contextResult = await (0, builder_1.buildContextPrompt)(config.workspaceRoot, config.cwd);
+    const contextPrompt = contextResult.prompt;
+    let totalToolCalls = 0;
+    let totalTokensIn = 0;
+    let totalTokensOut = 0;
+    let turns = 0;
+    let finalText = "";
+    for (let turn = 0; turn < maxTurns; turn++) {
+        const apiMessages = conversation.getApiMessages();
+        const systemMessage = {
+            role: "system",
+            content: contextPrompt,
+        };
+        const allMessages = [
+            systemMessage,
+            ...apiMessages.map((msg) => {
+                if (msg.role === "system")
+                    return { role: "system", content: msg.content };
+                if (msg.role === "user")
+                    return { role: "user", content: msg.content };
+                if (msg.role === "assistant") {
+                    const m = {
+                        role: "assistant",
+                        content: msg.content || null,
+                    };
+                    if (msg.toolCalls && msg.toolCalls.length > 0) {
+                        m.tool_calls = msg.toolCalls.map((tc) => ({
+                            id: tc.id,
+                            type: "function",
+                            function: { name: tc.function.name, arguments: tc.function.arguments },
+                        }));
+                    }
+                    return m;
+                }
+                if (msg.role === "tool") {
+                    return {
+                        role: "tool",
+                        tool_call_id: msg.toolCallId ?? "",
+                        content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content),
+                    };
+                }
+                return { role: "user", content: msg.content };
+            }),
+        ];
+        const stream = await client.chat.completions.create({
+            model,
+            messages: allMessages,
+            tools: openaiTools.length > 0 ? openaiTools : undefined,
+            stream: true,
+            temperature: 0.7,
+            max_tokens: 16384,
+        });
+        let assistantContent = "";
+        const toolCalls = [];
+        let currentToolCall = null;
+        for await (const chunk of stream) {
+            const delta = chunk.choices[0]?.delta;
+            if (!delta)
+                continue;
+            if (delta.content) {
+                assistantContent += delta.content;
+                if (onTextChunk)
+                    onTextChunk(delta.content);
+                else
+                    process.stdout.write(delta.content);
+            }
+            if (delta.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                    if (tc.id && tc.function?.name) {
+                        currentToolCall = {
+                            id: tc.id,
+                            name: tc.function.name,
+                            arguments: tc.function.arguments ?? "",
+                        };
+                        toolCalls.push({
+                            id: tc.id,
+                            type: "function",
+                            function: { name: tc.function.name, arguments: tc.function.arguments ?? "" },
+                        });
+                    }
+                    else if (currentToolCall && tc.function?.arguments) {
+                        currentToolCall.arguments += tc.function.arguments;
+                        const last = toolCalls[toolCalls.length - 1];
+                        if (last)
+                            last.function.arguments = currentToolCall.arguments;
+                    }
+                }
+            }
+            if (chunk.usage) {
+                totalTokensIn += chunk.usage.prompt_tokens ?? 0;
+                totalTokensOut += chunk.usage.completion_tokens ?? 0;
+            }
+        }
+        if (!onTextChunk)
+            console.log();
+        turns++;
+        if (toolCalls.length === 0) {
+            conversation.addAssistantMessage(assistantContent);
+            finalText = assistantContent;
+            break;
+        }
+        conversation.addAssistantMessage(assistantContent, toolCalls);
+        for (const tc of toolCalls) {
+            totalToolCalls++;
+            let toolInput;
+            try {
+                toolInput = JSON.parse(tc.function.arguments);
+            }
+            catch {
+                toolInput = { raw: tc.function.arguments };
+            }
+            const summary = summarizeToolInput(tc.function.name, toolInput);
+            console.log(chalk_1.default.cyan(`  ▶ ${tc.function.name}`) + chalk_1.default.dim(` ${summary}`));
+            const toolCtx = {
+                workspaceRoot: config.workspaceRoot,
+                cwd: config.cwd,
+            };
+            const result = await registry.dispatchAsync(tc.function.name, toolInput, toolCtx);
+            if (result.isError) {
+                console.log(chalk_1.default.red(`  ✗ ${tc.function.name}: ${String(result.output).slice(0, 200)}`));
+            }
+            else {
+                console.log(chalk_1.default.green(`  ✓ ${summarizeToolResult(tc.function.name, result.output)}`));
+            }
+            const resultStr = typeof result.output === "string" ? result.output : JSON.stringify(result.output);
+            conversation.addToolResult(tc.id, resultStr);
+        }
+        if (turn === maxTurns - 1) {
+            finalText = "[Max tool turns reached]";
+        }
+    }
+    return { finalText, totalToolCalls, totalTokensIn, totalTokensOut, turns };
+}
+function summarizeToolInput(name, input) {
+    const n = name.toLowerCase();
+    if (n === "bash") {
+        const cmd = String(input.command ?? "").replace(/\n/g, " ");
+        return cmd.length > 60 ? cmd.slice(0, 57) + "..." : cmd;
+    }
+    if (n === "read" || n === "write" || n === "edit") {
+        return String(input.file_path ?? input.path ?? "");
+    }
+    if (n === "glob")
+        return String(input.pattern ?? "");
+    if (n === "grep")
+        return String(input.pattern ?? "");
+    return "";
+}
+function summarizeToolResult(name, output) {
+    if (typeof output === "string") {
+        return output.length > 100 ? output.slice(0, 97) + "..." : output;
+    }
+    if (typeof output === "object" && output !== null) {
+        const obj = output;
+        if (obj.error)
+            return `error: ${String(obj.error).slice(0, 80)}`;
+        if (obj.numFiles !== undefined)
+            return `${name} · ${obj.numFiles} results`;
+        if (obj.exit_code !== undefined)
+            return `${name} · exit ${obj.exit_code}`;
+    }
+    return `${name} completed`;
+}
+//# sourceMappingURL=loop.js.map

package/dist/agent/planner.d.ts

@@ -0,0 +1,8 @@
+import OpenAI from "openai";
+export interface PlanResult {
+    needsTools: boolean;
+    toolsNeeded: string[];
+    plan: string;
+}
+export declare function planToolUsage(client: OpenAI, model: string, userMessage: string, availableTools: string[]): Promise<PlanResult>;
+//# sourceMappingURL=planner.d.ts.map

package/dist/agent/planner.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planToolUsage = planToolUsage;
+const PLANNER_SYSTEM_PROMPT = `You are a tool-use planner. Given a user message and available tools, decide:
+1. Does this request need any tools? (simple questions like "what is 2+2" do not)
+2. If yes, which specific tools are needed?
+3. What is the execution plan?
+
+Respond in this exact JSON format:
+{"needs_tools": boolean, "tools_needed": ["tool_name", ...], "plan": "brief description"}
+
+Only include tools that are actually necessary. Do not over-plan.`;
+async function planToolUsage(client, model, userMessage, availableTools) {
+    try {
+        const response = await client.chat.completions.create({
+            model,
+            messages: [
+                { role: "system", content: PLANNER_SYSTEM_PROMPT },
+                {
+                    role: "user",
+                    content: `Available tools: ${availableTools.join(", ")}\n\nUser message: ${userMessage}`,
+                },
+            ],
+            max_tokens: 200,
+            temperature: 0,
+        });
+        const content = response.choices[0]?.message?.content?.trim() ?? "";
+        const jsonMatch = content.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return { needsTools: true, toolsNeeded: [], plan: "proceed with all tools" };
+        }
+        const parsed = JSON.parse(jsonMatch[0]);
+        return {
+            needsTools: parsed.needs_tools ?? true,
+            toolsNeeded: parsed.tools_needed ?? [],
+            plan: parsed.plan ?? "",
+        };
+    }
+    catch {
+        return { needsTools: true, toolsNeeded: [], plan: "" };
+    }
+}
+//# sourceMappingURL=planner.js.map

package/dist/auth/client.d.ts

@@ -0,0 +1,4 @@
+import OpenAI from "openai";
+export declare function createClient(): OpenAI;
+export declare function getDefaultModel(): string;
+//# sourceMappingURL=client.d.ts.map

package/dist/auth/client.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createClient = createClient;
+exports.getDefaultModel = getDefaultModel;
+const openai_1 = __importDefault(require("openai"));
+const config_1 = require("./config");
+function createClient() {
+    const apiKey = (0, config_1.loadConfig)().apiKey;
+    if (!apiKey) {
+        console.error("Not logged in. Run: llmtune login");
+        process.exit(1);
+    }
+    return new openai_1.default({
+        apiKey,
+        baseURL: (0, config_1.getApiBase)(),
+    });
+}
+function getDefaultModel() {
+    return (0, config_1.getDefaultModel)();
+}
+//# sourceMappingURL=client.js.map

package/dist/auth/config.d.ts

@@ -0,0 +1,21 @@
+export interface AuthConfig {
+    apiKey: string;
+    apiBase: string;
+    defaultModel?: string;
+}
+export interface AppConfig {
+    defaultProvider?: string;
+    providers?: Record<string, AuthConfig>;
+    [key: string]: unknown;
+}
+export declare function ensureConfigDir(): void;
+export declare function loadConfig(): AppConfig;
+export declare function saveConfig(config: AppConfig): void;
+export declare function getApiKey(): string | null;
+export declare function getApiBase(): string;
+export declare function getDefaultModel(): string;
+export declare function isLoggedIn(): boolean;
+export declare function logout(): void;
+export declare function getConfigPath(): string;
+export declare function getConfigDir(): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/auth/config.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureConfigDir = ensureConfigDir;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.getApiKey = getApiKey;
+exports.getApiBase = getApiBase;
+exports.getDefaultModel = getDefaultModel;
+exports.isLoggedIn = isLoggedIn;
+exports.logout = logout;
+exports.getConfigPath = getConfigPath;
+exports.getConfigDir = getConfigDir;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const CONFIG_DIR = path_1.default.join(os_1.default.homedir(), ".llmtune");
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, "config.json");
+function ensureConfigDir() {
+    if (!fs_1.default.existsSync(CONFIG_DIR)) {
+        fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    const memDir = path_1.default.join(CONFIG_DIR, "memory");
+    if (!fs_1.default.existsSync(memDir)) {
+        fs_1.default.mkdirSync(memDir, { recursive: true });
+    }
+    const sessionsDir = path_1.default.join(CONFIG_DIR, "sessions");
+    if (!fs_1.default.existsSync(sessionsDir)) {
+        fs_1.default.mkdirSync(sessionsDir, { recursive: true });
+    }
+    const logsDir = path_1.default.join(CONFIG_DIR, "logs");
+    if (!fs_1.default.existsSync(logsDir)) {
+        fs_1.default.mkdirSync(logsDir, { recursive: true });
+    }
+}
+function loadConfig() {
+    ensureConfigDir();
+    if (!fs_1.default.existsSync(CONFIG_FILE)) {
+        return {};
+    }
+    try {
+        const raw = fs_1.default.readFileSync(CONFIG_FILE, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+function saveConfig(config) {
+    ensureConfigDir();
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), "utf-8");
+}
+function getApiKey() {
+    const config = loadConfig();
+    return config.apiKey ?? null;
+}
+function getApiBase() {
+    const config = loadConfig();
+    return config.apiBase ?? "https://api.llmtune.io/api/agent/v1";
+}
+function getDefaultModel() {
+    const config = loadConfig();
+    return config.defaultModel ?? "z-ai/GLM-5.1";
+}
+function isLoggedIn() {
+    return getApiKey() !== null;
+}
+function logout() {
+    const config = loadConfig();
+    delete config.apiKey;
+    delete config.apiBase;
+    delete config.defaultModel;
+    saveConfig(config);
+}
+function getConfigPath() {
+    return CONFIG_FILE;
+}
+function getConfigDir() {
+    return CONFIG_DIR;
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/chat.d.ts

@@ -0,0 +1,5 @@
+export declare function chatCommand(options: {
+    model?: string;
+    stream?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=chat.d.ts.map

package/dist/commands/chat.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatCommand = chatCommand;
+const chalk_1 = __importDefault(require("chalk"));
+const config_js_1 = require("../auth/config.js");
+const client_js_1 = require("../auth/client.js");
+const repl_js_1 = require("../repl/repl.js");
+async function chatCommand(options) {
+    const config = (0, config_js_1.loadConfig)();
+    if (!config.apiKey) {
+        console.log(chalk_1.default.red('No API key configured. Run "llmtune login" first.'));
+        process.exit(1);
+    }
+    const client = (0, client_js_1.createClient)();
+    const model = options.model || config.defaultModel || "z-ai/GLM-5.1";
+    const stream = options.stream !== false;
+    console.log(chalk_1.default.cyan(`\nLLMTune CLI`));
+    console.log(chalk_1.default.dim(`Connected to ${(0, config_js_1.getApiBase)()}`));
+    console.log(chalk_1.default.dim(`Model: ${model}`));
+    console.log(chalk_1.default.dim(`Stream: ${stream}`));
+    console.log(chalk_1.default.dim(`Type /help for commands, /exit to quit\n`));
+    await (0, repl_js_1.startRepl)({ client, model, stream });
+}
+//# sourceMappingURL=chat.js.map

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+export declare function showConfig(): void;
+//# sourceMappingURL=config.d.ts.map

package/dist/commands/config.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showConfig = showConfig;
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("../auth/config");
+function showConfig() {
+    const configPath = (0, config_1.getConfigPath)();
+    try {
+        const config = (0, config_1.loadConfig)();
+        console.log(chalk_1.default.bold("\nConfiguration\n"));
+        console.log(`  Config file: ${chalk_1.default.cyan(configPath)}`);
+        const apiKey = config.apiKey;
+        const apiBase = config.apiBase;
+        const defaultModel = config.defaultModel;
+        console.log(`  API base:    ${chalk_1.default.cyan(apiBase ?? "(not set)")}`);
+        console.log(`  Default model: ${chalk_1.default.cyan(defaultModel || "(not set)")}`);
+        if (apiKey) {
+            const masked = apiKey.length > 12
+                ? `${apiKey.slice(0, 6)}...${apiKey.slice(-4)}`
+                : "(set)";
+            console.log(`  API key:     ${chalk_1.default.green(masked)}`);
+        }
+        else {
+            console.log(`  API key:     ${chalk_1.default.red("(not set)")}`);
+            console.log(chalk_1.default.dim(`\n  Run ${chalk_1.default.bold("llmtune login")} to configure your API key.`));
+        }
+        console.log();
+    }
+    catch {
+        console.log(chalk_1.default.dim(`\n  No config found at ${configPath}`));
+        console.log(chalk_1.default.dim(`  Run ${chalk_1.default.bold("llmtune login")} to get started.\n`));
+    }
+}
+//# sourceMappingURL=config.js.map

package/dist/commands/login.d.ts

@@ -0,0 +1,2 @@
+export declare function loginCommand(): Promise<void>;
+//# sourceMappingURL=login.d.ts.map