@pedrocivita/tocket 1.2.0 → 2.1.0

package/dist/commands/status.cmd.js

@@ -0,0 +1,85 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { success, warn, info, dim, heading } from "../utils/theme.js";
+import { getCurrentBranch, isGitRepo } from "../utils/git.js";
+function extractFocus(content) {
+    const match = content.match(/## Current Focus\s*\n+(.+)/);
+    if (!match?.[1])
+        return "";
+    const line = match[1].trim();
+    if (line.startsWith("_") || line.includes("No active tasks"))
+        return "";
+    return line.length > 80 ? line.substring(0, 77) + "..." : line;
+}
+function daysSince(filePath) {
+    const stats = statSync(filePath);
+    return Math.floor((Date.now() - stats.mtimeMs) / (1000 * 60 * 60 * 24));
+}
+function countContextFiles(contextDir) {
+    const expected = [
+        "activeContext.md",
+        "systemPatterns.md",
+        "productContext.md",
+        "techContext.md",
+        "progress.md",
+    ];
+    return expected.filter((f) => existsSync(join(contextDir, f))).length;
+}
+export function registerStatusCommand(program) {
+    program
+        .command("status")
+        .description("Show a quick overview of the current workspace")
+        .action(() => {
+        const cwd = process.cwd();
+        const contextDir = join(cwd, ".context");
+        const hasWorkspace = existsSync(contextDir);
+        console.log(heading("\n  Tocket Status\n"));
+        // Workspace
+        if (!hasWorkspace) {
+            console.log("  " + warn("No Tocket workspace in this directory."));
+            console.log("  " + dim("Run 'tocket init' to get started.\n"));
+            return;
+        }
+        const fileCount = countContextFiles(contextDir);
+        console.log("  " + success(`Workspace: ${fileCount}/5 context files`));
+        // Focus
+        const activeContextPath = join(contextDir, "activeContext.md");
+        if (existsSync(activeContextPath)) {
+            const content = readFileSync(activeContextPath, "utf-8");
+            const focus = extractFocus(content);
+            if (focus) {
+                console.log("  " + info(`Focus: ${focus}`));
+            }
+            else {
+                console.log("  " + dim("  Focus: (none set)"));
+            }
+            const days = daysSince(activeContextPath);
+            if (days > 7) {
+                console.log("  " + warn(`Context last updated ${days} days ago`));
+            }
+        }
+        // Git
+        if (isGitRepo(cwd)) {
+            const branch = getCurrentBranch(cwd);
+            if (branch) {
+                console.log("  " + info(`Branch: ${branch}`));
+            }
+        }
+        // Agent configs
+        const agents = ["CLAUDE.md", "GEMINI.md", ".cursorrules"].filter((f) => existsSync(join(cwd, f)));
+        if (agents.length > 0) {
+            console.log("  " + info(`Agents: ${agents.join(", ")}`));
+        }
+        // Last sync
+        const progressPath = join(contextDir, "progress.md");
+        if (existsSync(progressPath)) {
+            const progressContent = readFileSync(progressPath, "utf-8");
+            const sessionMatch = progressContent.match(/## Session: (\d{4}-\d{2}-\d{2})/g);
+            if (sessionMatch && sessionMatch.length > 0) {
+                const lastSession = sessionMatch[sessionMatch.length - 1].replace("## Session: ", "");
+                console.log("  " + dim(`  Last sync: ${lastSession}`));
+            }
+        }
+        console.log();
+    });
+}

package/dist/commands/sync.cmd.js

@@ -1,16 +1,10 @@
 import { input } from "@inquirer/prompts";
 import { existsSync } from "node:fs";
 import { appendFile, writeFile } from "node:fs/promises";
-import { execSync } from "node:child_process";
 import { join } from "node:path";
-function getRecentCommits() {
-    try {
-        return execSync("git log --oneline -5", { encoding: "utf-8" }).trim();
-    }
-    catch {
-        return "_No commits found or not a git repository._";
-    }
-}
+import { success, error as themeError } from "../utils/theme.js";
+import { getRecentCommitsRaw } from "../utils/git.js";
+import { getConfig } from "../utils/config.js";
 export function registerSyncCommand(program) {
     program
         .command("sync")
@@ -19,16 +13,18 @@ export function registerSyncCommand(program) {
         const progressPath = join(process.cwd(), ".context", "progress.md");
         const contextDir = join(process.cwd(), ".context");
         if (!existsSync(contextDir)) {
-            console.error("\x1b[31mMemory Bank not found. Run 'tocket init' first.\x1b[0m");
+            console.error(themeError("Memory Bank not found. Run 'tocket init' first."));
             process.exitCode = 1;
             return;
         }
+        const config = await getConfig();
         const summary = await input({
             message: "What did you accomplish in this session?",
         });
-        const commits = getRecentCommits();
+        const commits = getRecentCommitsRaw();
         const date = new Date().toISOString().split("T")[0];
-        const block = `## Session: ${date}
+        const authorTag = config.author ? ` (${config.author})` : "";
+        const block = `## Session: ${date}${authorTag}
 
 **Summary**: ${summary}
 
@@ -46,6 +42,6 @@ ${commits}
         else {
             await appendFile(progressPath, block, "utf-8");
         }
-        console.log("\n\x1b[32m✓\x1b[0m Memory Bank synchronized successfully!");
+        console.log("\n" + success("Memory Bank synchronized!"));
     });
 }

package/dist/commands/validate.cmd.js

@@ -1,8 +1,9 @@
 import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
-const PASS = "\x1b[32m\u2713\x1b[0m";
-const WARN = "\x1b[33m\u26A0\x1b[0m";
-const FAIL = "\x1b[31m\u2717\x1b[0m";
+import { success as themePass, warn as themeWarn, error as themeFail, heading } from "../utils/theme.js";
+const PASS = themePass("");
+const WARN = themeWarn("");
+const FAIL = themeFail("");
 function checkFile(basePath, relativePath, required) {
     const fullPath = join(basePath, relativePath);
     if (existsSync(fullPath)) {
@@ -55,7 +56,7 @@ export function registerValidateCommand(program) {
         const cwd = process.cwd();
         const results = [];
         let hasFailure = false;
-        console.log("\nValidating Tocket workspace...\n");
+        console.log(heading("\nValidating Tocket workspace...\n"));
         // Required files
         results.push(checkFile(cwd, join(".context"), true));
         results.push(checkFile(cwd, join(".context", "activeContext.md"), true));
@@ -80,11 +81,11 @@ export function registerValidateCommand(program) {
         }
         console.log("");
         if (hasFailure) {
-            console.log("\x1b[31mWorkspace has issues.\x1b[0m Run \x1b[1mtocket init\x1b[0m to scaffold missing files.");
+            console.log(themeFail("Workspace has issues.") + " Run tocket init to scaffold missing files.");
             process.exitCode = 1;
         }
         else {
-            console.log("\x1b[32mWorkspace is healthy.\x1b[0m");
+            console.log(themePass("Workspace is healthy."));
         }
     });
 }

package/dist/index.js

@@ -1,16 +1,35 @@
 #!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
 import { Command } from "commander";
 import { registerInitCommand } from "./commands/init.cmd.js";
 import { registerGenerateCommand } from "./commands/generate.cmd.js";
 import { registerSyncCommand } from "./commands/sync.cmd.js";
 import { registerValidateCommand } from "./commands/validate.cmd.js";
+import { registerConfigCommand } from "./commands/config.cmd.js";
+import { registerEjectCommand } from "./commands/eject.cmd.js";
+import { registerFocusCommand } from "./commands/focus.cmd.js";
+import { registerStatusCommand } from "./commands/status.cmd.js";
+const pkg = JSON.parse(readFileSync(join(import.meta.dirname, "..", "package.json"), "utf-8"));
 const program = new Command();
 program
     .name("tocket")
     .description("The Context Engineering Framework for Multi-Agent Workspaces")
-    .version("1.2.0");
+    .version(pkg.version);
 registerInitCommand(program);
 registerGenerateCommand(program);
 registerSyncCommand(program);
 registerValidateCommand(program);
-program.parse();
+registerConfigCommand(program);
+registerEjectCommand(program);
+registerFocusCommand(program);
+registerStatusCommand(program);
+// No-args: show interactive dashboard (TTY) or help (non-TTY)
+const args = process.argv.slice(2);
+if (args.length === 0 && process.stdin.isTTY) {
+    const { showDashboard } = await import("./commands/dashboard.js");
+    await showDashboard(program);
+}
+else {
+    program.parse();
+}

package/dist/tests/config.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/config.test.js

@@ -0,0 +1,68 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { getConfig, saveConfig, updateConfig, resetConfig, } from "../utils/config.js";
+describe("config - read and write", () => {
+    let tempDir;
+    let configPath;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-config-test-"));
+        configPath = join(tempDir, ".tocketrc.json");
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("getConfig returns empty object when file does not exist", async () => {
+        const config = await getConfig(configPath);
+        assert.deepEqual(config, {});
+    });
+    it("saveConfig writes a valid config", async () => {
+        const data = { author: "Test User" };
+        await saveConfig(data, configPath);
+        const config = await getConfig(configPath);
+        assert.equal(config.author, "Test User");
+    });
+    it("saveConfig preserves all fields", async () => {
+        const data = {
+            author: "Alice",
+            defaultAgent: "Claude",
+            defaults: { priority: "high", skills: "core,lsp" },
+            theme: { disableBanner: true },
+        };
+        await saveConfig(data, configPath);
+        const config = await getConfig(configPath);
+        assert.equal(config.author, "Alice");
+        assert.equal(config.defaultAgent, "Claude");
+        assert.equal(config.defaults?.priority, "high");
+        assert.equal(config.defaults?.skills, "core,lsp");
+        assert.equal(config.theme?.disableBanner, true);
+    });
+    it("updateConfig merges without overwriting", async () => {
+        await saveConfig({ author: "Bob", defaultAgent: "Gemini" }, configPath);
+        await updateConfig({ author: "Charlie" }, configPath);
+        const config = await getConfig(configPath);
+        assert.equal(config.author, "Charlie");
+        assert.equal(config.defaultAgent, "Gemini");
+    });
+    it("updateConfig merges nested defaults", async () => {
+        await saveConfig({ defaults: { priority: "low", skills: "a,b" } }, configPath);
+        await updateConfig({ defaults: { priority: "high" } }, configPath);
+        const config = await getConfig(configPath);
+        assert.equal(config.defaults?.priority, "high");
+        assert.equal(config.defaults?.skills, "a,b");
+    });
+    it("resetConfig clears all data", async () => {
+        await saveConfig({ author: "Remove Me" }, configPath);
+        await resetConfig(configPath);
+        const config = await getConfig(configPath);
+        assert.deepEqual(config, {});
+    });
+});
+describe("config - error handling", () => {
+    it("getConfig returns empty object for non-existent path", async () => {
+        const config = await getConfig("/nonexistent/path/.tocketrc.json");
+        assert.deepEqual(config, {});
+    });
+});

package/dist/tests/eject.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/eject.test.js

@@ -0,0 +1,88 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, } from "node:fs";
+import { rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { EJECT_FILES, EJECT_DIRS } from "../commands/eject.cmd.js";
+describe("eject - constants", () => {
+    it("EJECT_FILES contains all expected files", () => {
+        assert.ok(EJECT_FILES.includes("TOCKET.md"));
+        assert.ok(EJECT_FILES.includes("CLAUDE.md"));
+        assert.ok(EJECT_FILES.includes("GEMINI.md"));
+        assert.ok(EJECT_FILES.includes(".cursorrules"));
+    });
+    it("EJECT_DIRS contains .context", () => {
+        assert.ok(EJECT_DIRS.includes(".context"));
+    });
+});
+describe("eject - removal logic", () => {
+    let tempDir;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-eject-test-"));
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("removes .context directory recursively", async () => {
+        const contextDir = join(tempDir, ".context");
+        mkdirSync(contextDir, { recursive: true });
+        writeFileSync(join(contextDir, "activeContext.md"), "test", "utf-8");
+        writeFileSync(join(contextDir, "systemPatterns.md"), "test", "utf-8");
+        assert.ok(existsSync(contextDir));
+        await rm(contextDir, { recursive: true, force: true });
+        assert.ok(!existsSync(contextDir));
+    });
+    it("removes individual eject files", async () => {
+        for (const file of EJECT_FILES) {
+            const fullPath = join(tempDir, file);
+            writeFileSync(fullPath, "test content", "utf-8");
+            assert.ok(existsSync(fullPath));
+            await rm(fullPath, { force: true });
+            assert.ok(!existsSync(fullPath));
+        }
+    });
+    it("does not error when files are already missing", async () => {
+        for (const file of EJECT_FILES) {
+            const fullPath = join(tempDir, file);
+            assert.ok(!existsSync(fullPath));
+            await rm(fullPath, { force: true });
+        }
+    });
+    it("does not error when .context is already missing", async () => {
+        const contextDir = join(tempDir, ".context");
+        assert.ok(!existsSync(contextDir));
+        await rm(contextDir, { recursive: true, force: true });
+    });
+});
+describe("eject - partial workspace", () => {
+    let tempDir;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-eject-partial-"));
+        mkdirSync(join(tempDir, ".context"), { recursive: true });
+        writeFileSync(join(tempDir, ".context", "activeContext.md"), "data", "utf-8");
+        writeFileSync(join(tempDir, "TOCKET.md"), "data", "utf-8");
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("removes existing files and skips missing ones", async () => {
+        assert.ok(existsSync(join(tempDir, ".context")));
+        assert.ok(existsSync(join(tempDir, "TOCKET.md")));
+        assert.ok(!existsSync(join(tempDir, "CLAUDE.md")));
+        for (const dir of EJECT_DIRS) {
+            const fullPath = join(tempDir, dir);
+            if (existsSync(fullPath)) {
+                await rm(fullPath, { recursive: true, force: true });
+            }
+        }
+        for (const file of EJECT_FILES) {
+            const fullPath = join(tempDir, file);
+            if (existsSync(fullPath)) {
+                await rm(fullPath, { force: true });
+            }
+        }
+        assert.ok(!existsSync(join(tempDir, ".context")));
+        assert.ok(!existsSync(join(tempDir, "TOCKET.md")));
+    });
+});

package/dist/tests/focus.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/focus.test.js

@@ -0,0 +1,130 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { replaceFocusSection } from "../commands/focus.cmd.js";
+describe("replaceFocusSection", () => {
+    it("replaces single-line focus content", () => {
+        const input = `# Active Context
+
+## Current Focus
+
+Old focus text here.
+
+## Recent Changes
+
+Some changes.
+`;
+        const result = replaceFocusSection(input, "New focus message");
+        assert.ok(result.includes("New focus message"));
+        assert.ok(!result.includes("Old focus text here"));
+        assert.ok(result.includes("## Recent Changes"));
+    });
+    it("replaces multi-line focus content", () => {
+        const input = `# Active Context
+
+## Current Focus
+
+**v2.0.0 — UX Overhaul.** Added purple theme, dashboard,
+config command, smart generate, and 29 new tests.
+All decisions resolved.
+
+## Recent Changes
+
+| Date | Change |
+`;
+        const result = replaceFocusSection(input, "Working on v2.1.0 features");
+        assert.ok(result.includes("Working on v2.1.0 features"));
+        assert.ok(!result.includes("v2.0.0"));
+        assert.ok(result.includes("## Recent Changes"));
+    });
+    it("preserves sections before and after Current Focus", () => {
+        const input = `# Active Context
+
+<!-- comment -->
+
+## Current Focus
+
+Old stuff.
+
+## Recent Changes
+
+Data here.
+
+## Open Decisions
+
+Decisions here.
+`;
+        const result = replaceFocusSection(input, "Brand new focus");
+        assert.ok(result.includes("# Active Context"));
+        assert.ok(result.includes("<!-- comment -->"));
+        assert.ok(result.includes("## Recent Changes"));
+        assert.ok(result.includes("Data here."));
+        assert.ok(result.includes("## Open Decisions"));
+        assert.ok(result.includes("Decisions here."));
+    });
+    it("appends section when ## Current Focus is missing", () => {
+        const input = `# Active Context
+
+## Recent Changes
+
+Some data.
+`;
+        const result = replaceFocusSection(input, "New focus");
+        assert.ok(result.includes("## Current Focus"));
+        assert.ok(result.includes("New focus"));
+        assert.ok(result.includes("## Recent Changes"));
+    });
+    it("handles Current Focus at end of file (no following section)", () => {
+        const input = `# Active Context
+
+## Current Focus
+
+Last section, nothing after this.
+`;
+        const result = replaceFocusSection(input, "Updated final section");
+        assert.ok(result.includes("Updated final section"));
+        assert.ok(!result.includes("Last section"));
+    });
+    it("handles empty content between heading and next section", () => {
+        const input = `## Current Focus
+
+## Recent Changes
+`;
+        const result = replaceFocusSection(input, "Fill the gap");
+        assert.ok(result.includes("Fill the gap"));
+        assert.ok(result.includes("## Recent Changes"));
+    });
+});
+describe("focus - file integration", () => {
+    let tempDir;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-focus-test-"));
+        mkdirSync(join(tempDir, ".context"), { recursive: true });
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("correctly round-trips through file read/write", () => {
+        const filePath = join(tempDir, ".context", "activeContext.md");
+        const original = `# Active Context - Test
+
+## Current Focus
+
+Old focus.
+
+## Recent Changes
+
+Nothing yet.
+`;
+        writeFileSync(filePath, original, "utf-8");
+        const content = readFileSync(filePath, "utf-8");
+        const updated = replaceFocusSection(content, "Round-tripped focus");
+        writeFileSync(filePath, updated, "utf-8");
+        const final = readFileSync(filePath, "utf-8");
+        assert.ok(final.includes("Round-tripped focus"));
+        assert.ok(!final.includes("Old focus"));
+        assert.ok(final.includes("## Recent Changes"));
+    });
+});

package/dist/tests/git.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/git.test.js

@@ -0,0 +1,61 @@
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { isGitRepo, getStagedFiles, getModifiedFiles, getRecentCommits, getRecentCommitsRaw, getCurrentBranch, } from "../utils/git.js";
+// Use the Tocket repo itself for "in git" tests
+const tocketRoot = join(import.meta.dirname, "..", "..");
+describe("git - in a git repository", () => {
+    it("isGitRepo returns true", () => {
+        assert.equal(isGitRepo(tocketRoot), true);
+    });
+    it("getRecentCommits returns an array with items", () => {
+        const commits = getRecentCommits(3, tocketRoot);
+        assert.ok(Array.isArray(commits));
+        assert.ok(commits.length > 0);
+    });
+    it("getRecentCommitsRaw returns a non-empty string", () => {
+        const raw = getRecentCommitsRaw(3, tocketRoot);
+        assert.ok(raw.length > 0);
+        assert.ok(!raw.includes("No commits found"));
+    });
+    it("getCurrentBranch returns a non-empty string", () => {
+        const branch = getCurrentBranch(tocketRoot);
+        assert.ok(typeof branch === "string");
+        assert.ok(branch.length > 0);
+    });
+    it("getStagedFiles returns an array", () => {
+        const files = getStagedFiles(tocketRoot);
+        assert.ok(Array.isArray(files));
+    });
+    it("getModifiedFiles returns an array", () => {
+        const files = getModifiedFiles(tocketRoot);
+        assert.ok(Array.isArray(files));
+    });
+});
+describe("git - in a non-git directory", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-git-test-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("isGitRepo returns false", () => {
+        assert.equal(isGitRepo(tempDir), false);
+    });
+    it("getStagedFiles returns empty array", () => {
+        assert.deepEqual(getStagedFiles(tempDir), []);
+    });
+    it("getModifiedFiles returns empty array", () => {
+        assert.deepEqual(getModifiedFiles(tempDir), []);
+    });
+    it("getRecentCommits returns empty array", () => {
+        assert.deepEqual(getRecentCommits(5, tempDir), []);
+    });
+    it("getRecentCommitsRaw returns fallback message", () => {
+        const raw = getRecentCommitsRaw(5, tempDir);
+        assert.ok(raw.includes("No commits found"));
+    });
+    it("getCurrentBranch returns empty string", () => {
+        assert.equal(getCurrentBranch(tempDir), "");
+    });
+});

package/dist/tests/status.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/status.test.js

@@ -0,0 +1,34 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync, existsSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+describe("status - workspace detection", () => {
+    let tempDir;
+    before(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "tocket-status-test-"));
+    });
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("detects absence of .context directory", () => {
+        const contextDir = join(tempDir, ".context");
+        assert.ok(!existsSync(contextDir));
+    });
+    it("detects presence of .context directory with files", () => {
+        const contextDir = join(tempDir, ".context");
+        mkdirSync(contextDir, { recursive: true });
+        writeFileSync(join(contextDir, "activeContext.md"), "# Active Context\n\n## Current Focus\n\nTesting status command.\n", "utf-8");
+        writeFileSync(join(contextDir, "systemPatterns.md"), "test", "utf-8");
+        writeFileSync(join(contextDir, "progress.md"), "# Progress\n\n## Session: 2026-02-25\n\n**Summary**: test\n", "utf-8");
+        assert.ok(existsSync(contextDir));
+        assert.ok(existsSync(join(contextDir, "activeContext.md")));
+    });
+    it("counts context files correctly", () => {
+        const contextDir = join(tempDir, ".context");
+        const expected = ["activeContext.md", "systemPatterns.md", "productContext.md", "techContext.md", "progress.md"];
+        const count = expected.filter((f) => existsSync(join(contextDir, f))).length;
+        // We created 3 files above
+        assert.equal(count, 3);
+    });
+});

package/dist/tests/theme.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/theme.test.js

@@ -0,0 +1,58 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { success, error, warn, info, heading, dim, banner } from "../utils/theme.js";
+describe("theme - success", () => {
+    it("returns a string containing the message", () => {
+        const result = success("done");
+        assert.ok(result.includes("done"));
+    });
+    it("contains a checkmark character", () => {
+        const result = success("ok");
+        assert.ok(result.includes("\u2713"));
+    });
+});
+describe("theme - error", () => {
+    it("returns a string containing the message", () => {
+        const result = error("fail");
+        assert.ok(result.includes("fail"));
+    });
+    it("contains an X character", () => {
+        const result = error("bad");
+        assert.ok(result.includes("\u2717"));
+    });
+});
+describe("theme - warn", () => {
+    it("returns a string containing the message", () => {
+        const result = warn("caution");
+        assert.ok(result.includes("caution"));
+    });
+});
+describe("theme - info", () => {
+    it("returns a string containing the message", () => {
+        const result = info("notice");
+        assert.ok(result.includes("notice"));
+    });
+});
+describe("theme - heading", () => {
+    it("returns a non-empty string", () => {
+        const result = heading("Title");
+        assert.ok(result.length > 0);
+        assert.ok(result.includes("Title"));
+    });
+});
+describe("theme - dim", () => {
+    it("returns a string containing the message", () => {
+        const result = dim("faded");
+        assert.ok(result.includes("faded"));
+    });
+});
+describe("theme - banner", () => {
+    it("returns a long string", () => {
+        const result = banner();
+        assert.ok(result.length > 100);
+    });
+    it("contains framework tagline", () => {
+        const result = banner();
+        assert.ok(result.includes("Context Engineering Framework"));
+    });
+});