@pedrocivita/tocket 2.0.0 → 2.1.0

package/README.md

@@ -43,6 +43,12 @@ npx @pedrocivita/tocket generate
 
 # Sync session progress into Memory Bank
 npx @pedrocivita/tocket sync
+
+# Update the current focus
+npx @pedrocivita/tocket focus "Refactoring payment module"
+
+# Remove all Tocket files (with confirmation)
+npx @pedrocivita/tocket eject
 ```
 
 ## Commands
@@ -54,7 +60,10 @@ npx @pedrocivita/tocket sync
 | `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 focus`    | Update the Current Focus in `.context/activeContext.md`              |
+| `tocket status`   | Quick overview of workspace, focus, branch, and agents               |
 | `tocket config`   | Manage global settings (`~/.tocketrc.json`)                          |
+| `tocket eject`    | Remove all Tocket files from the workspace                           |
 
 ## Configuration
 

package/dist/commands/dashboard.js

@@ -44,7 +44,10 @@ export async function showDashboard(program) {
             { value: "generate", name: "Generate payload" },
             { value: "sync", name: "Sync progress" },
             { value: "validate", name: "Validate workspace" },
+            { value: "focus", name: "Update focus" },
+            { value: "status", name: "Workspace status" },
             { value: "config", name: "Configure settings" },
+            { value: "eject", name: "Eject workspace" },
             { value: "exit", name: "Exit" },
         ]
         : [

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

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+/** Files created by `tocket init` that eject should remove. */
+export declare const EJECT_FILES: readonly ["TOCKET.md", "CLAUDE.md", "GEMINI.md", ".cursorrules"];
+/** Directories created by `tocket init` that eject should remove. */
+export declare const EJECT_DIRS: readonly [".context"];
+export declare function registerEjectCommand(program: Command): void;

package/dist/commands/eject.cmd.js

@@ -0,0 +1,65 @@
+import { confirm } from "@inquirer/prompts";
+import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { success, warn, info, dim } from "../utils/theme.js";
+/** Files created by `tocket init` that eject should remove. */
+export const EJECT_FILES = [
+    "TOCKET.md",
+    "CLAUDE.md",
+    "GEMINI.md",
+    ".cursorrules",
+];
+/** Directories created by `tocket init` that eject should remove. */
+export const EJECT_DIRS = [".context"];
+export function registerEjectCommand(program) {
+    program
+        .command("eject")
+        .description("Remove all Tocket files from the current workspace")
+        .option("-f, --force", "Skip confirmation prompt")
+        .action(async (options) => {
+        const cwd = process.cwd();
+        const contextDir = join(cwd, ".context");
+        if (!existsSync(contextDir)) {
+            console.log(warn("No Tocket workspace found in this directory."));
+            return;
+        }
+        if (!options.force) {
+            const ok = await confirm({
+                message: "This will permanently remove .context/, CLAUDE.md, GEMINI.md, TOCKET.md, and .cursorrules. Continue?",
+                default: false,
+            });
+            if (!ok) {
+                console.log(dim("\n  Cancelled.\n"));
+                return;
+            }
+        }
+        let removedCount = 0;
+        for (const dir of EJECT_DIRS) {
+            const fullPath = join(cwd, dir);
+            if (existsSync(fullPath)) {
+                await rm(fullPath, { recursive: true, force: true });
+                console.log(info(`Removed ${dir}/`));
+                removedCount++;
+            }
+        }
+        for (const file of EJECT_FILES) {
+            const fullPath = join(cwd, file);
+            if (existsSync(fullPath)) {
+                await rm(fullPath, { force: true });
+                console.log(info(`Removed ${file}`));
+                removedCount++;
+            }
+        }
+        if (removedCount === 0) {
+            console.log(warn("Nothing to remove."));
+        }
+        else {
+            console.log("\n" +
+                success("Tocket workspace ejected.") +
+                " " +
+                dim("Global config (~/.tocketrc.json) was not touched.") +
+                "\n");
+        }
+    });
+}

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

@@ -0,0 +1,7 @@
+import type { Command } from "commander";
+/**
+ * Replaces the content under ## Current Focus with the new message.
+ * Exported for testing.
+ */
+export declare function replaceFocusSection(content: string, newFocus: string): string;
+export declare function registerFocusCommand(program: Command): void;

package/dist/commands/focus.cmd.js

@@ -0,0 +1,52 @@
+import { input } from "@inquirer/prompts";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { success, error as themeError, info } from "../utils/theme.js";
+/**
+ * Replaces the content under ## Current Focus with the new message.
+ * Exported for testing.
+ */
+export function replaceFocusSection(content, newFocus) {
+    const regex = /(## Current Focus[ \t]*\n)[\s\S]*?(?=\n## |\n*$)/;
+    if (!regex.test(content)) {
+        return content.trimEnd() + "\n\n## Current Focus\n\n" + newFocus + "\n";
+    }
+    return content.replace(regex, `$1\n${newFocus}\n`);
+}
+export function registerFocusCommand(program) {
+    program
+        .command("focus")
+        .description("Update the Current Focus in activeContext.md")
+        .argument("[message...]", "Focus message (prompted if omitted)")
+        .action(async (messageParts) => {
+        const cwd = process.cwd();
+        const contextDir = join(cwd, ".context");
+        if (!existsSync(contextDir)) {
+            console.error(themeError("No .context/ directory found. Run 'tocket init' first."));
+            process.exitCode = 1;
+            return;
+        }
+        const filePath = join(contextDir, "activeContext.md");
+        if (!existsSync(filePath)) {
+            console.error(themeError("activeContext.md not found. Run 'tocket init' first."));
+            process.exitCode = 1;
+            return;
+        }
+        let message = messageParts.join(" ").trim();
+        if (!message) {
+            message = await input({ message: "What is the current focus?" });
+            message = message.trim();
+        }
+        if (!message) {
+            console.error(themeError("Focus message cannot be empty."));
+            process.exitCode = 1;
+            return;
+        }
+        const content = await readFile(filePath, "utf-8");
+        const updated = replaceFocusSection(content, message);
+        await writeFile(filePath, updated, "utf-8");
+        console.log(info("Focus updated in .context/activeContext.md"));
+        console.log("  " + success(message));
+    });
+}

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

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

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/index.js

@@ -7,6 +7,9 @@ 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
@@ -18,6 +21,9 @@ registerGenerateCommand(program);
 registerSyncCommand(program);
 registerValidateCommand(program);
 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) {

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/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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pedrocivita/tocket",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "The Context Engineering Framework for Multi-Agent Workspaces",
   "type": "module",
   "main": "dist/index.js",