@pedrocivita/tocket 2.1.0 → 2.2.0

package/dist/tests/init.test.js

@@ -0,0 +1,69 @@
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execSync } from "node:child_process";
+// Path to the built CLI
+const cliPath = join(import.meta.dirname, "..", "index.js");
+describe("init --minimal", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-init-minimal-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("creates only essential files with --minimal --name --description --force", () => {
+        execSync(`node "${cliPath}" init --minimal --name testproject --description "A test" --force`, { cwd: tempDir, encoding: "utf-8" });
+        // Essential files should exist
+        assert.ok(existsSync(join(tempDir, ".context", "activeContext.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "systemPatterns.md")));
+        assert.ok(existsSync(join(tempDir, "TOCKET.md")));
+        // Non-essential files should NOT exist
+        assert.ok(!existsSync(join(tempDir, "CLAUDE.md")));
+        assert.ok(!existsSync(join(tempDir, "GEMINI.md")));
+        assert.ok(!existsSync(join(tempDir, ".cursorrules")));
+        assert.ok(!existsSync(join(tempDir, ".context", "productContext.md")));
+        assert.ok(!existsSync(join(tempDir, ".context", "techContext.md")));
+        assert.ok(!existsSync(join(tempDir, ".context", "progress.md")));
+    });
+});
+describe("init --name --description (non-interactive)", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-init-flags-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("creates full workspace without interactive prompts", () => {
+        execSync(`node "${cliPath}" init --name flagproject --description "Flag desc" --force`, { cwd: tempDir, encoding: "utf-8" });
+        // All 9 files should exist (not minimal)
+        assert.ok(existsSync(join(tempDir, ".context", "activeContext.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "systemPatterns.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "productContext.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "techContext.md")));
+        assert.ok(existsSync(join(tempDir, ".context", "progress.md")));
+        assert.ok(existsSync(join(tempDir, "TOCKET.md")));
+        assert.ok(existsSync(join(tempDir, "CLAUDE.md")));
+        assert.ok(existsSync(join(tempDir, "GEMINI.md")));
+        assert.ok(existsSync(join(tempDir, ".cursorrules")));
+    });
+});
+describe("init --minimal file count", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-init-count-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("minimal creates exactly 3 files + 1 directory", () => {
+        execSync(`node "${cliPath}" init --minimal --name counttest --description "test" --force`, { cwd: tempDir, encoding: "utf-8" });
+        // Count files in .context/
+        const contextDir = join(tempDir, ".context");
+        assert.ok(existsSync(contextDir));
+        // Exactly 2 files in .context/
+        const contextFiles = ["activeContext.md", "systemPatterns.md"];
+        for (const f of contextFiles) {
+            assert.ok(existsSync(join(contextDir, f)), `${f} should exist`);
+        }
+        // These should NOT be in .context/ with minimal
+        const skippedContextFiles = ["productContext.md", "techContext.md", "progress.md"];
+        for (const f of skippedContextFiles) {
+            assert.ok(!existsSync(join(contextDir, f)), `${f} should not exist in minimal mode`);
+        }
+    });
+});

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

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

package/dist/tests/lint.test.js

@@ -0,0 +1,120 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { lintActiveContext, lintSystemPatterns, lintProtocolSpec, lintAgentConfig, } from "../commands/lint.cmd.js";
+describe("lintActiveContext", () => {
+    const wellFormed = `# Active Context
+
+## Current Focus
+
+Working on feature X.
+
+## Recent Changes
+
+| Date | Change | Agent |
+|------|--------|-------|
+| 2026-02-25 | Added X | Claude |
+
+## Open Decisions
+
+- Should we use Y or Z?
+`;
+    it("passes all checks on well-formed content", () => {
+        const results = lintActiveContext(wellFormed);
+        const fails = results.filter((r) => r.severity === "fail");
+        assert.equal(fails.length, 0);
+    });
+    it("detects all three required sections", () => {
+        const results = lintActiveContext(wellFormed);
+        const sectionPasses = results.filter((r) => r.severity === "pass" && r.message.includes("Has ##"));
+        assert.equal(sectionPasses.length, 3);
+    });
+    it("detects populated focus", () => {
+        const results = lintActiveContext(wellFormed);
+        const focusPass = results.find((r) => r.message.includes("Focus is populated"));
+        assert.ok(focusPass);
+    });
+    it("warns on placeholder focus", () => {
+        const placeholder = wellFormed.replace("Working on feature X.", "_Describe what you're working on._");
+        const results = lintActiveContext(placeholder);
+        const focusWarn = results.find((r) => r.severity === "warn" && r.message.includes("Focus"));
+        assert.ok(focusWarn);
+        assert.ok(focusWarn.suggestion);
+    });
+    it("fails when Current Focus section is missing", () => {
+        const noFocus = "# Active Context\n\n## Recent Changes\n\n## Open Decisions\n";
+        const results = lintActiveContext(noFocus);
+        const fail = results.find((r) => r.severity === "fail" && r.message.includes("Current Focus"));
+        assert.ok(fail);
+    });
+    it("fails when Recent Changes section is missing", () => {
+        const noRecent = "# Active Context\n\n## Current Focus\n\nDoing X.\n\n## Open Decisions\n";
+        const results = lintActiveContext(noRecent);
+        const fail = results.find((r) => r.severity === "fail" && r.message.includes("Recent Changes"));
+        assert.ok(fail);
+    });
+    it("reports info when Open Decisions is empty", () => {
+        const emptyDecisions = wellFormed.replace("- Should we use Y or Z?", "_List anything unresolved._");
+        const results = lintActiveContext(emptyDecisions);
+        const info = results.find((r) => r.severity === "info" && r.message.includes("Open Decisions"));
+        assert.ok(info);
+    });
+});
+describe("lintSystemPatterns", () => {
+    it("passes when conventions are documented with bullet points", () => {
+        const content = "# Patterns\n\n- Code in English\n- ESM only\n";
+        const results = lintSystemPatterns(content);
+        const pass = results.find((r) => r.message.includes("documented conventions"));
+        assert.ok(pass);
+        assert.equal(pass.severity, "pass");
+    });
+    it("passes when conventions are documented with table rows", () => {
+        const content = "# Patterns\n\n| Convention | Detail |\n|---|---|\n| Language | English |\n";
+        const results = lintSystemPatterns(content);
+        const pass = results.find((r) => r.message.includes("documented conventions"));
+        assert.ok(pass);
+    });
+    it("warns when no conventions exist", () => {
+        const content = "# Patterns\n\nNothing here yet.\n";
+        const results = lintSystemPatterns(content);
+        const warn = results.find((r) => r.severity === "warn");
+        assert.ok(warn);
+        assert.ok(warn.suggestion);
+    });
+});
+describe("lintProtocolSpec", () => {
+    it("passes when payload and Memory Bank are referenced", () => {
+        const content = "# Protocol\n\nThe payload format...\n\nMemory Bank in .context/\n";
+        const results = lintProtocolSpec(content);
+        const passes = results.filter((r) => r.severity === "pass");
+        assert.equal(passes.length, 2);
+    });
+    it("warns when payload is not referenced", () => {
+        const content = "# Protocol\n\nMemory Bank in .context/\n";
+        const results = lintProtocolSpec(content);
+        const warn = results.find((r) => r.message.includes("payload"));
+        assert.ok(warn);
+        assert.equal(warn.severity, "warn");
+    });
+    it("warns when Memory Bank is not referenced", () => {
+        const content = "# Protocol\n\nPayload format is XML.\n";
+        const results = lintProtocolSpec(content);
+        const warn = results.find((r) => r.message.includes("Memory Bank"));
+        assert.ok(warn);
+        assert.equal(warn.severity, "warn");
+    });
+});
+describe("lintAgentConfig", () => {
+    it("passes when .context/ is referenced", () => {
+        const content = "# Claude\n\nRead .context/ before acting.\n";
+        const results = lintAgentConfig("CLAUDE.md", content);
+        assert.equal(results.length, 1);
+        assert.equal(results[0].severity, "pass");
+    });
+    it("warns when .context/ is not referenced", () => {
+        const content = "# Claude\n\nJust some instructions.\n";
+        const results = lintAgentConfig("CLAUDE.md", content);
+        assert.equal(results.length, 1);
+        assert.equal(results[0].severity, "warn");
+        assert.ok(results[0].suggestion);
+    });
+});

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

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

package/dist/tests/validate.test.js

@@ -0,0 +1,92 @@
+import { describe, it, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, utimesSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { checkFile, checkStale, checkAgentFile } from "../commands/validate.cmd.js";
+describe("checkFile", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-validate-test-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("returns pass icon when required file exists", () => {
+        writeFileSync(join(tempDir, "exists.md"), "content", "utf-8");
+        const result = checkFile(tempDir, "exists.md", true);
+        assert.ok(result.message.includes("found"));
+    });
+    it("returns fail icon when required file is missing", () => {
+        const result = checkFile(tempDir, "missing.md", true);
+        assert.ok(result.message.includes("missing (required)"));
+    });
+    it("returns warn icon when optional file is missing", () => {
+        const result = checkFile(tempDir, "optional.md", false);
+        assert.ok(result.message.includes("missing (optional)"));
+    });
+    it("returns pass icon when optional file exists", () => {
+        writeFileSync(join(tempDir, "opt-exists.md"), "content", "utf-8");
+        const result = checkFile(tempDir, "opt-exists.md", false);
+        assert.ok(result.message.includes("found"));
+    });
+});
+describe("checkStale", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-stale-test-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("returns null when file does not exist", () => {
+        const result = checkStale(tempDir, "nonexistent.md");
+        assert.equal(result, null);
+    });
+    it("returns null when file is fresh (< 7 days)", () => {
+        writeFileSync(join(tempDir, "fresh.md"), "content", "utf-8");
+        const result = checkStale(tempDir, "fresh.md");
+        assert.equal(result, null);
+    });
+    it("returns warn result when file is stale (> 7 days)", () => {
+        const filePath = join(tempDir, "stale.md");
+        writeFileSync(filePath, "content", "utf-8");
+        // Set mtime to 10 days ago
+        const tenDaysAgo = new Date(Date.now() - 10 * 24 * 60 * 60 * 1000);
+        utimesSync(filePath, tenDaysAgo, tenDaysAgo);
+        const result = checkStale(tempDir, "stale.md");
+        assert.ok(result !== null);
+        assert.ok(result.message.includes("days ago"));
+    });
+});
+describe("checkAgentFile", () => {
+    const tempDir = mkdtempSync(join(tmpdir(), "tocket-agent-test-"));
+    after(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("returns pass when CLAUDE.md exists", () => {
+        const dir = join(tempDir, "with-claude");
+        mkdirSync(dir);
+        writeFileSync(join(dir, "CLAUDE.md"), "# Claude", "utf-8");
+        const result = checkAgentFile(dir);
+        assert.ok(result.message.includes("Agent config found"));
+        assert.ok(result.message.includes("CLAUDE.md"));
+    });
+    it("returns pass when .cursorrules exists", () => {
+        const dir = join(tempDir, "with-cursor");
+        mkdirSync(dir);
+        writeFileSync(join(dir, ".cursorrules"), "rules", "utf-8");
+        const result = checkAgentFile(dir);
+        assert.ok(result.message.includes("Agent config found"));
+        assert.ok(result.message.includes(".cursorrules"));
+    });
+    it("returns warn when no agent files exist", () => {
+        const dir = join(tempDir, "empty");
+        mkdirSync(dir);
+        const result = checkAgentFile(dir);
+        assert.ok(result.message.includes("No agent config file found"));
+    });
+    it("lists multiple agent files when present", () => {
+        const dir = join(tempDir, "multi");
+        mkdirSync(dir);
+        writeFileSync(join(dir, "CLAUDE.md"), "# Claude", "utf-8");
+        writeFileSync(join(dir, "GEMINI.md"), "# Gemini", "utf-8");
+        const result = checkAgentFile(dir);
+        assert.ok(result.message.includes("CLAUDE.md"));
+        assert.ok(result.message.includes("GEMINI.md"));
+    });
+});

package/dist/utils/git.d.ts

@@ -3,4 +3,5 @@ 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 getLastCommitMessage(cwd?: string): string;
 export declare function getCurrentBranch(cwd?: string): string;

package/dist/utils/git.js

@@ -64,6 +64,19 @@ export function getRecentCommitsRaw(n = 5, cwd = process.cwd()) {
         return "_No commits found or not a git repository._";
     }
 }
+export function getLastCommitMessage(cwd = process.cwd()) {
+    if (!isGitRepo(cwd))
+        return "";
+    try {
+        return execSync("git log -1 --pretty=%B", {
+            cwd,
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return "";
+    }
+}
 export function getCurrentBranch(cwd = process.cwd()) {
     if (!isGitRepo(cwd))
         return "";

package/package.json

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