@pedrocivita/tocket 1.1.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,31 +1,192 @@
-import { input } from "@inquirer/prompts";
-import { mkdir, writeFile } from "node:fs/promises";
+import { input, confirm } from "@inquirer/prompts";
+import { mkdir, readFile, writeFile, access } from "node:fs/promises";
 import { join } from "node:path";
-import { claudeMd, geminiMd, tocketMd, activeContextMd, systemPatternsMd, productContextMd, techContextMd, progressMd, } from "../templates/memory-bank.js";
+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 {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function detectFramework(deps, devDeps) {
+    const all = [...deps, ...devDeps];
+    if (all.includes("next"))
+        return "Next.js";
+    if (all.includes("nuxt"))
+        return "Nuxt";
+    if (all.includes("@sveltejs/kit"))
+        return "SvelteKit";
+    if (all.includes("remix") || all.includes("@remix-run/react"))
+        return "Remix";
+    if (all.includes("astro"))
+        return "Astro";
+    if (all.includes("react"))
+        return "React";
+    if (all.includes("vue"))
+        return "Vue";
+    if (all.includes("svelte"))
+        return "Svelte";
+    if (all.includes("angular") || all.includes("@angular/core"))
+        return "Angular";
+    if (all.includes("express"))
+        return "Express";
+    if (all.includes("fastify"))
+        return "Fastify";
+    if (all.includes("hono"))
+        return "Hono";
+    if (all.includes("commander") || all.includes("yargs"))
+        return "CLI (Node.js)";
+    return "";
+}
+function detectBuild(devDeps) {
+    if (devDeps.includes("vite"))
+        return "Vite";
+    if (devDeps.includes("webpack"))
+        return "Webpack";
+    if (devDeps.includes("esbuild"))
+        return "esbuild";
+    if (devDeps.includes("rollup"))
+        return "Rollup";
+    if (devDeps.includes("turbopack") || devDeps.includes("turbo"))
+        return "Turbopack";
+    if (devDeps.includes("typescript"))
+        return "tsc";
+    return "";
+}
+function pickExtras(deps, devDeps) {
+    const notable = [
+        "tailwindcss", "prisma", "@prisma/client",
+        "drizzle-orm", "mongoose", "sequelize",
+        "trpc", "@trpc/server", "graphql",
+        "zod", "joi", "yup",
+        "jest", "vitest", "mocha",
+        "eslint", "prettier", "biome",
+        "docker-compose", "firebase", "supabase",
+        "stripe", "clerk", "@clerk/nextjs",
+        "socket.io", "redis", "bullmq",
+    ];
+    const all = [...deps, ...devDeps];
+    return notable.filter((n) => all.includes(n));
+}
+async function detectStack(cwd) {
+    const empty = {
+        language: "",
+        runtime: "",
+        build: "",
+        framework: "",
+        extras: [],
+    };
+    const pkgPath = join(cwd, "package.json");
+    if (!(await fileExists(pkgPath))) {
+        return { stack: empty, detectedName: "", detectedDescription: "" };
+    }
+    let pkg;
+    try {
+        const raw = await readFile(pkgPath, "utf-8");
+        pkg = JSON.parse(raw);
+    }
+    catch {
+        return { stack: empty, detectedName: "", detectedDescription: "" };
+    }
+    const deps = Object.keys(pkg.dependencies ?? {});
+    const devDeps = Object.keys(pkg.devDependencies ?? {});
+    const hasTsConfig = await fileExists(join(cwd, "tsconfig.json"));
+    const hasTs = hasTsConfig || devDeps.includes("typescript");
+    const stack = {
+        language: hasTs ? "TypeScript" : "JavaScript",
+        runtime: "Node.js",
+        build: detectBuild(devDeps),
+        framework: detectFramework(deps, devDeps),
+        extras: pickExtras(deps, devDeps),
+    };
+    const rawName = pkg.name ?? "";
+    const detectedName = rawName.startsWith("@")
+        ? rawName.split("/").pop() ?? rawName
+        : rawName;
+    return {
+        stack,
+        detectedName,
+        detectedDescription: pkg.description ?? "",
+    };
+}
 export function registerInitCommand(program) {
     program
         .command("init")
         .description("Scaffold an agentic workspace with Memory Bank and triangulation config")
-        .action(async () => {
-        const projectName = await input({ message: "Project Name:" });
-        const description = await input({ message: "Short Description:" });
-        const contextDir = join(process.cwd(), ".context");
+        .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(heading("  Auto-detected stack:\n"));
+            if (stack.language)
+                console.log(info(`Language:  ${stack.language}`));
+            if (stack.runtime)
+                console.log(info(`Runtime:   ${stack.runtime}`));
+            if (stack.build)
+                console.log(info(`Build:     ${stack.build}`));
+            if (stack.framework)
+                console.log(info(`Framework: ${stack.framework}`));
+            if (stack.extras.length)
+                console.log(info(`Extras:    ${stack.extras.join(", ")}`));
+            console.log();
+        }
+        const projectName = await input({
+            message: "Project Name:",
+            default: detectedName || undefined,
+        });
+        const description = await input({
+            message: "Short Description:",
+            default: detectedDescription || undefined,
+        });
+        const contextDir = join(cwd, ".context");
         await mkdir(contextDir, { recursive: true });
         const files = [
             ["TOCKET.md", tocketMd(projectName)],
             ["CLAUDE.md", claudeMd(projectName, description)],
             ["GEMINI.md", geminiMd(projectName, description)],
+            [".cursorrules", cursorrulesMd(projectName, description)],
             [join(".context", "activeContext.md"), activeContextMd(projectName)],
             [join(".context", "systemPatterns.md"), systemPatternsMd(projectName)],
-            [join(".context", "productContext.md"), productContextMd(projectName, description)],
-            [join(".context", "techContext.md"), techContextMd(projectName)],
+            [
+                join(".context", "productContext.md"),
+                productContextMd(projectName, description),
+            ],
+            [
+                join(".context", "techContext.md"),
+                techContextMd(projectName, hasDetection ? stack : undefined),
+            ],
             [join(".context", "progress.md"), progressMd(projectName)],
         ];
         for (const [filePath, content] of files) {
-            const fullPath = join(process.cwd(), filePath);
+            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}! 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.1.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/templates/memory-bank.d.ts

@@ -1,8 +1,16 @@
+export interface StackInfo {
+    language: string;
+    runtime: string;
+    build: string;
+    framework: string;
+    extras: string[];
+}
 export declare const claudeMd: (projectName: string, description: string) => string;
 export declare const geminiMd: (projectName: string, description: string) => string;
 export declare const activeContextMd: (projectName: string) => string;
 export declare const systemPatternsMd: (projectName: string) => string;
 export declare const productContextMd: (projectName: string, description: string) => string;
-export declare const techContextMd: (projectName: string) => string;
+export declare const techContextMd: (projectName: string, stack?: StackInfo) => string;
 export declare const progressMd: (projectName: string) => string;
+export declare const cursorrulesMd: (projectName: string, description: string) => string;
 export declare const tocketMd: (projectName: string) => string;

package/dist/templates/memory-bank.js

@@ -163,7 +163,15 @@ _Who is this for?_
 
 - _List the guiding principles for this project_
 `;
-export const techContextMd = (projectName) => `# Tech Context - ${projectName}
+export const techContextMd = (projectName, stack) => {
+    const lang = stack?.language || "";
+    const rt = stack?.runtime || "";
+    const bld = stack?.build || "";
+    const fw = stack?.framework || "";
+    const extras = stack?.extras?.length
+        ? `\n### Notable Dependencies\n\n${stack.extras.map((d) => `- \`${d}\``).join("\n")}\n`
+        : "";
+    return `# Tech Context - ${projectName}
 
 <!-- Stack, build tools, and critical rules. Updated by the Architect. -->
 
@@ -171,11 +179,11 @@ export const techContextMd = (projectName) => `# Tech Context - ${projectName}
 
 | Layer | Technology | Notes |
 |-------|-----------|-------|
-| Language | | |
-| Runtime | | |
-| Build | | |
-| Framework | | |
-
+| Language | ${lang} | ${lang ? "Auto-detected by Tocket" : ""} |
+| Runtime | ${rt} | ${rt ? "Auto-detected by Tocket" : ""} |
+| Build | ${bld} | ${bld ? "Auto-detected by Tocket" : ""} |
+| Framework | ${fw} | ${fw ? "Auto-detected by Tocket" : ""} |
+${extras}
 ## Critical Rules
 
 _Document any rules that agents must follow (e.g., import conventions, naming patterns)._
@@ -188,6 +196,7 @@ ${projectName}/
   .context/    # Memory Bank
 \`\`\`
 `;
+};
 export const progressMd = (projectName) => `# Progress Log - ${projectName}
 
 <!-- Appended by tocket sync and manual updates -->
@@ -203,6 +212,38 @@ export const progressMd = (projectName) => `# Progress Log - ${projectName}
 
 - [ ] _Define your first milestone here_
 `;
+export const cursorrulesMd = (projectName, description) => `# .cursorrules - ${projectName}
+
+# Generated by Tocket CLI — compatible with Cursor IDE
+
+## Role
+
+You are the **Executor** for **${projectName}**.
+${description ? `\n> ${description}\n` : ""}
+Your job is to **implement**, not to plan. Read the Memory Bank before every session, follow the Architect's decisions, and write code.
+
+## Rules
+
+1. **Always read \`.context/\` first** — Start every session by reading activeContext.md and systemPatterns.md.
+2. **Follow the Architect's plan** — Implementation decisions come from mission briefs. Do not redesign.
+3. **Ask before deviating** — If the plan is unclear or blocked, ask the user. Do not improvise architecture.
+4. **Write code in English** — Variables, functions, comments, commits — all in \`en-US\`.
+5. **Update Memory Bank on completion** — After finishing a task, update activeContext.md with what changed.
+
+## Memory Bank
+
+| File | Purpose |
+|------|---------|
+| \`.context/activeContext.md\` | Current focus, recent changes, open decisions |
+| \`.context/systemPatterns.md\` | Architecture patterns, tech stack, conventions |
+| \`.context/techContext.md\` | Stack, build tools, critical rules |
+
+## Workflow
+
+\`\`\`
+1. Read .context/  →  2. Receive task  →  3. Implement  →  4. Update .context/
+\`\`\`
+`;
 export const tocketMd = (projectName) => `# Tocket Protocol Specification
 
 > How any AI agent should operate in **${projectName}**.

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/memory-bank.test.js

@@ -1,6 +1,6 @@
 import { describe, it } from "node:test";
 import assert from "node:assert/strict";
-import { claudeMd, geminiMd, tocketMd, activeContextMd, systemPatternsMd, productContextMd, techContextMd, progressMd, } from "../templates/memory-bank.js";
+import { claudeMd, geminiMd, tocketMd, activeContextMd, systemPatternsMd, productContextMd, techContextMd, progressMd, cursorrulesMd, } from "../templates/memory-bank.js";
 describe("claudeMd", () => {
     const output = claudeMd("TestProject", "A test project");
     it("includes the project name in the title", () => {
@@ -106,17 +106,63 @@ describe("productContextMd", () => {
     });
 });
 describe("techContextMd", () => {
-    const output = techContextMd("TestProject");
     it("includes the project name", () => {
+        const output = techContextMd("TestProject");
         assert.ok(output.includes("# Tech Context - TestProject"));
     });
     it("has a stack table", () => {
+        const output = techContextMd("TestProject");
         assert.ok(output.includes("| Language |"));
         assert.ok(output.includes("| Runtime |"));
     });
     it("includes project structure with project name", () => {
+        const output = techContextMd("TestProject");
         assert.ok(output.includes("TestProject/"));
     });
+    it("renders empty rows when no stack provided", () => {
+        const output = techContextMd("TestProject");
+        // Should have empty cells (no "Auto-detected")
+        assert.ok(!output.includes("Auto-detected"));
+    });
+    it("renders detected stack when StackInfo is provided", () => {
+        const stack = {
+            language: "TypeScript",
+            runtime: "Node.js",
+            build: "Vite",
+            framework: "React",
+            extras: ["tailwindcss", "prisma"],
+        };
+        const output = techContextMd("TestProject", stack);
+        assert.ok(output.includes("TypeScript"));
+        assert.ok(output.includes("Node.js"));
+        assert.ok(output.includes("Vite"));
+        assert.ok(output.includes("React"));
+        assert.ok(output.includes("Auto-detected by Tocket"));
+    });
+    it("renders notable dependencies when extras are present", () => {
+        const stack = {
+            language: "TypeScript",
+            runtime: "Node.js",
+            build: "tsc",
+            framework: "",
+            extras: ["tailwindcss", "zod"],
+        };
+        const output = techContextMd("TestProject", stack);
+        assert.ok(output.includes("### Notable Dependencies"));
+        assert.ok(output.includes("`tailwindcss`"));
+        assert.ok(output.includes("`zod`"));
+    });
+    it("omits notable dependencies section when extras are empty", () => {
+        const stack = {
+            language: "TypeScript",
+            runtime: "Node.js",
+            build: "tsc",
+            framework: "",
+            extras: [],
+        };
+        const output = techContextMd("TestProject", stack);
+        assert.ok(!output.includes("### Notable Dependencies"));
+    });
 });
 describe("progressMd", () => {
     const output = progressMd("TestProject");
@@ -130,3 +176,24 @@ describe("progressMd", () => {
         assert.ok(output.includes("## Next Up"));
     });
 });
+describe("cursorrulesMd", () => {
+    const output = cursorrulesMd("TestProject", "A cool CLI tool");
+    it("includes the project name", () => {
+        assert.ok(output.includes("# .cursorrules - TestProject"));
+    });
+    it("includes the description as a blockquote", () => {
+        assert.ok(output.includes("> A cool CLI tool"));
+    });
+    it("defines the Executor role", () => {
+        assert.ok(output.includes("**Executor**"));
+    });
+    it("references Memory Bank files", () => {
+        assert.ok(output.includes(".context/activeContext.md"));
+        assert.ok(output.includes(".context/systemPatterns.md"));
+    });
+    it("handles empty description gracefully", () => {
+        const noDesc = cursorrulesMd("Foo", "");
+        assert.ok(noDesc.includes("# .cursorrules - Foo"));
+        assert.ok(!noDesc.includes("> \n"));
+    });
+});

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.1.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"
   },