@pedrocivita/tocket 1.2.0 → 2.0.0

package/README.md

@@ -32,10 +32,13 @@ The CLI just automates the scaffolding.
 ## Quick Start
 
 ```bash
+# Interactive dashboard — guided entry point
+npx @pedrocivita/tocket
+
 # Scaffold a new workspace (creates .context/, TOCKET.md, CLAUDE.md, GEMINI.md)
 npx @pedrocivita/tocket init
 
-# Generate a payload XML for agent handoff
+# Generate a payload XML with smart git integration
 npx @pedrocivita/tocket generate
 
 # Sync session progress into Memory Bank
@@ -44,12 +47,31 @@ npx @pedrocivita/tocket sync
 
 ## Commands
 
-| Command           | What it does                                                   |
-| ----------------- | -------------------------------------------------------------- |
-| `tocket init`     | Scaffolds `.context/`, `TOCKET.md`, `CLAUDE.md`, `GEMINI.md`   |
-| `tocket generate` | Interactive payload XML builder — copies to clipboard          |
-| `tocket sync`     | Appends session summary + git log to `.context/progress.md`    |
-| `tocket validate` | Checks if the current directory has a valid Tocket Memory Bank |
+| Command           | What it does                                                         |
+| ----------------- | -------------------------------------------------------------------- |
+| `tocket`          | Interactive dashboard with guided menu                               |
+| `tocket init`     | Scaffolds `.context/`, `TOCKET.md`, `CLAUDE.md`, `GEMINI.md`         |
+| `tocket generate` | Smart payload builder — auto-fills scope from git, multi-task support |
+| `tocket sync`     | Appends session summary + git log to `.context/progress.md`          |
+| `tocket validate` | Checks if the current directory has a valid Tocket Memory Bank       |
+| `tocket config`   | Manage global settings (`~/.tocketrc.json`)                          |
+
+## Configuration
+
+Set global defaults so you don't repeat yourself:
+
+```bash
+# Interactive setup
+tocket config
+
+# Or use flags (CI-friendly)
+tocket config --author "Your Name" --priority medium --skills "core,lsp"
+
+# View current config
+tocket config --show
+```
+
+Config is stored at `~/.tocketrc.json` and pre-fills author, priority, and skills in all commands.
 
 ## How Triangulation works
 

package/dist/commands/config.cmd.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerConfigCommand(program: Command): void;

package/dist/commands/config.cmd.js

@@ -0,0 +1,102 @@
+import { input, select, confirm } from "@inquirer/prompts";
+import { getConfig, saveConfig, resetConfig, getConfigPath, } from "../utils/config.js";
+import { success, heading, dim } from "../utils/theme.js";
+export function registerConfigCommand(program) {
+    program
+        .command("config")
+        .description("Manage global Tocket configuration (~/.tocketrc.json)")
+        .option("--author <name>", "Set default author name")
+        .option("--agent <name>", "Set default agent name")
+        .option("--priority <level>", "Set default priority (high|medium|low)")
+        .option("--skills <list>", "Set default skills (comma-separated)")
+        .option("--show", "Display current configuration")
+        .option("--path", "Show config file path")
+        .option("--reset", "Reset configuration to defaults")
+        .action(async (options) => {
+        // --path: print and exit
+        if (options.path) {
+            console.log(getConfigPath());
+            return;
+        }
+        // --show: display current config
+        if (options.show) {
+            const config = await getConfig();
+            console.log(heading("\n  Current Configuration\n"));
+            console.log(JSON.stringify(config, null, 2)
+                .split("\n")
+                .map((l) => "  " + l)
+                .join("\n"));
+            console.log(dim(`\n  Path: ${getConfigPath()}\n`));
+            return;
+        }
+        // --reset: clear config
+        if (options.reset) {
+            const ok = await confirm({
+                message: "Reset all configuration to defaults?",
+                default: false,
+            });
+            if (ok) {
+                await resetConfig();
+                console.log(success("Configuration reset."));
+            }
+            return;
+        }
+        // Non-interactive: handle individual flags
+        const hasFlags = options.author || options.agent || options.priority || options.skills;
+        if (hasFlags) {
+            const config = await getConfig();
+            if (options.author)
+                config.author = options.author;
+            if (options.agent)
+                config.defaultAgent = options.agent;
+            if (options.priority) {
+                if (!config.defaults)
+                    config.defaults = {};
+                config.defaults.priority = options.priority;
+            }
+            if (options.skills) {
+                if (!config.defaults)
+                    config.defaults = {};
+                config.defaults.skills = options.skills;
+            }
+            await saveConfig(config);
+            console.log(success("Configuration updated."));
+            return;
+        }
+        // Interactive TUI mode
+        const current = await getConfig();
+        console.log(heading("\n  Tocket Configuration\n"));
+        const author = await input({
+            message: "Author name:",
+            default: current.author || undefined,
+        });
+        const agent = await input({
+            message: "Default agent name:",
+            default: current.defaultAgent || undefined,
+        });
+        const priority = await select({
+            message: "Default priority:",
+            choices: [
+                { value: "high", name: "high" },
+                { value: "medium", name: "medium" },
+                { value: "low", name: "low" },
+            ],
+            default: current.defaults?.priority ?? "medium",
+        });
+        const skills = await input({
+            message: "Default skills (comma-separated):",
+            default: current.defaults?.skills || undefined,
+        });
+        await saveConfig({
+            ...current,
+            author: author || undefined,
+            defaultAgent: agent || undefined,
+            defaults: {
+                priority: priority,
+                skills: skills || undefined,
+            },
+        });
+        console.log("\n" + success("Configuration saved."));
+        console.log(dim(`  Path: ${getConfigPath()}\n`));
+    });
+}

package/dist/commands/dashboard.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function showDashboard(program: Command): Promise<void>;

package/dist/commands/dashboard.js

@@ -0,0 +1,65 @@
+import { select } from "@inquirer/prompts";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { banner, heading, success, dim, warn } from "../utils/theme.js";
+import { getConfig } from "../utils/config.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;
+}
+export async function showDashboard(program) {
+    const config = await getConfig();
+    const cwd = process.cwd();
+    const hasWorkspace = existsSync(join(cwd, ".context"));
+    if (!config.theme?.disableBanner) {
+        console.log(banner());
+    }
+    console.log(heading("  Dashboard\n"));
+    if (hasWorkspace) {
+        console.log("  " + success("Workspace detected"));
+        try {
+            const ctx = await readFile(join(cwd, ".context", "activeContext.md"), "utf-8");
+            const focus = extractFocus(ctx);
+            if (focus) {
+                console.log("  " + dim(`Focus: ${focus}`));
+            }
+        }
+        catch {
+            // activeContext.md missing or unreadable — ignore
+        }
+    }
+    else {
+        console.log("  " + warn("No workspace in this directory"));
+        console.log("  " + dim("Run init to scaffold a Tocket workspace here.\n"));
+    }
+    console.log();
+    const choices = hasWorkspace
+        ? [
+            { value: "generate", name: "Generate payload" },
+            { value: "sync", name: "Sync progress" },
+            { value: "validate", name: "Validate workspace" },
+            { value: "config", name: "Configure settings" },
+            { value: "exit", name: "Exit" },
+        ]
+        : [
+            { value: "init", name: "Initialize workspace" },
+            { value: "config", name: "Configure settings" },
+            { value: "exit", name: "Exit" },
+        ];
+    const action = await select({
+        message: "What would you like to do?",
+        choices,
+    });
+    if (action === "exit") {
+        console.log(dim("\n  Goodbye!\n"));
+        return;
+    }
+    console.log();
+    await program.parseAsync(["node", "tocket", action]);
+}

package/dist/commands/generate.cmd.js

@@ -1,14 +1,26 @@
-import { input, select } from "@inquirer/prompts";
+import { input, select, confirm } from "@inquirer/prompts";
 import clipboard from "clipboardy";
-function buildPayloadXml(opts) {
-    const skillsAttr = opts.skills.trim()
-        ? `\n    <skills>${opts.skills.trim()}</skills>`
+import { success, heading, dim, banner } from "../utils/theme.js";
+import { getConfig } from "../utils/config.js";
+import { getStagedFiles, getModifiedFiles } from "../utils/git.js";
+function buildPayloadXml(tasks) {
+    const first = tasks[0];
+    const skillsAttr = first.skills.trim()
+        ? `\n    <skills>${first.skills.trim()}</skills>`
         : "";
+    const taskBlocks = tasks
+        .map((t, i) => `    <task id="${i + 1}" type="create | edit | delete">
+      <target><!-- file/path --></target>
+      <action>${t.intent}</action>
+      <spec><!-- Detailed specification --></spec>
+      <done><!-- Definition of done --></done>
+    </task>`)
+        .join("\n");
     return `<payload version="2.0">
   <meta>
-    <intent>${opts.intent}</intent>
-    <scope>${opts.scope}</scope>${skillsAttr}
-    <priority>${opts.priority}</priority>
+    <intent>${first.intent}</intent>
+    <scope>${first.scope}</scope>${skillsAttr}
+    <priority>${first.priority}</priority>
   </meta>
 
   <context>
@@ -16,12 +28,7 @@ function buildPayloadXml(opts) {
   </context>
 
   <tasks>
-    <task id="1" type="create | edit | delete">
-      <target><!-- file/path --></target>
-      <action><!-- What to do --></action>
-      <spec><!-- Detailed specification --></spec>
-      <done><!-- Definition of done --></done>
-    </task>
+${taskBlocks}
   </tasks>
 
   <validate>
@@ -29,26 +36,71 @@ function buildPayloadXml(opts) {
   </validate>
 </payload>`;
 }
+function suggestScope() {
+    const staged = getStagedFiles();
+    const modified = getModifiedFiles();
+    const all = [...new Set([...staged, ...modified])];
+    return all.join(", ");
+}
 export function registerGenerateCommand(program) {
     program
         .command("generate")
         .description("Build payload XMLs interactively for Architect-Executor handoff")
-        .action(async () => {
-        const intent = await input({ message: "Intent (goal in one line):" });
-        const scope = await input({ message: "Scope (files/folders affected):" });
-        const priority = await select({
-            message: "Priority:",
-            choices: [
-                { value: "high", name: "high" },
-                { value: "medium", name: "medium" },
-                { value: "low", name: "low" },
-            ],
-        });
-        const skills = await input({
-            message: "Skills/plugins (comma-separated, optional):",
-        });
-        const xml = buildPayloadXml({ intent, scope, priority, skills });
+        .option("--no-preview", "Skip payload preview before copying")
+        .action(async (options) => {
+        const config = await getConfig();
+        if (!config.theme?.disableBanner) {
+            console.log(banner());
+        }
+        const tasks = [];
+        const suggestedScope = suggestScope();
+        const defaultPriority = config.defaults?.priority ?? "medium";
+        const defaultSkills = config.defaults?.skills ?? "";
+        let addMore = true;
+        while (addMore) {
+            const taskNum = tasks.length + 1;
+            if (taskNum > 1) {
+                console.log(heading(`\n  Task ${taskNum}\n`));
+            }
+            const intent = await input({ message: "Intent (goal in one line):" });
+            const scope = await input({
+                message: "Scope (files/folders affected):",
+                default: taskNum === 1 && suggestedScope ? suggestedScope : undefined,
+            });
+            const priority = await select({
+                message: "Priority:",
+                choices: [
+                    { value: "high", name: "high" },
+                    { value: "medium", name: "medium" },
+                    { value: "low", name: "low" },
+                ],
+                default: defaultPriority,
+            });
+            const skills = await input({
+                message: "Skills/plugins (comma-separated, optional):",
+                default: taskNum === 1 && defaultSkills ? defaultSkills : undefined,
+            });
+            tasks.push({ intent, scope, priority, skills });
+            addMore = await confirm({
+                message: "Add another task?",
+                default: false,
+            });
+        }
+        const xml = buildPayloadXml(tasks);
+        // Preview
+        if (options.preview !== false) {
+            console.log(dim("\n--- Payload Preview ---"));
+            const lines = xml.split("\n");
+            const preview = lines.length > 20
+                ? lines.slice(0, 20).join("\n") + dim("\n  ... (" + (lines.length - 20) + " more lines)")
+                : lines.join("\n");
+            console.log(dim(preview));
+            console.log(dim("--- End Preview ---\n"));
+        }
         clipboard.writeSync(xml);
-        console.log("\n\x1b[32m\u2713\x1b[0m Payload XML (v2.0) copied to clipboard! Paste it into your Architect to continue.");
+        console.log(success(`Payload XML (v2.0) copied to clipboard!`) +
+            dim(` ${tasks.length} task(s).`) +
+            "\n" +
+            dim("  Paste it into your Architect to continue.\n"));
     });
 }

package/dist/commands/init.cmd.js

@@ -1,6 +1,8 @@
-import { input } from "@inquirer/prompts";
+import { input, confirm } from "@inquirer/prompts";
 import { mkdir, readFile, writeFile, access } from "node:fs/promises";
 import { join } from "node:path";
+import { banner, heading, info, success, dim } from "../utils/theme.js";
+import { getConfig } from "../utils/config.js";
 import { claudeMd, geminiMd, tocketMd, activeContextMd, systemPatternsMd, productContextMd, techContextMd, progressMd, cursorrulesMd, } from "../templates/memory-bank.js";
 async function fileExists(path) {
     try {
@@ -116,22 +118,28 @@ export function registerInitCommand(program) {
     program
         .command("init")
         .description("Scaffold an agentic workspace with Memory Bank and triangulation config")
-        .action(async () => {
+        .option("-f, --force", "Overwrite existing files without prompting")
+        .action(async (options) => {
+        const force = options.force ?? false;
         const cwd = process.cwd();
+        const globalConfig = await getConfig();
+        if (!globalConfig.theme?.disableBanner) {
+            console.log(banner());
+        }
         const { stack, detectedName, detectedDescription } = await detectStack(cwd);
         const hasDetection = Boolean(stack.language);
         if (hasDetection) {
-            console.log("\n  Auto-detected stack from package.json:");
+            console.log(heading("  Auto-detected stack:\n"));
             if (stack.language)
-                console.log(`    Language:  ${stack.language}`);
+                console.log(info(`Language:  ${stack.language}`));
             if (stack.runtime)
-                console.log(`    Runtime:   ${stack.runtime}`);
+                console.log(info(`Runtime:   ${stack.runtime}`));
             if (stack.build)
-                console.log(`    Build:     ${stack.build}`);
+                console.log(info(`Build:     ${stack.build}`));
             if (stack.framework)
-                console.log(`    Framework: ${stack.framework}`);
+                console.log(info(`Framework: ${stack.framework}`));
             if (stack.extras.length)
-                console.log(`    Extras:    ${stack.extras.join(", ")}`);
+                console.log(info(`Extras:    ${stack.extras.join(", ")}`));
             console.log();
         }
         const projectName = await input({
@@ -163,9 +171,22 @@ export function registerInitCommand(program) {
         ];
         for (const [filePath, content] of files) {
             const fullPath = join(cwd, filePath);
+            const exists = await fileExists(fullPath);
+            if (exists && !force) {
+                const overwrite = await confirm({
+                    message: `${filePath} already exists. Overwrite?`,
+                    default: false,
+                });
+                if (!overwrite) {
+                    console.log("  " + dim(`skipped ${filePath}`));
+                    continue;
+                }
+            }
             await writeFile(fullPath, content, "utf-8");
-            console.log(`  created ${filePath}`);
+            console.log("  " + success(`${exists ? "updated" : "created"} ${filePath}`));
         }
-        console.log(`\nAgentic workspace initialized for ${projectName}!${hasDetection ? " Stack pre-populated from package.json." : ""} Ready to launch.`);
+        console.log("\n" + success(`Workspace initialized for ${projectName}!`) +
+            (hasDetection ? dim(" Stack pre-populated from package.json.") : "") +
+            "\n" + dim("  Next: run tocket generate to create your first payload.\n"));
     });
 }

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,29 @@
 #!/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";
+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);
+// 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/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/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"));
+    });
+});

package/dist/utils/config.d.ts

@@ -0,0 +1,16 @@
+export interface TocketConfig {
+    author?: string;
+    defaultAgent?: string;
+    defaults?: {
+        priority?: "high" | "medium" | "low";
+        skills?: string;
+    };
+    theme?: {
+        disableBanner?: boolean;
+    };
+}
+export declare function getConfigPath(): string;
+export declare function getConfig(configPath?: string): Promise<TocketConfig>;
+export declare function saveConfig(config: TocketConfig, configPath?: string): Promise<void>;
+export declare function updateConfig(partial: Partial<TocketConfig>, configPath?: string): Promise<void>;
+export declare function resetConfig(configPath?: string): Promise<void>;

package/dist/utils/config.js

@@ -0,0 +1,33 @@
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+export function getConfigPath() {
+    return join(homedir(), ".tocketrc.json");
+}
+export async function getConfig(configPath) {
+    const path = configPath ?? getConfigPath();
+    try {
+        const content = await readFile(path, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveConfig(config, configPath) {
+    const path = configPath ?? getConfigPath();
+    await writeFile(path, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+export async function updateConfig(partial, configPath) {
+    const current = await getConfig(configPath);
+    const merged = {
+        ...current,
+        ...partial,
+        defaults: { ...current.defaults, ...partial.defaults },
+        theme: { ...current.theme, ...partial.theme },
+    };
+    await saveConfig(merged, configPath);
+}
+export async function resetConfig(configPath) {
+    await saveConfig({}, configPath);
+}

package/dist/utils/git.d.ts

@@ -0,0 +1,6 @@
+export declare function isGitRepo(cwd?: string): boolean;
+export declare function getStagedFiles(cwd?: string): string[];
+export declare function getModifiedFiles(cwd?: string): string[];
+export declare function getRecentCommits(n?: number, cwd?: string): string[];
+export declare function getRecentCommitsRaw(n?: number, cwd?: string): string;
+export declare function getCurrentBranch(cwd?: string): string;

package/dist/utils/git.js

@@ -0,0 +1,79 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+export function isGitRepo(cwd = process.cwd()) {
+    return existsSync(join(cwd, ".git"));
+}
+export function getStagedFiles(cwd = process.cwd()) {
+    if (!isGitRepo(cwd))
+        return [];
+    try {
+        const output = execSync("git diff --name-only --cached", {
+            cwd,
+            encoding: "utf-8",
+        }).trim();
+        return output ? output.split("\n") : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function getModifiedFiles(cwd = process.cwd()) {
+    if (!isGitRepo(cwd))
+        return [];
+    try {
+        const output = execSync("git status --porcelain", {
+            cwd,
+            encoding: "utf-8",
+        }).trim();
+        if (!output)
+            return [];
+        return output
+            .split("\n")
+            .filter((line) => line.length > 3)
+            .map((line) => line.substring(3).trim());
+    }
+    catch {
+        return [];
+    }
+}
+export function getRecentCommits(n = 5, cwd = process.cwd()) {
+    if (!isGitRepo(cwd))
+        return [];
+    try {
+        const output = execSync(`git log --oneline -${n}`, {
+            cwd,
+            encoding: "utf-8",
+        }).trim();
+        return output ? output.split("\n") : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function getRecentCommitsRaw(n = 5, cwd = process.cwd()) {
+    if (!isGitRepo(cwd))
+        return "_No commits found or not a git repository._";
+    try {
+        return execSync(`git log --oneline -${n}`, {
+            cwd,
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return "_No commits found or not a git repository._";
+    }
+}
+export function getCurrentBranch(cwd = process.cwd()) {
+    if (!isGitRepo(cwd))
+        return "";
+    try {
+        return execSync("git branch --show-current", {
+            cwd,
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}

package/dist/utils/theme.d.ts

@@ -0,0 +1,13 @@
+export declare const purple: import("chalk").ChalkInstance;
+export declare const green: import("chalk").ChalkInstance;
+export declare const red: import("chalk").ChalkInstance;
+export declare const yellow: import("chalk").ChalkInstance;
+export declare const dimmed: import("chalk").ChalkInstance;
+export declare const bold: import("chalk").ChalkInstance;
+export declare function banner(): string;
+export declare function success(msg: string): string;
+export declare function error(msg: string): string;
+export declare function warn(msg: string): string;
+export declare function info(msg: string): string;
+export declare function heading(msg: string): string;
+export declare function dim(msg: string): string;

package/dist/utils/theme.js

@@ -0,0 +1,38 @@
+import chalk from "chalk";
+// ── Brand colors ──────────────────────────────────────────────────────
+export const purple = chalk.hex("#7C3AED");
+export const green = chalk.green;
+export const red = chalk.red;
+export const yellow = chalk.yellow;
+export const dimmed = chalk.dim;
+export const bold = chalk.bold;
+// ── ASCII banner ──────────────────────────────────────────────────────
+export function banner() {
+    const art = `
+  ████████╗ ██████╗  ██████╗██╗  ██╗███████╗████████╗
+  ╚══██╔══╝██╔═══██╗██╔════╝██║ ██╔╝██╔════╝╚══██╔══╝
+     ██║   ██║   ██║██║     █████╔╝ █████╗     ██║
+     ██║   ██║   ██║██║     ██╔═██╗ ██╔══╝     ██║
+     ██║   ╚██████╔╝╚██████╗██║  ██╗███████╗   ██║
+     ╚═╝    ╚═════╝  ╚═════╝╚═╝  ╚═╝╚══════╝   ╚═╝`;
+    return purple(art) + "\n" + dimmed("  Context Engineering Framework\n");
+}
+// ── Semantic helpers ──────────────────────────────────────────────────
+export function success(msg) {
+    return `${green("\u2713")} ${msg}`;
+}
+export function error(msg) {
+    return `${red("\u2717")} ${msg}`;
+}
+export function warn(msg) {
+    return `${yellow("\u26A0")} ${msg}`;
+}
+export function info(msg) {
+    return `${purple("\u203A")} ${msg}`;
+}
+export function heading(msg) {
+    return bold(purple(msg));
+}
+export function dim(msg) {
+    return dimmed(msg);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrocivita/tocket",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "The Context Engineering Framework for Multi-Agent Workspaces",
   "type": "module",
   "main": "dist/index.js",
@@ -37,6 +37,7 @@
   },
   "dependencies": {
     "@inquirer/prompts": "^8.3.0",
+    "chalk": "^5.6.2",
     "clipboardy": "^5.3.0",
     "commander": "^14.0.3"
   },