@llmtune/cli 0.1.0 → 0.1.1

package/dist/context/workspace.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildWorkspaceSnapshot = buildWorkspaceSnapshot;
+exports.renderWorkspaceSection = renderWorkspaceSection;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const KEY_FILE_NAMES = new Set([
+    "package.json",
+    "tsconfig.json",
+    "Cargo.toml",
+    "go.mod",
+    "pyproject.toml",
+    "requirements.txt",
+    "Makefile",
+    "Dockerfile",
+    "docker-compose.yml",
+    "README.md",
+    "CLAUDE.md",
+    "LLMTUNE.md",
+    ".env.example",
+    ".gitignore",
+    "prisma",
+    "schema.prisma",
+]);
+const IGNORED_DIRS = new Set([
+    "node_modules",
+    ".git",
+    "__pycache__",
+    ".next",
+    "dist",
+    "build",
+    ".venv",
+    "venv",
+    ".tox",
+    "target",
+    ".cache",
+    ".turbo",
+    "coverage",
+]);
+async function buildWorkspaceSnapshot(workspaceRoot, cwd) {
+    const root = workspaceRoot;
+    const current = cwd ?? workspaceRoot;
+    const topEntries = await safeReaddir(root);
+    const topLevelEntries = topEntries.map((e) => e.name);
+    const keyFiles = [];
+    const fileTypeCounts = {};
+    let totalFiles = 0;
+    await walkDir(root, "", async (name, relPath, isDir) => {
+        if (isDir)
+            return;
+        totalFiles++;
+        const ext = (0, path_1.extname)(name).toLowerCase();
+        fileTypeCounts[ext] = (fileTypeCounts[ext] ?? 0) + 1;
+        if (KEY_FILE_NAMES.has(name)) {
+            keyFiles.push((0, path_1.relative)(root, (0, path_1.join)(root, relPath, name)));
+        }
+    });
+    return {
+        workspace_root: root,
+        current_directory: current,
+        top_level_entries: topLevelEntries.slice(0, 30),
+        key_files: keyFiles.slice(0, 20),
+        total_files: totalFiles,
+        file_type_counts: fileTypeCounts,
+    };
+}
+function renderWorkspaceSection(snapshot) {
+    const today = new Date().toISOString().split("T")[0];
+    const lines = [
+        "## Runtime Context",
+        `- Today's date: ${today}`,
+        `- Workspace root: ${snapshot.workspace_root}`,
+        `- Current directory: ${snapshot.current_directory}`,
+        `- Total files: ${snapshot.total_files}`,
+    ];
+    const topExts = Object.entries(snapshot.file_type_counts)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5)
+        .map(([ext, count]) => `${ext || "none"}: ${count}`);
+    if (topExts.length > 0) {
+        lines.push(`- Top file types: ${topExts.join(", ")}`);
+    }
+    if (snapshot.key_files.length > 0) {
+        lines.push(`- Key files: ${snapshot.key_files.join(", ")}`);
+    }
+    if (snapshot.top_level_entries.length > 0) {
+        lines.push(`- Top-level entries: ${snapshot.top_level_entries.slice(0, 15).join(", ")}`);
+    }
+    return lines.join("\n");
+}
+async function walkDir(root, relDir, visitor, depth = 0) {
+    if (depth > 3)
+        return;
+    const entries = await safeReaddir((0, path_1.join)(root, relDir));
+    for (const entry of entries) {
+        if (IGNORED_DIRS.has(entry.name))
+            continue;
+        const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+        const isDir = entry.isDirectory();
+        await visitor(entry.name, relDir, isDir);
+        if (isDir && depth < 3) {
+            await walkDir(root, relPath, visitor, depth + 1);
+        }
+    }
+}
+async function safeReaddir(dirPath) {
+    try {
+        const entries = await (0, promises_1.readdir)(dirPath, { withFileTypes: true });
+        return entries;
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=workspace.js.map

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -45,7 +45,7 @@ const repl_1 = require("./repl/repl");
 const program = new commander_1.Command();
 program
     .name("llmtune")
-    .description("LLMTune CLI - AI coding agent powered by api.llmtune.io")
+    .description("AI CLI Agent powered by llmtune.io")
     .version("0.1.0");
 program
     .command("login")

package/dist/marketplace/client.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Skill marketplace client.
+ * Interacts with the infra's skill registry API to list, search, install, and publish skills.
+ */
+import type { AppConfig } from "../auth/config";
+export interface MarketplaceSkill {
+    name: string;
+    description: string;
+    trustLevel: "local" | "community" | "verified" | "signed";
+    allowedTools: string[];
+    author?: string;
+    version?: string;
+    installs?: number;
+    rating?: number;
+    tags?: string[];
+}
+export interface SearchResult {
+    skills: MarketplaceSkill[];
+    total: number;
+    page: number;
+}
+/**
+ * List all skills in the marketplace.
+ */
+export declare function listSkills(config: AppConfig, options?: {
+    search?: string;
+    tag?: string;
+    page?: number;
+    limit?: number;
+}): Promise<SearchResult>;
+/**
+ * Get details for a specific skill.
+ */
+export declare function getSkillDetails(config: AppConfig, name: string): Promise<MarketplaceSkill>;
+/**
+ * Install a skill from the marketplace to the local skills directory.
+ */
+export declare function installSkill(config: AppConfig, name: string): Promise<string>;
+/**
+ * Publish a local skill to the marketplace.
+ */
+export declare function publishSkill(config: AppConfig, skill: {
+    name: string;
+    description: string;
+    content: string;
+    trustLevel: string;
+    allowedTools: string[];
+}): Promise<{
+    published: boolean;
+    skillName: string;
+}>;
+//# sourceMappingURL=client.d.ts.map

package/dist/marketplace/client.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listSkills = listSkills;
+exports.getSkillDetails = getSkillDetails;
+exports.installSkill = installSkill;
+exports.publishSkill = publishSkill;
+function getApiBase(config) {
+    return String(config.apiBase ?? "https://api.llmtune.io/api/agent/v1").replace(/\/$/, "");
+}
+function getHeaders(config) {
+    return {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.apiKey}`,
+    };
+}
+/**
+ * List all skills in the marketplace.
+ */
+async function listSkills(config, options) {
+    const base = getApiBase(config);
+    const params = new URLSearchParams();
+    if (options?.search)
+        params.set("search", options.search);
+    if (options?.tag)
+        params.set("tag", options.tag);
+    if (options?.page)
+        params.set("page", String(options.page));
+    if (options?.limit)
+        params.set("limit", String(options.limit));
+    const url = `${base}/skills?${params.toString()}`;
+    const response = await fetch(url, { headers: getHeaders(config) });
+    if (!response.ok) {
+        throw new Error(`Failed to list skills: HTTP ${response.status}`);
+    }
+    return (await response.json());
+}
+/**
+ * Get details for a specific skill.
+ */
+async function getSkillDetails(config, name) {
+    const base = getApiBase(config);
+    const url = `${base}/skills/${encodeURIComponent(name)}`;
+    const response = await fetch(url, { headers: getHeaders(config) });
+    if (!response.ok) {
+        if (response.status === 404)
+            throw new Error(`Skill not found: ${name}`);
+        throw new Error(`Failed to get skill: HTTP ${response.status}`);
+    }
+    return (await response.json());
+}
+/**
+ * Install a skill from the marketplace to the local skills directory.
+ */
+async function installSkill(config, name) {
+    const base = getApiBase(config);
+    const url = `${base}/skills/install`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: getHeaders(config),
+        body: JSON.stringify({ skillName: name }),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Failed to install skill: ${body}`);
+    }
+    const data = (await response.json());
+    return data.installPath;
+}
+/**
+ * Publish a local skill to the marketplace.
+ */
+async function publishSkill(config, skill) {
+    const base = getApiBase(config);
+    const url = `${base}/skills`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: getHeaders(config),
+        body: JSON.stringify(skill),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new Error(`Failed to publish skill: ${body}`);
+    }
+    return (await response.json());
+}
+//# sourceMappingURL=client.js.map

package/dist/memory/files.d.ts

@@ -0,0 +1,14 @@
+export interface MemoryCategory {
+    key: string;
+    filename: string;
+    description: string;
+}
+export declare const MEMORY_CATEGORIES: MemoryCategory[];
+export declare function getMemoryDir(): string;
+export declare function ensureMemoryDir(): void;
+export declare function readMemory(key: string): string;
+export declare function writeMemory(key: string, content: string): void;
+export declare function appendMemory(key: string, line: string): void;
+export declare function readAllMemory(): Record<string, string>;
+export declare function buildMemoryPrompt(): string;
+//# sourceMappingURL=files.d.ts.map

package/dist/memory/files.js

@@ -0,0 +1,116 @@
+"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.MEMORY_CATEGORIES = void 0;
+exports.getMemoryDir = getMemoryDir;
+exports.ensureMemoryDir = ensureMemoryDir;
+exports.readMemory = readMemory;
+exports.writeMemory = writeMemory;
+exports.appendMemory = appendMemory;
+exports.readAllMemory = readAllMemory;
+exports.buildMemoryPrompt = buildMemoryPrompt;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../auth/config");
+exports.MEMORY_CATEGORIES = [
+    { key: "preferences", filename: "preferences.md", description: "User preferences (language, style, conventions)" },
+    { key: "project", filename: "project-notes.md", description: "Project knowledge (architecture, patterns, key decisions)" },
+    { key: "decisions", filename: "decisions.md", description: "Past decisions and rationale" },
+    { key: "architecture", filename: "architecture.md", description: "System architecture notes" },
+];
+function getMemoryDir() {
+    return path.join((0, config_1.getConfigDir)(), "memory");
+}
+function ensureMemoryDir() {
+    const dir = getMemoryDir();
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    for (const cat of exports.MEMORY_CATEGORIES) {
+        const filePath = path.join(dir, cat.filename);
+        if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, `# ${cat.description}\n\n`, "utf-8");
+        }
+    }
+}
+function readMemory(key) {
+    const cat = exports.MEMORY_CATEGORIES.find((c) => c.key === key);
+    if (!cat)
+        return "";
+    const filePath = path.join(getMemoryDir(), cat.filename);
+    try {
+        return fs.readFileSync(filePath, "utf-8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+function writeMemory(key, content) {
+    const cat = exports.MEMORY_CATEGORIES.find((c) => c.key === key);
+    if (!cat)
+        return;
+    ensureMemoryDir();
+    const filePath = path.join(getMemoryDir(), cat.filename);
+    fs.writeFileSync(filePath, content, "utf-8");
+}
+function appendMemory(key, line) {
+    const current = readMemory(key);
+    writeMemory(key, current + "\n" + line);
+}
+function readAllMemory() {
+    const result = {};
+    for (const cat of exports.MEMORY_CATEGORIES) {
+        const content = readMemory(cat.key);
+        if (content)
+            result[cat.key] = content;
+    }
+    return result;
+}
+function buildMemoryPrompt() {
+    const memories = readAllMemory();
+    const entries = Object.entries(memories);
+    if (entries.length === 0)
+        return "";
+    const lines = ["## User Memory"];
+    for (const [key, content] of entries) {
+        const cat = exports.MEMORY_CATEGORIES.find((c) => c.key === key);
+        if (cat && content.trim()) {
+            lines.push(`### ${cat.description}`);
+            lines.push(content);
+        }
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=files.js.map

package/dist/memory/service.d.ts

@@ -0,0 +1,22 @@
+declare const MEMORY_FILES: {
+    readonly preferences: "preferences.md";
+    readonly "project-notes": "project-notes.md";
+    readonly decisions: "decisions.md";
+    readonly architecture: "architecture.md";
+};
+type MemoryCategory = keyof typeof MEMORY_FILES;
+export interface MemoryEntry {
+    category: MemoryCategory;
+    content: string;
+    path: string;
+}
+export declare function readMemory(category: MemoryCategory): string;
+export declare function writeMemory(category: MemoryCategory, content: string): void;
+export declare function appendMemory(category: MemoryCategory, line: string): void;
+export declare function readAllMemory(): MemoryEntry[];
+export declare function buildMemoryPrompt(): string;
+export declare function clearMemory(category?: MemoryCategory): void;
+export declare function getMemoryDir(): string;
+export declare function initMemoryFiles(): void;
+export {};
+//# sourceMappingURL=service.d.ts.map

package/dist/memory/service.js

@@ -0,0 +1,146 @@
+"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.readMemory = readMemory;
+exports.writeMemory = writeMemory;
+exports.appendMemory = appendMemory;
+exports.readAllMemory = readAllMemory;
+exports.buildMemoryPrompt = buildMemoryPrompt;
+exports.clearMemory = clearMemory;
+exports.getMemoryDir = getMemoryDir;
+exports.initMemoryFiles = initMemoryFiles;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const MEMORY_DIR = path.join(os.homedir(), ".llmtune", "memory");
+const MEMORY_FILES = {
+    preferences: "preferences.md",
+    "project-notes": "project-notes.md",
+    decisions: "decisions.md",
+    architecture: "architecture.md",
+};
+function ensureMemoryDir() {
+    if (!fs.existsSync(MEMORY_DIR)) {
+        fs.mkdirSync(MEMORY_DIR, { recursive: true });
+    }
+}
+function getMemoryPath(category) {
+    return path.join(MEMORY_DIR, MEMORY_FILES[category]);
+}
+function readMemory(category) {
+    const filePath = getMemoryPath(category);
+    try {
+        return fs.readFileSync(filePath, "utf-8").trim();
+    }
+    catch {
+        return "";
+    }
+}
+function writeMemory(category, content) {
+    ensureMemoryDir();
+    const filePath = getMemoryPath(category);
+    fs.writeFileSync(filePath, content.trim() + "\n", "utf-8");
+}
+function appendMemory(category, line) {
+    ensureMemoryDir();
+    const existing = readMemory(category);
+    const updated = existing ? `${existing}\n${line}` : line;
+    writeMemory(category, updated);
+}
+function readAllMemory() {
+    ensureMemoryDir();
+    const entries = [];
+    for (const [category, filename] of Object.entries(MEMORY_FILES)) {
+        const content = readMemory(category);
+        if (content) {
+            entries.push({
+                category: category,
+                content,
+                path: path.join(MEMORY_DIR, filename),
+            });
+        }
+    }
+    return entries;
+}
+function buildMemoryPrompt() {
+    const entries = readAllMemory();
+    if (entries.length === 0)
+        return "";
+    const sections = entries.map((entry) => {
+        const label = entry.category.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+        return `### ${label}\n${entry.content}`;
+    });
+    return "## User Memory\n\n" + sections.join("\n\n");
+}
+function clearMemory(category) {
+    if (category) {
+        const filePath = getMemoryPath(category);
+        try {
+            fs.unlinkSync(filePath);
+        }
+        catch {
+            // file doesn't exist
+        }
+    }
+    else {
+        for (const filename of Object.values(MEMORY_FILES)) {
+            try {
+                fs.unlinkSync(path.join(MEMORY_DIR, filename));
+            }
+            catch {
+                // skip
+            }
+        }
+    }
+}
+function getMemoryDir() {
+    return MEMORY_DIR;
+}
+function initMemoryFiles() {
+    ensureMemoryDir();
+    const defaults = {
+        preferences: "# User Preferences\n# Add your coding preferences here (one per line)\n# Example: I prefer TypeScript over JavaScript\n# Example: I use 2-space indentation\n",
+        "project-notes": "# Project Notes\n# Key facts about the current project\n# Example: Auth uses JWT + bcrypt\n# Example: Database is Neon PostgreSQL via Prisma\n",
+        decisions: "# Architecture Decisions\n# Record important technical decisions\n# Example: Decided to use Prisma instead of Drizzle for ORM\n",
+        architecture: "# Architecture Overview\n# Describe the project structure\n# Example: Frontend: Next.js 16, Backend: Express 5, DB: Neon\n",
+    };
+    for (const [category, defaultContent] of Object.entries(defaults)) {
+        const filePath = getMemoryPath(category);
+        if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, defaultContent, "utf-8");
+        }
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/repl/repl.d.ts

@@ -0,0 +1,8 @@
+import OpenAI from "openai";
+export interface ReplOptions {
+    client: OpenAI;
+    model: string;
+    stream: boolean;
+}
+export declare function startRepl(options: ReplOptions): Promise<void>;
+//# sourceMappingURL=repl.d.ts.map