@pedrocivita/tocket 2.0.0 → 2.2.0

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/generate.cmd.d.ts

@@ -1,2 +1,10 @@
 import type { Command } from "commander";
+export interface TaskInput {
+    intent: string;
+    scope: string;
+    priority: string;
+    skills: string;
+}
+export declare function buildPayloadXml(tasks: TaskInput[]): string;
+export declare function suggestScope(): string;
 export declare function registerGenerateCommand(program: Command): void;

package/dist/commands/generate.cmd.js

@@ -1,9 +1,9 @@
 import { input, select, confirm } from "@inquirer/prompts";
-import clipboard from "clipboardy";
+import { writeFileSync } from "node:fs";
 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) {
+import { getStagedFiles, getModifiedFiles, getLastCommitMessage } from "../utils/git.js";
+export function buildPayloadXml(tasks) {
     const first = tasks[0];
     const skillsAttr = first.skills.trim()
         ? `\n    <skills>${first.skills.trim()}</skills>`
@@ -36,7 +36,7 @@ ${taskBlocks}
   </validate>
 </payload>`;
 }
-function suggestScope() {
+export function suggestScope() {
     const staged = getStagedFiles();
     const modified = getModifiedFiles();
     const all = [...new Set([...staged, ...modified])];
@@ -47,6 +47,7 @@ export function registerGenerateCommand(program) {
         .command("generate")
         .description("Build payload XMLs interactively for Architect-Executor handoff")
         .option("--no-preview", "Skip payload preview before copying")
+        .option("--to <target>", "Output target: clipboard (default), stdout, or file path")
         .action(async (options) => {
         const config = await getConfig();
         if (!config.theme?.disableBanner) {
@@ -62,7 +63,11 @@ export function registerGenerateCommand(program) {
             if (taskNum > 1) {
                 console.log(heading(`\n  Task ${taskNum}\n`));
             }
-            const intent = await input({ message: "Intent (goal in one line):" });
+            const lastCommit = getLastCommitMessage();
+            const intent = await input({
+                message: "Intent (goal in one line):",
+                default: lastCommit || undefined,
+            });
             const scope = await input({
                 message: "Scope (files/folders affected):",
                 default: taskNum === 1 && suggestedScope ? suggestedScope : undefined,
@@ -97,10 +102,22 @@ export function registerGenerateCommand(program) {
             console.log(dim(preview));
             console.log(dim("--- End Preview ---\n"));
         }
-        clipboard.writeSync(xml);
-        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"));
+        const target = options.to ?? "clipboard";
+        if (target === "stdout") {
+            console.log(xml);
+        }
+        else if (target === "clipboard") {
+            const { default: clipboard } = await import("clipboardy");
+            clipboard.writeSync(xml);
+            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"));
+        }
+        else {
+            writeFileSync(target, xml, "utf-8");
+            console.log(success(`Payload XML (v2.0) written to ${target}!`) +
+                dim(` ${tasks.length} task(s).\n`));
+        }
     });
 }

package/dist/commands/init.cmd.js

@@ -119,8 +119,12 @@ export function registerInitCommand(program) {
         .command("init")
         .description("Scaffold an agentic workspace with Memory Bank and triangulation config")
         .option("-f, --force", "Overwrite existing files without prompting")
+        .option("--minimal", "Scaffold only essential files (.context/ + TOCKET.md)")
+        .option("--name <name>", "Project name (skip prompt)")
+        .option("--description <desc>", "Project description (skip prompt)")
         .action(async (options) => {
         const force = options.force ?? false;
+        const minimal = options.minimal ?? false;
         const cwd = process.cwd();
         const globalConfig = await getConfig();
         if (!globalConfig.theme?.disableBanner) {
@@ -142,11 +146,11 @@ export function registerInitCommand(program) {
                 console.log(info(`Extras:    ${stack.extras.join(", ")}`));
             console.log();
         }
-        const projectName = await input({
+        const projectName = options.name ?? await input({
             message: "Project Name:",
             default: detectedName || undefined,
         });
-        const description = await input({
+        const description = options.description ?? await input({
             message: "Short Description:",
             default: detectedDescription || undefined,
         });
@@ -169,7 +173,15 @@ export function registerInitCommand(program) {
             ],
             [join(".context", "progress.md"), progressMd(projectName)],
         ];
-        for (const [filePath, content] of files) {
+        const minimalPaths = new Set([
+            "TOCKET.md",
+            join(".context", "activeContext.md"),
+            join(".context", "systemPatterns.md"),
+        ]);
+        const filesToWrite = minimal
+            ? files.filter(([path]) => minimalPaths.has(path))
+            : files;
+        for (const [filePath, content] of filesToWrite) {
             const fullPath = join(cwd, filePath);
             const exists = await fileExists(fullPath);
             if (exists && !force) {

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

@@ -0,0 +1,12 @@
+import type { Command } from "commander";
+export interface LintResult {
+    severity: "pass" | "warn" | "info" | "fail";
+    message: string;
+    file?: string;
+    suggestion?: string;
+}
+export declare function lintActiveContext(content: string): LintResult[];
+export declare function lintSystemPatterns(content: string): LintResult[];
+export declare function lintProtocolSpec(content: string): LintResult[];
+export declare function lintAgentConfig(name: string, content: string): LintResult[];
+export declare function registerLintCommand(program: Command): void;

package/dist/commands/lint.cmd.js

@@ -0,0 +1,269 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+import { success as themePass, warn as themeWarn, error as themeFail, heading, dim, info as themeInfo } from "../utils/theme.js";
+import { isGitRepo } from "../utils/git.js";
+export function lintActiveContext(content) {
+    const results = [];
+    // Check required sections exist
+    const requiredSections = ["## Current Focus", "## Recent Changes", "## Open Decisions"];
+    for (const section of requiredSections) {
+        if (content.includes(section)) {
+            results.push({ severity: "pass", message: `Has ${section} section` });
+        }
+        else {
+            results.push({
+                severity: "fail",
+                message: `Missing ${section} section`,
+                suggestion: `Add a "${section}" heading to activeContext.md`,
+            });
+        }
+    }
+    // Check Current Focus is populated
+    const focusMatch = content.match(/## Current Focus\s*\n+([\s\S]*?)(?=\n##|\n*$)/);
+    const focusBody = focusMatch?.[1]?.trim() ?? "";
+    if (!focusBody || focusBody.startsWith("_") || focusBody.includes("No active tasks")) {
+        results.push({
+            severity: "warn",
+            message: "Current Focus is empty or placeholder",
+            suggestion: "Run tocket focus \"your current task\" to set it",
+        });
+    }
+    else {
+        results.push({ severity: "pass", message: "Current Focus is populated" });
+    }
+    // Check Open Decisions section
+    const decisionsMatch = content.match(/## Open Decisions\s*\n+([\s\S]*?)(?=\n##|\n*$)/);
+    const decisionsBody = decisionsMatch?.[1]?.trim() ?? "";
+    if (!decisionsBody || decisionsBody.startsWith("_")) {
+        results.push({
+            severity: "info",
+            message: "Open Decisions section is empty",
+            suggestion: "List any unresolved decisions or write \"None\" if all resolved",
+        });
+    }
+    return results;
+}
+export function lintSystemPatterns(content) {
+    const results = [];
+    const hasConvention = content.includes("- ") || content.includes("| ");
+    if (hasConvention) {
+        results.push({ severity: "pass", message: "Has documented conventions" });
+    }
+    else {
+        results.push({
+            severity: "warn",
+            message: "No conventions documented",
+            suggestion: "Add bullet points or a table with your project's coding conventions",
+        });
+    }
+    // Check for key decisions table
+    if (content.includes("Key Decisions") || content.includes("key decisions")) {
+        const hasDecisionRows = content.match(/\|[^|]+\|[^|]+\|[^|]+\|/g);
+        const hasDataRows = hasDecisionRows && hasDecisionRows.length > 2; // header + separator + at least 1 row
+        if (hasDataRows) {
+            results.push({ severity: "pass", message: "Has key decisions recorded" });
+        }
+        else {
+            results.push({
+                severity: "info",
+                message: "Key Decisions table is empty",
+                suggestion: "Record architectural decisions with rationale and date",
+            });
+        }
+    }
+    return results;
+}
+export function lintProtocolSpec(content) {
+    const results = [];
+    if (content.includes("payload") || content.includes("Payload")) {
+        results.push({ severity: "pass", message: "References payload format" });
+    }
+    else {
+        results.push({
+            severity: "warn",
+            message: "Does not reference payload format",
+            suggestion: "TOCKET.md should describe the payload XML handoff format",
+        });
+    }
+    if (content.includes("Memory Bank") || content.includes(".context/")) {
+        results.push({ severity: "pass", message: "References Memory Bank" });
+    }
+    else {
+        results.push({
+            severity: "warn",
+            message: "Does not reference Memory Bank",
+            suggestion: "TOCKET.md should describe the .context/ directory",
+        });
+    }
+    return results;
+}
+export function lintAgentConfig(name, content) {
+    const results = [];
+    if (content.includes(".context/") || content.includes(".context\\")) {
+        results.push({ severity: "pass", message: `References .context/` });
+    }
+    else {
+        results.push({
+            severity: "warn",
+            message: `Does not reference .context/`,
+            suggestion: `Add instructions to read .context/ before acting`,
+        });
+    }
+    return results;
+}
+function severityIcon(severity) {
+    switch (severity) {
+        case "pass": return themePass("");
+        case "warn": return themeWarn("");
+        case "info": return themeInfo("");
+        case "fail": return themeFail("");
+    }
+}
+export function registerLintCommand(program) {
+    program
+        .command("lint")
+        .description("Audit .context/ content quality and suggest improvements")
+        .action(() => {
+        const cwd = process.cwd();
+        let passCount = 0;
+        let warnCount = 0;
+        let infoCount = 0;
+        let failCount = 0;
+        console.log(heading("\nTocket Lint\n"));
+        // Check TOCKET.md exists
+        const tocketPath = join(cwd, "TOCKET.md");
+        if (!existsSync(tocketPath)) {
+            console.log(themeFail("  TOCKET.md not found. Run tocket init first."));
+            process.exitCode = 1;
+            return;
+        }
+        // Lint activeContext.md
+        const acPath = join(cwd, ".context", "activeContext.md");
+        if (existsSync(acPath)) {
+            console.log(dim("  .context/activeContext.md"));
+            const content = readFileSync(acPath, "utf-8");
+            const results = lintActiveContext(content);
+            for (const r of results) {
+                printResult(r);
+                countResult(r.severity);
+            }
+            // Staleness check
+            const stats = statSync(acPath);
+            const daysSince = Math.floor((Date.now() - stats.mtimeMs) / (1000 * 60 * 60 * 24));
+            if (daysSince > 7) {
+                const r = {
+                    severity: "warn",
+                    message: `Last modified ${daysSince} days ago`,
+                    suggestion: "Update activeContext.md with current state",
+                };
+                printResult(r);
+                countResult(r.severity);
+            }
+            console.log();
+        }
+        else {
+            console.log(dim("  .context/activeContext.md"));
+            console.log(`    ${severityIcon("fail")} File missing (required)`);
+            failCount++;
+            console.log();
+        }
+        // Lint systemPatterns.md
+        const spPath = join(cwd, ".context", "systemPatterns.md");
+        if (existsSync(spPath)) {
+            console.log(dim("  .context/systemPatterns.md"));
+            const content = readFileSync(spPath, "utf-8");
+            const results = lintSystemPatterns(content);
+            for (const r of results) {
+                printResult(r);
+                countResult(r.severity);
+            }
+            console.log();
+        }
+        // Lint TOCKET.md
+        console.log(dim("  TOCKET.md"));
+        const tocketContent = readFileSync(tocketPath, "utf-8");
+        const tocketResults = lintProtocolSpec(tocketContent);
+        for (const r of tocketResults) {
+            printResult(r);
+            countResult(r.severity);
+        }
+        console.log();
+        // Lint agent configs
+        const agentFiles = ["CLAUDE.md", "GEMINI.md"];
+        for (const af of agentFiles) {
+            const afPath = join(cwd, af);
+            if (existsSync(afPath)) {
+                console.log(dim(`  ${af}`));
+                const content = readFileSync(afPath, "utf-8");
+                const results = lintAgentConfig(af, content);
+                for (const r of results) {
+                    printResult(r);
+                    countResult(r.severity);
+                }
+                console.log();
+            }
+        }
+        // Uncommitted context check
+        if (isGitRepo(cwd)) {
+            try {
+                const output = execSync("git status --porcelain .context/", {
+                    cwd,
+                    encoding: "utf-8",
+                }).trim();
+                if (output) {
+                    const count = output.split("\n").length;
+                    console.log(dim("  git"));
+                    const r = {
+                        severity: "info",
+                        message: `${count} uncommitted change(s) in .context/`,
+                        suggestion: "Commit .context/ changes to preserve shared memory",
+                    };
+                    printResult(r);
+                    countResult(r.severity);
+                    console.log();
+                }
+            }
+            catch {
+                // git error — skip
+            }
+        }
+        // Summary
+        const total = passCount + warnCount + infoCount + failCount;
+        console.log(dim(`  ${passCount} passed, ${warnCount} warnings, ${infoCount} info, ${failCount} failures (${total} checks)`));
+        console.log();
+        if (failCount > 0) {
+            console.log(themeFail("Context has issues that need attention."));
+            process.exitCode = 1;
+        }
+        else if (warnCount > 0) {
+            console.log(themeWarn("Context is functional but could be improved."));
+        }
+        else {
+            console.log(themePass("Context is in great shape."));
+        }
+        function printResult(r) {
+            const icon = severityIcon(r.severity);
+            console.log(`    ${icon} ${r.message}`);
+            if (r.suggestion) {
+                console.log(`      ${dim(r.suggestion)}`);
+            }
+        }
+        function countResult(severity) {
+            switch (severity) {
+                case "pass":
+                    passCount++;
+                    break;
+                case "warn":
+                    warnCount++;
+                    break;
+                case "info":
+                    infoCount++;
+                    break;
+                case "fail":
+                    failCount++;
+                    break;
+            }
+        }
+    });
+}

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/commands/sync.cmd.js

@@ -9,7 +9,8 @@ export function registerSyncCommand(program) {
     program
         .command("sync")
         .description("Update Memory Bank from git history and session artifacts")
-        .action(async () => {
+        .option("--summary <text>", "Session summary (skip prompt)")
+        .action(async (options) => {
         const progressPath = join(process.cwd(), ".context", "progress.md");
         const contextDir = join(process.cwd(), ".context");
         if (!existsSync(contextDir)) {
@@ -18,7 +19,7 @@ export function registerSyncCommand(program) {
             return;
         }
         const config = await getConfig();
-        const summary = await input({
+        const summary = options.summary ?? await input({
             message: "What did you accomplish in this session?",
         });
         const commits = getRecentCommitsRaw();

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

@@ -1,2 +1,9 @@
 import type { Command } from "commander";
+export interface CheckResult {
+    icon: string;
+    message: string;
+}
+export declare function checkFile(basePath: string, relativePath: string, required: boolean): CheckResult;
+export declare function checkStale(basePath: string, relativePath: string): CheckResult | null;
+export declare function checkAgentFile(basePath: string): CheckResult;
 export declare function registerValidateCommand(program: Command): void;

package/dist/commands/validate.cmd.js

@@ -4,7 +4,7 @@ import { success as themePass, warn as themeWarn, error as themeFail, heading }
 const PASS = themePass("");
 const WARN = themeWarn("");
 const FAIL = themeFail("");
-function checkFile(basePath, relativePath, required) {
+export function checkFile(basePath, relativePath, required) {
     const fullPath = join(basePath, relativePath);
     if (existsSync(fullPath)) {
         return { icon: PASS, message: `${relativePath} found` };
@@ -14,7 +14,7 @@ function checkFile(basePath, relativePath, required) {
     }
     return { icon: WARN, message: `${relativePath} missing (optional)` };
 }
-function checkStale(basePath, relativePath) {
+export function checkStale(basePath, relativePath) {
     const fullPath = join(basePath, relativePath);
     if (!existsSync(fullPath))
         return null;
@@ -28,7 +28,7 @@ function checkStale(basePath, relativePath) {
     }
     return null;
 }
-function checkAgentFile(basePath) {
+export function checkAgentFile(basePath) {
     const agentFiles = [
         "CLAUDE.md",
         "GEMINI.md",

package/dist/index.js

@@ -7,6 +7,11 @@ 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";
+import { registerDoctorCommand } from "./commands/doctor.cmd.js";
+import { registerLintCommand } from "./commands/lint.cmd.js";
 const pkg = JSON.parse(readFileSync(join(import.meta.dirname, "..", "package.json"), "utf-8"));
 const program = new Command();
 program
@@ -18,6 +23,11 @@ registerGenerateCommand(program);
 registerSyncCommand(program);
 registerValidateCommand(program);
 registerConfigCommand(program);
+registerEjectCommand(program);
+registerFocusCommand(program);
+registerStatusCommand(program);
+registerDoctorCommand(program);
+registerLintCommand(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/doctor.test.d.ts

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