@pedrocivita/tocket 1.1.0 → 1.2.0

package/dist/commands/init.cmd.js

@@ -1,31 +1,171 @@
 import { input } from "@inquirer/prompts";
-import { mkdir, writeFile } from "node:fs/promises";
+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 { 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");
+        const cwd = process.cwd();
+        const { stack, detectedName, detectedDescription } = await detectStack(cwd);
+        const hasDetection = Boolean(stack.language);
+        if (hasDetection) {
+            console.log("\n  Auto-detected stack from package.json:");
+            if (stack.language)
+                console.log(`    Language:  ${stack.language}`);
+            if (stack.runtime)
+                console.log(`    Runtime:   ${stack.runtime}`);
+            if (stack.build)
+                console.log(`    Build:     ${stack.build}`);
+            if (stack.framework)
+                console.log(`    Framework: ${stack.framework}`);
+            if (stack.extras.length)
+                console.log(`    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);
             await writeFile(fullPath, content, "utf-8");
             console.log(`  created ${filePath}`);
         }
-        console.log(`\nAgentic workspace initialized for ${projectName}! Ready to launch.`);
+        console.log(`\nAgentic workspace initialized for ${projectName}!${hasDetection ? " Stack pre-populated from package.json." : ""} Ready to launch.`);
     });
 }

package/dist/index.js

@@ -8,7 +8,7 @@ const program = new Command();
 program
     .name("tocket")
     .description("The Context Engineering Framework for Multi-Agent Workspaces")
-    .version("1.1.0");
+    .version("1.2.0");
 registerInitCommand(program);
 registerGenerateCommand(program);
 registerSyncCommand(program);

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

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