@sean.holung/minicode 0.2.0 → 0.2.2

package/dist/src/ui/cli-ink.js

@@ -1,10 +1,10 @@
 import process from "node:process";
-import { CodingAgent } from "../agent/agent.js";
+import { CodingAgent, createModelClient } from "@minicode/agent-sdk";
 import { formatConfigForDisplay, loadAgentConfig } from "../agent/config.js";
 import { computeFileHashes, getWorkspaceCacheDir, loadIndex, saveIndex, } from "../indexer/cache.js";
 import { buildProjectIndex } from "../indexer/project-index.js";
-import { createModelClient } from "../model/client.js";
-import { ToolRegistry } from "../tools/registry.js";
+import { listSessions, loadSession, loadSessionByLabel, saveSession, } from "../session/session-store.js";
+import { createToolRegistry } from "../tools/registry.js";
 import { UiStore } from "./state/ui-store.js";
 import { runInkApp } from "./app.js";
 export async function runInkCli(verbose, initialTask) {
@@ -39,19 +39,9 @@ export async function runInkCli(verbose, initialTask) {
         indexStatus,
     });
     store.setPhase("idle");
-    const toolRegistry = ToolRegistry.createDefault(config, projectIndex);
-    const agent = new CodingAgent({
-        config,
-        modelClient,
-        toolRegistry,
-        verbose,
-        ...(projectIndex !== undefined ? { projectIndex } : {}),
-        ...(verbose
-            ? {
-                onProgress: (msg) => store.addItem({ type: "system", content: msg }),
-            }
-            : {}),
-        onUiUpdate: (event) => {
+    const toolRegistry = createToolRegistry(config, projectIndex);
+    function createUiUpdateHandler() {
+        return (event) => {
             switch (event.type) {
                 case "streaming_chunk":
                     store.appendToStreamingContent(event.content);
@@ -85,8 +75,27 @@ export async function runInkCli(verbose, initialTask) {
                     store.setPhase("model_wait");
                     break;
             }
-        },
-    });
+        };
+    }
+    function buildAgent(session) {
+        return new CodingAgent({
+            config,
+            modelClient,
+            toolRegistry,
+            verbose,
+            ...(session ? { session } : {}),
+            ...(projectIndex !== undefined
+                ? { getCodeMap: () => projectIndex.getCodeMap() }
+                : {}),
+            ...(verbose
+                ? {
+                    onProgress: (msg) => store.addItem({ type: "system", content: msg }),
+                }
+                : {}),
+            onUiUpdate: createUiUpdateHandler(),
+        });
+    }
+    let agent = buildAgent();
     let turnAbortController = null;
     const handleCtrlC = (inkExit) => {
         if (turnAbortController) {
@@ -112,7 +121,7 @@ export async function runInkCli(verbose, initialTask) {
         if (trimmed === "/help") {
             store.addItem({
                 type: "system",
-                content: 'Commands: "/help", "/config", "/exit". Start with --verbose or -v for detailed logs.',
+                content: 'Commands: "/help", "/config", "/save [label]", "/load [label]", "/sessions", "/exit".',
             });
             return;
         }
@@ -123,6 +132,69 @@ export async function runInkCli(verbose, initialTask) {
             });
             return;
         }
+        if (trimmed === "/save" || trimmed.startsWith("/save ")) {
+            const label = trimmed.slice("/save".length).trim() || undefined;
+            try {
+                const meta = await saveSession(agent.getSession(), label);
+                store.addItem({
+                    type: "system",
+                    content: `Session saved as "${meta.label}" (${meta.messageCount} messages)`,
+                });
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : "Unknown error";
+                store.addItem({ type: "system", content: `Failed to save session: ${msg}` });
+            }
+            return;
+        }
+        if (trimmed === "/sessions") {
+            const sessions = await listSessions();
+            if (sessions.length === 0) {
+                store.addItem({ type: "system", content: "No saved sessions found." });
+            }
+            else {
+                const lines = sessions.map((s) => `  ${s.label} (${s.messageCount} msgs, saved ${s.savedAt})`);
+                store.addItem({
+                    type: "system",
+                    content: "Saved sessions:\n" + lines.join("\n"),
+                });
+            }
+            return;
+        }
+        if (trimmed === "/load" || trimmed.startsWith("/load ")) {
+            const arg = trimmed.slice("/load".length).trim();
+            if (arg.length === 0) {
+                const sessions = await listSessions();
+                if (sessions.length === 0) {
+                    store.addItem({ type: "system", content: "No saved sessions found." });
+                }
+                else {
+                    const lines = sessions.map((s) => `  ${s.label} (${s.messageCount} msgs, saved ${s.savedAt})`);
+                    store.addItem({
+                        type: "system",
+                        content: "Saved sessions:\n" +
+                            lines.join("\n") +
+                            '\n\nUse "/load <label>" to restore a session.',
+                    });
+                }
+                return;
+            }
+            const result = (await loadSessionByLabel(arg)) ??
+                (await loadSession(arg));
+            if (!result) {
+                store.addItem({
+                    type: "system",
+                    content: `No session found matching "${arg}".`,
+                });
+                return;
+            }
+            agent = buildAgent(result.session);
+            store.addItem({
+                type: "system",
+                content: `Session "${result.label}" restored (${result.session.getMessages().length} messages).`,
+            });
+            return;
+        }
         store.addItem({ type: "user", content: trimmed });
         store.setPhase("sending");
         store.setStep(0);

package/dist/tests/agent.test.js

@@ -1,9 +1,8 @@
 import assert from "node:assert/strict";
 import path from "node:path";
 import { test } from "node:test";
-import { CodingAgent } from "../src/agent/agent.js";
+import { CodingAgent, ToolRegistry, } from "@minicode/agent-sdk";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
-import { ToolRegistry } from "../src/tools/registry.js";
 import { createTestAgentConfig } from "./test-utils.js";
 class SequenceModelClient {
     responses;
@@ -122,7 +121,7 @@ test("agent includes code map in system prompt when projectIndex is provided", a
         config: createTestAgentConfig(root),
         modelClient: spyClient,
         toolRegistry: new ToolRegistry([createEchoTool()]),
-        projectIndex,
+        getCodeMap: () => projectIndex.getCodeMap(),
     });
     await agent.runTurn("List the project structure");
     assert.ok(capturedSystem.includes("[Project Code Map]"));

package/dist/tests/cli-args.test.js

@@ -0,0 +1,73 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import { CliUsageError, parseCliArgs, validateCliArgs, } from "../src/cli/args.js";
+test("parseCliArgs parses oneshot and verbose flags", () => {
+    const parsed = parseCliArgs([
+        "node",
+        "src/index.ts",
+        "--oneshot",
+        "-v",
+        "Fix",
+        "lint",
+    ]);
+    assert.equal(parsed.oneshot, true);
+    assert.equal(parsed.verbose, true);
+    assert.equal(parsed.task, "Fix lint");
+});
+test("parseCliArgs supports -1 short flag", () => {
+    const parsed = parseCliArgs([
+        "node",
+        "src/index.ts",
+        "-1",
+        "refactor",
+        "parser",
+    ]);
+    assert.equal(parsed.oneshot, true);
+    assert.equal(parsed.verbose, false);
+    assert.equal(parsed.task, "refactor parser");
+});
+test("parseCliArgs supports --json and --out path", () => {
+    const parsed = parseCliArgs([
+        "node",
+        "src/index.ts",
+        "--oneshot",
+        "--json",
+        "--out",
+        "result.json",
+        "summarize",
+        "todos",
+    ]);
+    assert.equal(parsed.oneshot, true);
+    assert.equal(parsed.json, true);
+    assert.equal(parsed.outFile, "result.json");
+    assert.equal(parsed.task, "summarize todos");
+});
+test("parseCliArgs supports --out=<file>", () => {
+    const parsed = parseCliArgs([
+        "node",
+        "src/index.ts",
+        "--oneshot",
+        "--out=result.txt",
+        "do",
+        "work",
+    ]);
+    assert.equal(parsed.outFile, "result.txt");
+    assert.equal(parsed.task, "do work");
+});
+test("parseCliArgs rejects --out without value", () => {
+    assert.throws(() => parseCliArgs(["node", "src/index.ts", "--oneshot", "--out"]), CliUsageError);
+});
+test("validateCliArgs rejects oneshot without task", () => {
+    assert.throws(() => validateCliArgs({ verbose: false, oneshot: true, json: false, task: "" }), /--oneshot requires a task prompt/);
+});
+test("validateCliArgs rejects json without oneshot", () => {
+    assert.throws(() => validateCliArgs({
+        verbose: false,
+        oneshot: false,
+        json: true,
+        task: "hello",
+    }), /only supported with --oneshot/);
+});
+test("validateCliArgs allows non-oneshot empty task", () => {
+    assert.doesNotThrow(() => validateCliArgs({ verbose: false, oneshot: false, json: false, task: "" }));
+});

package/dist/tests/cli-oneshot.integration.test.js

@@ -0,0 +1,26 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { test } from "node:test";
+const repoRoot = path.resolve(import.meta.dirname, "..");
+const cliEntry = path.join(repoRoot, "src", "index.ts");
+function runCli(args) {
+    return spawnSync("node", ["--import", "tsx", cliEntry, ...args], {
+        cwd: repoRoot,
+        env: {
+            ...process.env,
+            CLI_UI_MODE: "legacy",
+        },
+        encoding: "utf8",
+    });
+}
+test("oneshot mode exits with usage code when prompt is missing", () => {
+    const result = runCli(["--oneshot"]);
+    assert.equal(result.status, 2);
+    assert.match(result.stderr, /--oneshot requires a task prompt/);
+});
+test("oneshot mode exits with usage code when --out has no value", () => {
+    const result = runCli(["--oneshot", "--out"]);
+    assert.equal(result.status, 2);
+    assert.match(result.stderr, /--out requires a file path/);
+});

package/dist/tests/dependency-graph.test.js

@@ -6,22 +6,22 @@ test("buildProjectIndex produces dependency edges", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const index = await buildProjectIndex(root);
     assert.ok(index.dependencyEdges.length > 0, "should have dependency edges");
-    const parseResponseRefs = index.dependencyEdges.filter((e) => e.from === "parseResponse");
-    assert.ok(parseResponseRefs.some((e) => e.to === "ModelResponse"), "parseResponse should reference ModelResponse");
-    assert.ok(parseResponseRefs.some((e) => e.to === "ToolCall"), "parseResponse should reference ToolCall");
+    const createToolRegistryRefs = index.dependencyEdges.filter((e) => e.from === "createToolRegistry");
+    assert.ok(createToolRegistryRefs.some((e) => e.to === "ProjectIndex"), "createToolRegistry should reference ProjectIndex");
+    assert.ok(createToolRegistryRefs.some((e) => e.to === "AgentConfig"), "createToolRegistry should reference AgentConfig");
 });
-test("createModelClient has expected dependencies", async () => {
+test("loadAgentConfig has expected dependencies", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const index = await buildProjectIndex(root);
-    const edges = index.dependencyEdges.filter((e) => e.from === "createModelClient");
-    assert.ok(edges.some((e) => e.to === "AgentConfig"), "createModelClient should reference AgentConfig");
-    assert.ok(edges.length >= 1, "createModelClient should have at least one dependency");
+    const edges = index.dependencyEdges.filter((e) => e.from === "loadAgentConfig");
+    assert.ok(edges.some((e) => e.to === "AgentConfig"), "loadAgentConfig should reference AgentConfig");
+    assert.ok(edges.length >= 1, "loadAgentConfig should have at least one dependency");
 });
-test("AnthropicModelClient implements ModelClient", async () => {
+test("buildProjectIndex indexes config and tool files", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const index = await buildProjectIndex(root);
-    const implementsEdge = index.dependencyEdges.find((e) => e.from === "AnthropicModelClient" &&
-        e.to === "ModelClient" &&
-        e.kind === "implements");
-    assert.ok(implementsEdge, "AnthropicModelClient should implement ModelClient");
+    const configSymbols = index.getSymbolsInFile("src/agent/config.ts");
+    assert.ok(configSymbols.some((s) => s.name === "loadAgentConfig"), "should index loadAgentConfig from config.ts");
+    const registrySymbols = index.getSymbolsInFile("src/tools/registry.ts");
+    assert.ok(registrySymbols.some((s) => s.name === "createToolRegistry"), "should index createToolRegistry from registry.ts");
 });

package/dist/tests/file-tools.test.js

@@ -3,9 +3,8 @@ import { mkdtemp, readFile, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import path from "node:path";
 import { test } from "node:test";
+import { createEditFileTool, createReadFileTool } from "@minicode/agent-sdk";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
-import { createEditFileTool } from "../src/tools/edit-file.js";
-import { createReadFileTool } from "../src/tools/read-file.js";
 import { createTestAgentConfig } from "./test-utils.js";
 async function createTempWorkspace() {
     return mkdtemp(path.join(tmpdir(), "minicode-tests-"));
@@ -50,7 +49,7 @@ test("edit_file triggers reindex when projectIndex provided", async () => {
     const index = await buildProjectIndex(workspaceRoot);
     const before = index.getSymbol("add");
     assert.ok(before?.signature.includes("a: number, b: number"));
-    const editTool = createEditFileTool(createTestAgentConfig(workspaceRoot), index);
+    const editTool = createEditFileTool(createTestAgentConfig(workspaceRoot), { afterEdit: (relPath, content) => index.reindexFile(relPath, content) });
     await editTool.execute({
         path: "src/util.ts",
         old_string: "a: number, b: number",

package/dist/tests/find-references.test.js

@@ -3,13 +3,13 @@ import path from "node:path";
 import { test } from "node:test";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createFindReferencesTool } from "../src/tools/find-references.js";
-test("find_references returns symbols that reference ModelResponse", async () => {
+test("find_references returns symbols that reference ProjectIndex", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const projectIndex = await buildProjectIndex(root);
     const tool = createFindReferencesTool(projectIndex);
-    const result = await tool.execute({ name: "ModelResponse" });
-    assert.ok(result.includes("# References to ModelResponse"));
-    assert.ok(result.includes("parseResponse"));
+    const result = await tool.execute({ name: "ProjectIndex" });
+    assert.ok(result.includes("# References to ProjectIndex"));
+    assert.ok(result.includes("createToolRegistry") || result.includes("createReadSymbolTool"));
 });
 test("find_references returns error for unknown symbol", async () => {
     const root = path.resolve(import.meta.dirname, "..");
@@ -21,9 +21,9 @@ test("find_references returns error for unknown symbol", async () => {
 test("find_references appears in tool registry when projectIndex provided", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const projectIndex = await buildProjectIndex(root);
-    const { ToolRegistry } = await import("../src/tools/registry.js");
+    const { createToolRegistry } = await import("../src/tools/registry.js");
     const { createTestAgentConfig } = await import("./test-utils.js");
-    const registry = ToolRegistry.createDefault(createTestAgentConfig(root), projectIndex);
+    const registry = createToolRegistry(createTestAgentConfig(root), projectIndex);
     const schemas = registry.getToolSchemas();
     const findRefs = schemas.find((s) => s.name === "find_references");
     assert.ok(findRefs);

package/dist/tests/guardrails.test.js

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { resolveWorkspacePath, validateCommand, validatePath, } from "../src/safety/guardrails.js";
+import { resolveWorkspacePath, validateCommand, validatePath, } from "@minicode/agent-sdk";
 test("validatePath allows files within workspace", () => {
     const workspaceRoot = "/tmp/workspace";
     assert.equal(validatePath("src/index.ts", workspaceRoot), true);

package/dist/tests/indexer.test.js

@@ -96,12 +96,12 @@ test("buildProjectIndex works on minicode src/", async () => {
     const index = await buildProjectIndex(root);
     assert.ok(index.symbols.size > 0);
     assert.ok(index.files.size > 0);
-    const agentSymbols = index.getSymbolsInFile("src/agent/agent.ts");
-    assert.ok(agentSymbols.length >= 1);
-    assert.ok(agentSymbols.some((s) => s.name === "CodingAgent"));
+    const configSymbols = index.getSymbolsInFile("src/agent/config.ts");
+    assert.ok(configSymbols.length >= 1);
+    assert.ok(configSymbols.some((s) => s.name === "loadAgentConfig"));
     const codeMap = index.getCodeMap();
     assert.ok(codeMap.text.includes("CodingAgent"));
-    assert.ok(codeMap.text.includes("runTurn"));
+    assert.ok(codeMap.totalCount > 0);
 });
 test("getPluginForFile routes .tsx, .js, .jsx to TypeScript plugin", async () => {
     const plugins = await loadPlugins("/tmp");
@@ -141,10 +141,10 @@ test("TypeScript plugin handles malformed syntax", () => {
 test("ProjectIndex getSymbol finds by qualifiedName and by name", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const index = await buildProjectIndex(root);
-    const byQualified = index.getSymbol("CodingAgent.runTurn");
+    const byQualified = index.getSymbol("loadAgentConfig");
     assert.ok(byQualified);
-    assert.equal(byQualified.qualifiedName, "CodingAgent.runTurn");
-    const byName = index.getSymbol("runTurn");
+    assert.equal(byQualified.qualifiedName, "loadAgentConfig");
+    const byName = index.getSymbol("formatConfigForDisplay");
     assert.ok(byName, "getSymbol should find by name when unique");
 });
 test("ProjectIndex getSymbolsInFile returns empty for non-existent file", async () => {
@@ -157,10 +157,10 @@ test("ProjectIndex getSymbolsInFile returns empty for non-existent file", async
 test("ProjectIndex getDependencyCone returns target and dependencies", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const index = await buildProjectIndex(root);
-    const cone = index.getDependencyCone("parseResponse", 1);
+    const cone = index.getDependencyCone("loadAgentConfig", 1);
     assert.ok(Array.isArray(cone));
     assert.ok(cone.length >= 1, "should include target symbol");
-    assert.ok(cone.some((s) => s.qualifiedName === "parseResponse"), "should include parseResponse");
+    assert.ok(cone.some((s) => s.qualifiedName === "loadAgentConfig"), "should include loadAgentConfig");
 });
 test("Code map handles empty symbols map", () => {
     const result = generateCodeMap(new Map());

package/dist/tests/model-client-openai.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { OpenAICompatibleModelClient, createModelClient, } from "../src/model/client.js";
+import { OpenAICompatibleModelClient, createModelClient, } from "@minicode/agent-sdk";
 import { createTestAgentConfig } from "./test-utils.js";
 test("openai-compatible client sends tool schemas and parses tool calls", async () => {
     let capturedUrl = "";

package/dist/tests/read-symbol.test.js

@@ -3,19 +3,19 @@ import path from "node:path";
 import { test } from "node:test";
 import { buildProjectIndex } from "../src/indexer/project-index.js";
 import { createReadSymbolTool } from "../src/tools/read-symbol.js";
-import { ToolRegistry } from "../src/tools/registry.js";
+import { createToolRegistry } from "../src/tools/registry.js";
 import { createTestAgentConfig } from "./test-utils.js";
 test("read_symbol returns correct function body", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const config = createTestAgentConfig(root);
     const projectIndex = await buildProjectIndex(root);
     const tool = createReadSymbolTool(config, projectIndex);
-    const result = await tool.execute({ name: "CodingAgent.runTurn" });
-    assert.ok(result.includes("# CodingAgent.runTurn"));
-    assert.ok(result.includes("src/agent/agent.ts"));
+    const result = await tool.execute({ name: "loadAgentConfig" });
+    assert.ok(result.includes("# loadAgentConfig"));
+    assert.ok(result.includes("src/agent/config.ts"));
     assert.ok(result.includes("Lines:"));
     assert.ok(/\d+\|/.test(result), "should have line numbers");
-    assert.ok(result.includes("runTurn") || result.includes("session"));
+    assert.ok(result.includes("loadAgentConfig") || result.includes("config"));
 });
 test("read_symbol returns error for unknown symbol name", async () => {
     const root = path.resolve(import.meta.dirname, "..");
@@ -32,13 +32,13 @@ test("read_symbol with includeBody: false returns signature only", async () => {
     const projectIndex = await buildProjectIndex(root);
     const tool = createReadSymbolTool(config, projectIndex);
     const result = await tool.execute({
-        name: "parseResponse",
+        name: "formatConfigForDisplay",
         includeBody: false,
     });
-    assert.ok(result.includes("# parseResponse"));
-    assert.ok(result.includes("src/model/client.ts"));
-    assert.ok(!result.includes("return {"));
-    assert.ok(result.includes("ModelResponse") || result.includes("=>"));
+    assert.ok(result.includes("# formatConfigForDisplay"));
+    assert.ok(result.includes("src/agent/config.ts"));
+    assert.ok(!result.includes("return lines.join"));
+    assert.ok(result.includes("config") || result.includes("=>"));
 });
 test("read_symbol includes leading context and line numbers", async () => {
     const root = path.resolve(import.meta.dirname, "..");
@@ -56,7 +56,7 @@ test("read_symbol appears in tool registry schemas when projectIndex provided",
     const root = path.resolve(import.meta.dirname, "..");
     const config = createTestAgentConfig(root);
     const projectIndex = await buildProjectIndex(root);
-    const registry = ToolRegistry.createDefault(config, projectIndex);
+    const registry = createToolRegistry(config, projectIndex);
     const schemas = registry.getToolSchemas();
     const readSymbol = schemas.find((s) => s.name === "read_symbol");
     assert.ok(readSymbol, "read_symbol should be in schemas");
@@ -64,19 +64,18 @@ test("read_symbol appears in tool registry schemas when projectIndex provided",
     const props = readSymbol.input_schema.properties;
     assert.ok(props && "name" in props);
 });
-test("read_symbol includes Referenced Types section for parseResponse", async () => {
+test("read_symbol includes Referenced Types section for createToolRegistry", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const config = createTestAgentConfig(root);
     const projectIndex = await buildProjectIndex(root);
     const tool = createReadSymbolTool(config, projectIndex);
-    const result = await tool.execute({ name: "parseResponse" });
-    assert.ok(result.includes("## Referenced Types"));
-    assert.ok(result.includes("ModelResponse"));
-    assert.ok(result.includes("ToolCall"));
+    const result = await tool.execute({ name: "createToolRegistry" });
+    assert.ok(result.includes("# createToolRegistry"));
+    assert.ok(result.includes("src/tools/registry.ts"));
 });
 test("read_symbol is not in tool registry when projectIndex is undefined", () => {
     const config = createTestAgentConfig("/tmp");
-    const registry = ToolRegistry.createDefault(config);
+    const registry = createToolRegistry(config);
     const schemas = registry.getToolSchemas();
     const readSymbol = schemas.find((s) => s.name === "read_symbol");
     assert.equal(readSymbol, undefined);

package/dist/tests/search-code-map.test.js

@@ -21,9 +21,9 @@ test("search_code_map returns empty when no match", async () => {
 test("search_code_map appears in tool registry when projectIndex provided", async () => {
     const root = path.resolve(import.meta.dirname, "..");
     const projectIndex = await buildProjectIndex(root);
-    const { ToolRegistry } = await import("../src/tools/registry.js");
+    const { createToolRegistry } = await import("../src/tools/registry.js");
     const { createTestAgentConfig } = await import("./test-utils.js");
-    const registry = ToolRegistry.createDefault(createTestAgentConfig(root), projectIndex);
+    const registry = createToolRegistry(createTestAgentConfig(root), projectIndex);
     const schemas = registry.getToolSchemas();
     const searchCodeMap = schemas.find((s) => s.name === "search_code_map");
     assert.ok(searchCodeMap);

package/dist/tests/session-store.test.js

@@ -0,0 +1,115 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, readdir, rm } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+import { Session } from "@minicode/agent-sdk";
+import { listSessions, loadSession, loadSessionByLabel, saveSession, setSessionsDir, } from "../src/session/session-store.js";
+async function withTmpDir(fn) {
+    const dir = await mkdtemp(path.join(os.tmpdir(), "minicode-test-"));
+    setSessionsDir(dir);
+    try {
+        await fn(dir);
+    }
+    finally {
+        await rm(dir, { recursive: true, force: true });
+    }
+}
+test("saveSession creates a JSON file in sessions dir", async () => {
+    await withTmpDir(async (dir) => {
+        const session = new Session("test-id");
+        session.addMessage({ role: "user", content: "hello" });
+        session.addMessage({ role: "assistant", content: "hi there" });
+        const meta = await saveSession(session, "my label");
+        assert.equal(meta.id, "test-id");
+        assert.equal(meta.label, "my label");
+        assert.equal(meta.messageCount, 2);
+        const files = await readdir(dir);
+        assert.equal(files.length, 1);
+        assert.equal(files[0], "test-id.json");
+    });
+});
+test("saveSession uses timestamp label when none provided", async () => {
+    await withTmpDir(async () => {
+        const session = new Session("test-id");
+        const meta = await saveSession(session);
+        assert.ok(meta.label.length > 0);
+    });
+});
+test("listSessions returns empty array when no sessions dir", async () => {
+    const nonexistent = path.join(os.tmpdir(), "minicode-nonexistent-" + Date.now());
+    setSessionsDir(nonexistent);
+    const sessions = await listSessions();
+    assert.equal(sessions.length, 0);
+});
+test("listSessions returns saved sessions sorted by savedAt desc", async () => {
+    await withTmpDir(async () => {
+        const s1 = new Session("s1");
+        s1.addMessage({ role: "user", content: "first" });
+        await saveSession(s1, "first session");
+        // Small delay to ensure distinct timestamps for ordering
+        await new Promise((r) => setTimeout(r, 50));
+        const s2 = new Session("s2");
+        s2.addMessage({ role: "user", content: "second" });
+        s2.addMessage({ role: "assistant", content: "reply" });
+        await saveSession(s2, "second session");
+        const sessions = await listSessions();
+        assert.equal(sessions.length, 2);
+        assert.equal(sessions[0]?.label, "second session");
+        assert.equal(sessions[1]?.label, "first session");
+    });
+});
+test("loadSession restores a session by id", async () => {
+    await withTmpDir(async () => {
+        const session = new Session("test-id");
+        session.addMessage({ role: "user", content: "hello" });
+        session.addMessage({ role: "assistant", content: "hi" });
+        await saveSession(session, "test label");
+        const result = await loadSession("test-id");
+        assert.ok(result);
+        assert.equal(result.label, "test label");
+        assert.equal(result.session.id, "test-id");
+        const msgs = result.session.getMessages();
+        assert.equal(msgs.length, 2);
+        assert.equal(msgs[0]?.content, "hello");
+        assert.equal(msgs[1]?.content, "hi");
+    });
+});
+test("loadSession returns undefined for missing id", async () => {
+    await withTmpDir(async () => {
+        const result = await loadSession("nonexistent");
+        assert.equal(result, undefined);
+    });
+});
+test("loadSessionByLabel finds session by label (case-insensitive)", async () => {
+    await withTmpDir(async () => {
+        const session = new Session("test-id");
+        session.addMessage({ role: "user", content: "hello" });
+        await saveSession(session, "My Label");
+        const result = await loadSessionByLabel("my label");
+        assert.ok(result);
+        assert.equal(result.label, "My Label");
+        assert.equal(result.session.id, "test-id");
+    });
+});
+test("loadSessionByLabel returns undefined for no match", async () => {
+    await withTmpDir(async () => {
+        const result = await loadSessionByLabel("nope");
+        assert.equal(result, undefined);
+    });
+});
+test("saving same session twice overwrites the file", async () => {
+    await withTmpDir(async (dir) => {
+        const session = new Session("test-id");
+        session.addMessage({ role: "user", content: "hello" });
+        await saveSession(session, "v1");
+        session.addMessage({ role: "assistant", content: "reply" });
+        await saveSession(session, "v2");
+        const files = await readdir(dir);
+        assert.equal(files.length, 1);
+        const result = await loadSession("test-id");
+        assert.ok(result);
+        assert.equal(result.label, "v2");
+        assert.equal(result.session.getMessages().length, 2);
+    });
+});

package/dist/tests/session.test.js

@@ -1,6 +1,6 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { Session } from "../src/session/session.js";
+import { Session } from "@minicode/agent-sdk";
 test("session stores and returns messages", () => {
     const session = new Session("test");
     session.addMessage({ role: "user", content: "hello" });

package/dist/tests/system-prompt.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import path from "node:path";
 import { test } from "node:test";
-import { buildSystemPrompt } from "../src/prompt/system-prompt.js";
+import { buildSystemPrompt } from "@minicode/agent-sdk";
 function createMinimalConfig(workspaceRoot) {
     return {
         modelProvider: "openai-compatible",