@llmtune/cli 0.1.0 → 0.1.1

package/dist/compact/service.js

@@ -0,0 +1,156 @@
+"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.compactConversation = compactConversation;
+exports.uncompactConversation = uncompactConversation;
+const tokens_1 = require("../utils/tokens");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const COMPACT_SYSTEM_PROMPT = `CRITICAL: Respond with TEXT ONLY. Do NOT call any tools.
+
+Your task is to create a detailed summary of the conversation so far.
+
+Include:
+1. Primary Request and Intent: What the user asked for
+2. Key Technical Concepts: Technologies, frameworks, patterns discussed
+3. Files and Code Sections: Files examined, modified, or created (with key snippets)
+4. Errors and Fixes: Problems encountered and how they were resolved
+5. Problem Solving: What was accomplished
+6. All User Messages: Summarize all non-tool-result user messages
+7. Pending Tasks: Tasks explicitly requested but not yet done
+8. Current Work: What was being worked on immediately before this summary
+
+Respond ONLY with plain text. No XML tags. No tool calls.`;
+async function compactConversation(client, model, conversation, sessionsDir) {
+    const messages = conversation.messages;
+    const preCompactTokens = (0, tokens_1.estimateTokens)(messages.map((m) => (typeof m.content === "string" ? m.content : JSON.stringify(m.content))).join(" "));
+    const preCompactCount = messages.length;
+    // Save raw history before compacting
+    saveRawHistory(conversation, sessionsDir);
+    // Build context for summary: last N messages
+    const contextMessages = messages.slice(-20);
+    const summaryRequestMessages = contextMessages
+        .filter((m) => m.role !== "system")
+        .map((m) => ({
+        role: m.role,
+        content: typeof m.content === "string" ? m.content : JSON.stringify(m.content),
+    }));
+    summaryRequestMessages.push({ role: "user", content: COMPACT_SYSTEM_PROMPT });
+    let summary = "";
+    try {
+        const response = await client.chat.completions.create({
+            model,
+            messages: summaryRequestMessages,
+            max_tokens: 4096,
+            temperature: 0,
+        });
+        summary = response.choices[0]?.message?.content?.trim() ?? "";
+    }
+    catch {
+        summary = buildFallbackSummary(messages);
+    }
+    if (!summary) {
+        summary = buildFallbackSummary(messages);
+    }
+    // Replace conversation with boundary marker + summary
+    const boundaryMsg = {
+        role: "system",
+        content: `[COMPACT BOUNDARY] Compacted at ${new Date().toISOString()}. ${preCompactCount} messages summarized. Raw history preserved.`,
+    };
+    const summaryMsg = {
+        role: "system",
+        content: `## Conversation Summary\n\n${summary}`,
+    };
+    // Keep system messages + boundary + summary
+    const systemMessages = messages.filter((m) => m.role === "system" && m === messages[0]);
+    conversation.messages.length = 0;
+    conversation.messages.push(...systemMessages, boundaryMsg, summaryMsg);
+    const postCompactTokens = (0, tokens_1.estimateTokens)(conversation.messages.map((m) => (typeof m.content === "string" ? m.content : JSON.stringify(m.content))).join(" "));
+    const postCompactCount = conversation.messages.length;
+    return {
+        tokensSaved: Math.max(0, preCompactTokens - postCompactTokens),
+        preCompactTokens,
+        postCompactTokens,
+        preCompactMessages: preCompactCount,
+        postCompactMessages: postCompactCount,
+        summary,
+    };
+}
+function uncompactConversation(conversation, sessionsDir) {
+    const dir = sessionsDir ?? path.join(os.homedir(), ".llmtune", "sessions");
+    const rawPath = path.join(dir, `${conversation.id}.raw.json`);
+    if (!fs.existsSync(rawPath)) {
+        return false;
+    }
+    try {
+        const raw = JSON.parse(fs.readFileSync(rawPath, "utf-8"));
+        conversation.messages.length = 0;
+        conversation.messages.push(...raw.messages);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function saveRawHistory(conversation, sessionsDir) {
+    const dir = sessionsDir ?? path.join(os.homedir(), ".llmtune", "sessions");
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const rawPath = path.join(dir, `${conversation.id}.raw.json`);
+    if (!fs.existsSync(rawPath)) {
+        fs.writeFileSync(rawPath, JSON.stringify({ messages: conversation.messages }, null, 2), "utf-8");
+    }
+}
+function buildFallbackSummary(messages) {
+    const userMsgs = messages
+        .filter((m) => m.role === "user")
+        .map((m) => (typeof m.content === "string" ? m.content.slice(0, 200) : ""))
+        .filter(Boolean);
+    const toolNames = messages
+        .filter((m) => m.role === "assistant" && m.toolCalls)
+        .flatMap((m) => m.toolCalls?.map((tc) => tc.function.name) ?? []);
+    const parts = [`Conversation had ${messages.length} messages.`];
+    if (toolNames.length > 0) {
+        const unique = [...new Set(toolNames)];
+        parts.push(`Tools used: ${unique.join(", ")}`);
+    }
+    if (userMsgs.length > 0) {
+        parts.push(`Last user message: ${userMsgs[userMsgs.length - 1].slice(0, 150)}`);
+    }
+    return parts.join("\n");
+}
+//# sourceMappingURL=service.js.map

package/dist/context/analyzer.d.ts

@@ -0,0 +1,26 @@
+import type { ToolSpec } from "../tools/protocol";
+export interface ContextCategory {
+    name: string;
+    tokens: number;
+}
+export interface ContextAnalysis {
+    categories: ContextCategory[];
+    totalTokens: number;
+    maxTokens: number;
+    percentage: number;
+    model: string;
+}
+export declare function getContextWindowForModel(model: string): number;
+export declare function analyzeContextUsage(options: {
+    systemPrompt: string;
+    toolSpecs: ToolSpec[];
+    messages: Array<{
+        role: string;
+        content: unknown;
+    }>;
+    skillsContent?: string;
+    memoryContent?: string;
+    model: string;
+}): ContextAnalysis;
+export declare function formatContextAnalysis(analysis: ContextAnalysis): string;
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/context/analyzer.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContextWindowForModel = getContextWindowForModel;
+exports.analyzeContextUsage = analyzeContextUsage;
+exports.formatContextAnalysis = formatContextAnalysis;
+const tokens_1 = require("../utils/tokens");
+const MODEL_CONTEXT_WINDOWS = {
+    "gpt-4o": 128_000,
+    "gpt-4o-mini": 128_000,
+    "gpt-4-turbo": 128_000,
+    "glm-5.1": 128_000,
+    "glm-5-turbo": 128_000,
+    "glm-4.7-flash": 128_000,
+    "claude-sonnet": 200_000,
+    "claude-opus": 200_000,
+    "deepseek-r1": 128_000,
+    "qwen3": 128_000,
+};
+const DEFAULT_CONTEXT_WINDOW = 128_000;
+function getContextWindowForModel(model) {
+    const lower = model.toLowerCase();
+    for (const [name, window] of Object.entries(MODEL_CONTEXT_WINDOWS)) {
+        if (lower.includes(name))
+            return window;
+    }
+    const kMatch = lower.match(/(\d+)k/);
+    if (kMatch)
+        return parseInt(kMatch[1], 10) * 1_000;
+    if (lower.includes("1m") || lower.includes("million"))
+        return 1_000_000;
+    return DEFAULT_CONTEXT_WINDOW;
+}
+function analyzeContextUsage(options) {
+    const categories = [];
+    const systemTokens = (0, tokens_1.estimateTokens)(options.systemPrompt);
+    if (systemTokens > 0) {
+        categories.push({ name: "System prompt", tokens: systemTokens });
+    }
+    let toolTokens = 0;
+    for (const spec of options.toolSpecs) {
+        toolTokens += (0, tokens_1.estimateTokens)(spec.description);
+        toolTokens += (0, tokens_1.estimateTokens)(JSON.stringify(spec.inputSchema));
+    }
+    if (toolTokens > 0) {
+        categories.push({ name: "Tool definitions", tokens: toolTokens });
+    }
+    if (options.skillsContent) {
+        const skillsTokens = (0, tokens_1.estimateTokens)(options.skillsContent);
+        if (skillsTokens > 0) {
+            categories.push({ name: "Skills", tokens: skillsTokens });
+        }
+    }
+    if (options.memoryContent) {
+        const memTokens = (0, tokens_1.estimateTokens)(options.memoryContent);
+        if (memTokens > 0) {
+            categories.push({ name: "Memory", tokens: memTokens });
+        }
+    }
+    let messageTokens = 0;
+    for (const msg of options.messages) {
+        const text = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content ?? "");
+        messageTokens += (0, tokens_1.estimateTokens)(text);
+    }
+    if (messageTokens > 0) {
+        categories.push({ name: "Messages", tokens: messageTokens });
+    }
+    const totalTokens = categories.reduce((sum, c) => sum + c.tokens, 0);
+    const maxTokens = getContextWindowForModel(options.model);
+    const percentage = maxTokens > 0 ? Math.round((totalTokens / maxTokens) * 1000) / 10 : 0;
+    const freeTokens = Math.max(0, maxTokens - totalTokens);
+    categories.push({ name: "Free space", tokens: freeTokens });
+    return { categories, totalTokens, maxTokens, percentage, model: options.model };
+}
+function formatContextAnalysis(analysis) {
+    const lines = [
+        "## Context Usage",
+        "",
+        `**Model:** ${analysis.model}`,
+        `**Tokens:** ${analysis.totalTokens.toLocaleString()} / ${analysis.maxTokens.toLocaleString()} (${analysis.percentage}%)`,
+        "",
+    ];
+    const visible = analysis.categories.filter((c) => c.tokens > 0 && c.name !== "Free space");
+    if (visible.length > 0) {
+        lines.push("| Category | Tokens | Percentage |");
+        lines.push("|----------|--------|------------|");
+        for (const cat of visible) {
+            const pct = analysis.maxTokens > 0 ? ((cat.tokens / analysis.maxTokens) * 100).toFixed(1) : "0.0";
+            lines.push(`| ${cat.name} | ${cat.tokens.toLocaleString()} | ${pct}% |`);
+        }
+        const free = analysis.categories.find((c) => c.name === "Free space");
+        if (free && free.tokens > 0) {
+            const pct = analysis.maxTokens > 0 ? ((free.tokens / analysis.maxTokens) * 100).toFixed(1) : "0.0";
+            lines.push(`| Free space | ${free.tokens.toLocaleString()} | ${pct}% |`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=analyzer.js.map

package/dist/context/builder.d.ts

@@ -0,0 +1,13 @@
+export interface ContextResult {
+    prompt: string;
+    cacheKey: string;
+    cacheHit: boolean;
+    sections: string[];
+}
+export declare function computeCacheKey(workspaceRoot: string, cwd: string): string;
+export declare function readCache(cacheKey: string): ContextResult | null;
+export declare function writeCache(cacheKey: string, result: ContextResult): void;
+export declare function buildContextPrompt(workspaceRoot: string, cwd: string, options?: {
+    useCache?: boolean;
+}): Promise<ContextResult>;
+//# sourceMappingURL=builder.d.ts.map

package/dist/context/builder.js

@@ -0,0 +1,144 @@
+"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.computeCacheKey = computeCacheKey;
+exports.readCache = readCache;
+exports.writeCache = writeCache;
+exports.buildContextPrompt = buildContextPrompt;
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+const fs = __importStar(require("fs"));
+const git_context_1 = require("./git-context");
+const workspace_1 = require("./workspace");
+const llmtune_md_1 = require("./llmtune-md");
+const CACHE_DIR = () => {
+    const base = process.env.LLMTUNE_CACHE_DIR || path.join(process.env.HOME || process.env.USERPROFILE || "~", ".llmtune", "cache");
+    return base;
+};
+function getCachePath(cacheKey) {
+    return path.join(CACHE_DIR(), `${cacheKey}.json`);
+}
+function computeCacheKey(workspaceRoot, cwd) {
+    const git = (0, git_context_1.collectGitContext)(workspaceRoot);
+    const base = `${workspaceRoot}:${cwd}`;
+    if (git.available && git.recentCommit) {
+        return crypto.createHash("sha256").update(`${base}:${git.recentCommit}`).digest("hex").slice(0, 16);
+    }
+    return crypto.createHash("sha256").update(base).digest("hex").slice(0, 16);
+}
+function readCache(cacheKey) {
+    try {
+        const cachePath = getCachePath(cacheKey);
+        if (fs.existsSync(cachePath)) {
+            const stat = fs.statSync(cachePath);
+            const ageMs = Date.now() - stat.mtimeMs;
+            if (ageMs > 30 * 60 * 1000)
+                return null;
+            const data = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
+            return { ...data, cacheHit: true };
+        }
+    }
+    catch { }
+    return null;
+}
+function writeCache(cacheKey, result) {
+    try {
+        const cacheDir = CACHE_DIR();
+        if (!fs.existsSync(cacheDir)) {
+            fs.mkdirSync(cacheDir, { recursive: true });
+        }
+        const cachePath = getCachePath(cacheKey);
+        fs.writeFileSync(cachePath, JSON.stringify({ ...result, cacheHit: false }, null, 2));
+    }
+    catch { }
+}
+async function buildContextPrompt(workspaceRoot, cwd, options) {
+    const cacheKey = computeCacheKey(workspaceRoot, cwd);
+    if (options?.useCache !== false) {
+        const cached = readCache(cacheKey);
+        if (cached)
+            return cached;
+    }
+    const sections = [];
+    // Workspace section (async)
+    const workspace = await (0, workspace_1.buildWorkspaceSnapshot)(workspaceRoot, cwd);
+    const workspaceSection = (0, workspace_1.renderWorkspaceSection)(workspace);
+    if (workspaceSection)
+        sections.push(workspaceSection);
+    // Git section
+    const git = (0, git_context_1.collectGitContext)(workspaceRoot);
+    const gitSection = renderGitSection(git);
+    if (gitSection)
+        sections.push(gitSection);
+    // LLMTUNE.md / CLAUDE.md section
+    const mdFiles = (0, llmtune_md_1.loadProjectInstructions)(workspaceRoot, cwd);
+    const mdSection = renderMdSection(mdFiles, workspaceRoot);
+    if (mdSection)
+        sections.push(mdSection);
+    const prompt = sections.join("\n\n");
+    const result = {
+        prompt,
+        cacheKey,
+        cacheHit: false,
+        sections,
+    };
+    writeCache(cacheKey, result);
+    return result;
+}
+function renderGitSection(git) {
+    if (!git.available)
+        return "";
+    const lines = ["## Git Context"];
+    if (git.branch)
+        lines.push(`- Current branch: ${git.branch}`);
+    if (git.recentCommit)
+        lines.push(`- Latest commit: ${git.recentCommit}`);
+    if (git.status) {
+        lines.push("- Git status snapshot:", "```text", git.status.slice(0, 2000), "```");
+    }
+    return lines.join("\n");
+}
+function renderMdSection(files, workspaceRoot) {
+    if (files.length === 0)
+        return "";
+    const lines = ["## Project Instructions"];
+    for (const f of files) {
+        const relative = path.relative(workspaceRoot, f.path);
+        const label = relative ? `./${relative}` : f.path;
+        lines.push(`### ${label}`, "```md", f.content.slice(0, 4000), "```");
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=builder.js.map

package/dist/context/cache.d.ts

@@ -0,0 +1,6 @@
+import { type ContextResult } from "./builder";
+export type { ContextResult };
+export declare function getContext(workspaceRoot: string, cwd: string, options?: {
+    useCache?: boolean;
+}): Promise<ContextResult>;
+//# sourceMappingURL=cache.d.ts.map

package/dist/context/cache.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContext = getContext;
+const builder_1 = require("./builder");
+async function getContext(workspaceRoot, cwd, options) {
+    return (0, builder_1.buildContextPrompt)(workspaceRoot, cwd, options);
+}
+//# sourceMappingURL=cache.js.map

package/dist/context/git-context.d.ts

@@ -0,0 +1,9 @@
+export interface GitContext {
+    available: boolean;
+    repoRoot: string | null;
+    branch: string | null;
+    recentCommit: string | null;
+    status: string | null;
+}
+export declare function collectGitContext(workspaceRoot: string): GitContext;
+//# sourceMappingURL=git-context.d.ts.map

package/dist/context/git-context.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectGitContext = collectGitContext;
+const child_process_1 = require("child_process");
+function collectGitContext(workspaceRoot) {
+    try {
+        const gitDir = (0, child_process_1.execSync)("git rev-parse --show-toplevel 2>/dev/null", {
+            cwd: workspaceRoot,
+            encoding: "utf-8",
+            timeout: 5000,
+        }).trim();
+        if (!gitDir) {
+            return { available: false, repoRoot: null, branch: null, recentCommit: null, status: null };
+        }
+        const branch = (0, child_process_1.execSync)("git rev-parse --abbrev-ref HEAD 2>/dev/null", {
+            cwd: gitDir,
+            encoding: "utf-8",
+            timeout: 5000,
+        }).trim();
+        const recentCommit = (0, child_process_1.execSync)("git log -1 --oneline 2>/dev/null", {
+            cwd: gitDir,
+            encoding: "utf-8",
+            timeout: 5000,
+        }).trim();
+        let status = null;
+        try {
+            const raw = (0, child_process_1.execSync)("git status --short 2>/dev/null", {
+                cwd: gitDir,
+                encoding: "utf-8",
+                timeout: 5000,
+            }).trim();
+            if (raw) {
+                const lines = raw.split("\n").slice(0, 30);
+                status = lines.join("\n");
+                if (raw.split("\n").length > 30) {
+                    status += `\n... ${raw.split("\n").length - 30} more files`;
+                }
+            }
+        }
+        catch {
+            // status unavailable, non-critical
+        }
+        return { available: true, repoRoot: gitDir, branch, recentCommit, status };
+    }
+    catch {
+        return { available: false, repoRoot: null, branch: null, recentCommit: null, status: null };
+    }
+}
+//# sourceMappingURL=git-context.js.map

package/dist/context/llmtune-md.d.ts

@@ -0,0 +1,6 @@
+export interface MarkdownFile {
+    path: string;
+    content: string;
+}
+export declare function loadProjectInstructions(workspaceRoot: string, cwd: string): MarkdownFile[];
+//# sourceMappingURL=llmtune-md.d.ts.map

package/dist/context/llmtune-md.js

@@ -0,0 +1,73 @@
+"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.loadProjectInstructions = loadProjectInstructions;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FILENAMES = ["LLMTUNE.md", "CLAUDE.md", ".llmtune", ".claude"];
+function loadProjectInstructions(workspaceRoot, cwd) {
+    const files = [];
+    const seen = new Set();
+    const dirsToCheck = [cwd];
+    let current = cwd;
+    while (current !== workspaceRoot && current !== path.dirname(current)) {
+        current = path.dirname(current);
+        dirsToCheck.push(current);
+    }
+    dirsToCheck.push(workspaceRoot);
+    for (const dir of dirsToCheck) {
+        for (const filename of FILENAMES) {
+            const filePath = path.join(dir, filename);
+            const resolved = path.resolve(filePath);
+            if (seen.has(resolved))
+                continue;
+            try {
+                const stat = fs.statSync(filePath);
+                if (stat.isFile()) {
+                    const content = fs.readFileSync(filePath, "utf-8");
+                    if (content.trim()) {
+                        seen.add(resolved);
+                        files.push({ path: resolved, content: content.trim() });
+                    }
+                }
+            }
+            catch {
+                // file doesn't exist, skip
+            }
+        }
+    }
+    return files;
+}
+//# sourceMappingURL=llmtune-md.js.map

package/dist/context/workspace.d.ts

@@ -0,0 +1,11 @@
+export interface WorkspaceSnapshot {
+    workspace_root: string;
+    current_directory: string;
+    top_level_entries: string[];
+    key_files: string[];
+    total_files: number;
+    file_type_counts: Record<string, number>;
+}
+export declare function buildWorkspaceSnapshot(workspaceRoot: string, cwd?: string): Promise<WorkspaceSnapshot>;
+export declare function renderWorkspaceSection(snapshot: WorkspaceSnapshot): string;
+//# sourceMappingURL=workspace.d.ts.map