planmode 0.1.5 → 0.2.1

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "planmode",
-  "version": "0.1.5",
+  "version": "0.2.1",
   "description": "The open source package manager for AI plans, rules, and prompts.",
   "type": "module",
   "bin": {
-    "planmode": "./dist/index.js"
+    "planmode": "./dist/index.js",
+    "planmode-mcp": "./dist/mcp.js"
   },
   "scripts": {
     "build": "tsup",
@@ -15,10 +16,12 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.26.0",
     "commander": "^13.1.0",
     "handlebars": "^4.7.8",
     "simple-git": "^3.27.0",
-    "yaml": "^2.7.0"
+    "yaml": "^2.7.0",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^22.13.0",

package/src/commands/doctor.ts

@@ -0,0 +1,43 @@
+import { Command } from "commander";
+import { runDoctor } from "../lib/doctor.js";
+import { logger } from "../lib/logger.js";
+
+export const doctorCommand = new Command("doctor")
+  .description("Check project health: verify installed packages, imports, and file integrity")
+  .action(() => {
+    const result = runDoctor();
+
+    logger.blank();
+    logger.bold(`Checked ${result.packagesChecked} package(s)`);
+    logger.blank();
+
+    if (result.issues.length === 0) {
+      logger.success("Everything looks good. No issues found.");
+      logger.blank();
+      return;
+    }
+
+    const errors = result.issues.filter((i) => i.severity === "error");
+    const warnings = result.issues.filter((i) => i.severity === "warning");
+
+    for (const issue of errors) {
+      logger.error(issue.message);
+      if (issue.fix) logger.dim(`  Fix: ${issue.fix}`);
+    }
+    for (const issue of warnings) {
+      logger.warn(issue.message);
+      if (issue.fix) logger.dim(`  Fix: ${issue.fix}`);
+    }
+
+    logger.blank();
+    if (errors.length > 0) {
+      logger.error(`${errors.length} error(s), ${warnings.length} warning(s)`);
+    } else {
+      logger.warn(`${warnings.length} warning(s)`);
+    }
+    logger.blank();
+
+    if (errors.length > 0) {
+      process.exit(1);
+    }
+  });

package/src/commands/init.ts

@@ -1,8 +1,6 @@
 import { Command } from "commander";
-import fs from "node:fs";
-import path from "node:path";
-import { stringify } from "yaml";
 import { logger } from "../lib/logger.js";
+import { createPackage } from "../lib/init.js";
 import type { PackageType, Category } from "../types/index.js";
 
 async function prompt(question: string): Promise<string> {
@@ -35,48 +33,31 @@ export const initCommand = new Command("init")
 
       const description = await prompt("Description: ");
       const author = await prompt("Author (GitHub username): ");
-      const license = await prompt("License [MIT]: ") || "MIT";
+      const license = (await prompt("License [MIT]: ")) || "MIT";
       const tagsInput = await prompt("Tags (comma-separated): ");
-      const tags = tagsInput ? tagsInput.split(",").map((t) => t.trim().toLowerCase()) : [];
-      const category = (await prompt("Category (frontend/backend/devops/database/testing/mobile/ai-ml/security/other) [other]: ") || "other") as Category;
+      const tags = tagsInput
+        ? tagsInput.split(",").map((t) => t.trim().toLowerCase())
+        : [];
+      const category =
+        ((await prompt(
+          "Category (frontend/backend/devops/database/testing/mobile/ai-ml/security/other) [other]: ",
+        )) || "other") as Category;
 
-      // Build manifest
-      const manifest: Record<string, unknown> = {
+      const result = createPackage({
         name,
-        version: "1.0.0",
         type,
         description,
         author,
         license,
-      };
-
-      if (tags.length > 0) manifest["tags"] = tags;
-      manifest["category"] = category;
-
-      const contentFile = `${type}.md`;
-      manifest["content_file"] = contentFile;
-
-      // Write planmode.yaml
-      const yamlContent = stringify(manifest);
-      fs.writeFileSync(path.join(process.cwd(), "planmode.yaml"), yamlContent, "utf-8");
-      logger.success("Created planmode.yaml");
-
-      // Write stub content file
-      const stubs: Record<string, string> = {
-        plan: `# ${name}\n\n1. First step\n2. Second step\n3. Third step\n`,
-        rule: `- Rule one\n- Rule two\n- Rule three\n`,
-        prompt: `Write your prompt here.\n\nUse {{variable_name}} for template variables.\n`,
-      };
-
-      fs.writeFileSync(
-        path.join(process.cwd(), contentFile),
-        stubs[type] ?? stubs["plan"]!,
-        "utf-8",
-      );
-      logger.success(`Created ${contentFile}`);
+        tags,
+        category,
+      });
 
+      logger.success(`Created ${result.files.join(", ")}`);
       logger.blank();
-      logger.info(`Edit ${contentFile}, then run \`planmode publish\` when ready.`);
+      logger.info(
+        `Edit ${result.files[1]}, then run \`planmode publish\` when ready.`,
+      );
       logger.blank();
     } catch (err) {
       logger.error((err as Error).message);

package/src/commands/mcp.ts

@@ -0,0 +1,39 @@
+import { Command } from "commander";
+import { execSync } from "node:child_process";
+import { logger } from "../lib/logger.js";
+
+export const mcpCommand = new Command("mcp")
+  .description("Manage MCP server registration with Claude Code");
+
+mcpCommand
+  .command("setup")
+  .description("Register the planmode MCP server with Claude Code")
+  .action(() => {
+    try {
+      execSync("claude mcp add --transport stdio planmode -- planmode-mcp", {
+        stdio: "inherit",
+      });
+      logger.success("Planmode MCP server registered with Claude Code.");
+      logger.dim("Claude Code can now use planmode tools directly.");
+    } catch (err) {
+      logger.error(
+        "Failed to register MCP server. Make sure Claude Code CLI is installed.",
+      );
+      process.exit(1);
+    }
+  });
+
+mcpCommand
+  .command("remove")
+  .description("Remove the planmode MCP server from Claude Code")
+  .action(() => {
+    try {
+      execSync("claude mcp remove planmode", { stdio: "inherit" });
+      logger.success("Planmode MCP server removed from Claude Code.");
+    } catch (err) {
+      logger.error(
+        "Failed to remove MCP server. Make sure Claude Code CLI is installed.",
+      );
+      process.exit(1);
+    }
+  });

package/src/commands/publish.ts

@@ -1,201 +1,13 @@
 import { Command } from "commander";
-import { readManifest, validateManifest } from "../lib/manifest.js";
-import { getGitHubToken } from "../lib/config.js";
-import { getRemoteUrl, getHeadSha, createTag, pushTag } from "../lib/git.js";
+import { publishPackage } from "../lib/publisher.js";
 import { logger } from "../lib/logger.js";
 
 export const publishCommand = new Command("publish")
   .description("Publish the current directory as a package to the registry")
   .action(async () => {
     try {
-      const cwd = process.cwd();
-
-      // Check auth
-      const token = getGitHubToken();
-      if (!token) {
-        logger.error("Not authenticated. Run `planmode login` first.");
-        process.exit(1);
-      }
-
-      // Read and validate manifest
-      logger.info("Reading planmode.yaml...");
-      const manifest = readManifest(cwd);
-      const errors = validateManifest(manifest, true);
-      if (errors.length > 0) {
-        logger.error("Invalid manifest:");
-        for (const err of errors) {
-          console.log(`  - ${err}`);
-        }
-        process.exit(1);
-      }
-
-      // Check git remote
-      const remoteUrl = await getRemoteUrl(cwd);
-      if (!remoteUrl) {
-        logger.error("No git remote found. Push your code to GitHub first.");
-        process.exit(1);
-      }
-
-      const sha = await getHeadSha(cwd);
-      const tag = `v${manifest.version}`;
-
-      // Create and push tag
-      logger.info(`Creating tag ${tag}...`);
-      try {
-        await createTag(cwd, tag);
-      } catch {
-        logger.dim(`Tag ${tag} already exists, using existing`);
-      }
-
-      try {
-        await pushTag(cwd, tag);
-        logger.success(`Pushed tag ${tag}`);
-      } catch {
-        logger.dim(`Tag ${tag} already pushed`);
-      }
-
-      // Fork registry and create PR via GitHub API
-      logger.info("Submitting to registry...");
-
-      const headers = {
-        Authorization: `Bearer ${token}`,
-        Accept: "application/vnd.github.v3+json",
-        "User-Agent": "planmode-cli",
-        "Content-Type": "application/json",
-      };
-
-      // Fork the registry repo (idempotent)
-      await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
-        method: "POST",
-        headers,
-      });
-
-      // Get authenticated user
-      const userRes = await fetch("https://api.github.com/user", { headers });
-      const user = (await userRes.json()) as { login: string };
-
-      // Create metadata files content
-      const metadataContent = JSON.stringify(
-        {
-          name: manifest.name,
-          description: manifest.description,
-          author: manifest.author,
-          license: manifest.license,
-          repository: remoteUrl
-            .replace(/^https?:\/\//, "")
-            .replace(/\.git$/, ""),
-          category: manifest.category ?? "other",
-          tags: manifest.tags ?? [],
-          type: manifest.type,
-          models: manifest.models ?? [],
-          latest_version: manifest.version,
-          versions: [manifest.version],
-          downloads: 0,
-          created_at: new Date().toISOString(),
-          updated_at: new Date().toISOString(),
-          dependencies: manifest.dependencies,
-          variables: manifest.variables,
-        },
-        null,
-        2,
-      );
-
-      const versionContent = JSON.stringify(
-        {
-          version: manifest.version,
-          published_at: new Date().toISOString(),
-          source: {
-            repository: remoteUrl
-              .replace(/^https?:\/\//, "")
-              .replace(/\.git$/, ""),
-            tag,
-            sha,
-          },
-          files: ["planmode.yaml", manifest.content_file ?? "inline"],
-          content_hash: `sha256:${sha.slice(0, 16)}`,
-        },
-        null,
-        2,
-      );
-
-      // Create branch on fork
-      const branchName = `add-${manifest.name}-${manifest.version}`;
-
-      // Get main branch ref
-      const refRes = await fetch(
-        `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
-        { headers },
-      );
-
-      if (!refRes.ok) {
-        logger.error("Failed to access registry fork. Make sure the fork exists.");
-        process.exit(1);
-      }
-
-      const refData = (await refRes.json()) as { object: { sha: string } };
-      const baseSha = refData.object.sha;
-
-      // Create branch
-      await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          ref: `refs/heads/${branchName}`,
-          sha: baseSha,
-        }),
-      });
-
-      // Create metadata.json
-      await fetch(
-        `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
-        {
-          method: "PUT",
-          headers,
-          body: JSON.stringify({
-            message: `Add ${manifest.name}@${manifest.version}`,
-            content: Buffer.from(metadataContent).toString("base64"),
-            branch: branchName,
-          }),
-        },
-      );
-
-      // Create version file
-      await fetch(
-        `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
-        {
-          method: "PUT",
-          headers,
-          body: JSON.stringify({
-            message: `Add ${manifest.name}@${manifest.version} version metadata`,
-            content: Buffer.from(versionContent).toString("base64"),
-            branch: branchName,
-          }),
-        },
-      );
-
-      // Create PR
-      const prRes = await fetch("https://api.github.com/repos/kaihannonen/planmode.org/pulls", {
-        method: "POST",
-        headers,
-        body: JSON.stringify({
-          title: `Add ${manifest.name}@${manifest.version}`,
-          head: `${user.login}:${branchName}`,
-          base: "main",
-          body: `## New package: ${manifest.name}\n\n- **Type:** ${manifest.type}\n- **Version:** ${manifest.version}\n- **Description:** ${manifest.description}\n- **Author:** ${manifest.author}\n\nSubmitted via \`planmode publish\`.`,
-        }),
-      });
-
-      if (prRes.ok) {
-        const pr = (await prRes.json()) as { html_url: string };
-        logger.blank();
-        logger.success(`Published ${manifest.name}@${manifest.version}`);
-        logger.info(`PR: ${pr.html_url}`);
-      } else {
-        const err = await prRes.text();
-        logger.error(`Failed to create PR: ${err}`);
-        process.exit(1);
-      }
-
+      logger.blank();
+      const result = await publishPackage();
       logger.blank();
     } catch (err) {
       logger.error((err as Error).message);

package/src/commands/record.ts

@@ -0,0 +1,76 @@
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import { startRecordingAsync, stopRecording, isRecording } from "../lib/recorder.js";
+import { logger } from "../lib/logger.js";
+
+export const recordCommand = new Command("record")
+  .description("Record git activity and generate a plan from commits");
+
+recordCommand
+  .command("start")
+  .description("Start recording — saves current HEAD as the starting point")
+  .action(async () => {
+    try {
+      logger.blank();
+      const sha = await startRecordingAsync();
+      logger.success(`Recording started at ${sha.slice(0, 7)}`);
+      logger.dim("Work normally. When done, run `planmode record stop` to generate a plan.");
+      logger.blank();
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });
+
+recordCommand
+  .command("stop")
+  .description("Stop recording and generate a plan from commits since start")
+  .option("--name <name>", "Package name (auto-inferred if not provided)")
+  .option("--author <author>", "Author GitHub username")
+  .option("--dir <dir>", "Output directory for the generated package (default: current directory)")
+  .action(async (options: { name?: string; author?: string; dir?: string }) => {
+    try {
+      logger.blank();
+      logger.info("Analyzing commits...");
+
+      const result = await stopRecording(process.cwd(), {
+        name: options.name,
+        author: options.author,
+      });
+
+      // Write to output directory
+      const outDir = options.dir ?? process.cwd();
+      fs.mkdirSync(outDir, { recursive: true });
+
+      fs.writeFileSync(path.join(outDir, "planmode.yaml"), result.manifestContent, "utf-8");
+      fs.writeFileSync(path.join(outDir, "plan.md"), result.planContent, "utf-8");
+
+      logger.success(`Generated plan from ${result.totalCommits} commit(s) (${result.totalFilesChanged} files changed)`);
+      logger.blank();
+
+      for (let i = 0; i < result.steps.length; i++) {
+        const step = result.steps[i]!;
+        logger.dim(`  ${i + 1}. ${step.title} (${step.filesChanged.length} files)`);
+      }
+
+      logger.blank();
+      logger.success("Created planmode.yaml and plan.md");
+      logger.dim("Edit the generated plan, then run `planmode test` to validate and `planmode publish` when ready.");
+      logger.blank();
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });
+
+recordCommand
+  .command("status")
+  .description("Check if a recording is in progress")
+  .action(() => {
+    if (isRecording()) {
+      logger.info("Recording is in progress. Run `planmode record stop` to generate a plan.");
+    } else {
+      logger.info("No recording in progress.");
+    }
+  });

package/src/commands/snapshot.ts

@@ -0,0 +1,46 @@
+import { Command } from "commander";
+import fs from "node:fs";
+import path from "node:path";
+import { takeSnapshot } from "../lib/snapshot.js";
+import { logger } from "../lib/logger.js";
+
+export const snapshotCommand = new Command("snapshot")
+  .description("Analyze the current project and generate a plan that recreates this setup")
+  .option("--name <name>", "Package name (auto-inferred from project)")
+  .option("--author <author>", "Author GitHub username")
+  .option("--dir <dir>", "Output directory for the generated package (default: current directory)")
+  .action((options: { name?: string; author?: string; dir?: string }) => {
+    try {
+      logger.blank();
+      logger.info("Analyzing project...");
+
+      const result = takeSnapshot(process.cwd(), {
+        name: options.name,
+        author: options.author,
+      });
+
+      // Write to output directory
+      const outDir = options.dir ?? process.cwd();
+      fs.mkdirSync(outDir, { recursive: true });
+
+      fs.writeFileSync(path.join(outDir, "planmode.yaml"), result.manifestContent, "utf-8");
+      fs.writeFileSync(path.join(outDir, "plan.md"), result.planContent, "utf-8");
+
+      logger.blank();
+      logger.success(`Snapshot: ${result.data.name}`);
+      if (result.data.framework) {
+        logger.dim(`  Framework: ${result.data.framework}`);
+      }
+      logger.dim(`  Dependencies: ${Object.keys(result.data.dependencies).length}`);
+      logger.dim(`  Dev dependencies: ${Object.keys(result.data.devDependencies).length}`);
+      logger.dim(`  Tools detected: ${result.data.detectedTools.map((t) => t.name).join(", ") || "none"}`);
+
+      logger.blank();
+      logger.success("Created planmode.yaml and plan.md");
+      logger.dim("Edit the generated plan, then run `planmode test` to validate and `planmode publish` when ready.");
+      logger.blank();
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });

package/src/commands/test.ts

@@ -0,0 +1,45 @@
+import { Command } from "commander";
+import { testPackage } from "../lib/tester.js";
+import { logger } from "../lib/logger.js";
+
+export const testCommand = new Command("test")
+  .description("Test the current package before publishing: validate manifest, render templates, check dependencies")
+  .action(async () => {
+    try {
+      logger.blank();
+      logger.bold("Testing package...");
+      logger.blank();
+
+      const result = await testPackage();
+
+      for (const check of result.checks) {
+        if (check.passed) {
+          logger.success(check.name);
+        } else {
+          const issue = result.issues.find((i) => i.check === check.name);
+          if (issue?.severity === "error") {
+            logger.error(`${check.name}: ${issue.message}`);
+          } else if (issue) {
+            logger.warn(`${check.name}: ${issue.message}`);
+          }
+        }
+      }
+
+      logger.blank();
+      if (result.passed) {
+        logger.success(`All checks passed. Ready to publish.`);
+      } else {
+        const errors = result.issues.filter((i) => i.severity === "error");
+        const warnings = result.issues.filter((i) => i.severity === "warning");
+        logger.error(`${errors.length} error(s), ${warnings.length} warning(s). Fix errors before publishing.`);
+      }
+      logger.blank();
+
+      if (!result.passed) {
+        process.exit(1);
+      }
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });

package/src/index.ts

@@ -9,13 +9,18 @@ import { listCommand } from "./commands/list.js";
 import { infoCommand } from "./commands/info.js";
 import { initCommand } from "./commands/init.js";
 import { loginCommand } from "./commands/login.js";
+import { mcpCommand } from "./commands/mcp.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { testCommand } from "./commands/test.js";
+import { recordCommand } from "./commands/record.js";
+import { snapshotCommand } from "./commands/snapshot.js";
 
 const program = new Command();
 
 program
   .name("planmode")
   .description("The open source package manager for AI plans, rules, and prompts.")
-  .version("0.1.5");
+  .version("0.2.1");
 
 program.addCommand(installCommand);
 program.addCommand(uninstallCommand);
@@ -27,5 +32,10 @@ program.addCommand(listCommand);
 program.addCommand(infoCommand);
 program.addCommand(initCommand);
 program.addCommand(loginCommand);
+program.addCommand(mcpCommand);
+program.addCommand(doctorCommand);
+program.addCommand(testCommand);
+program.addCommand(recordCommand);
+program.addCommand(snapshotCommand);
 
 program.parse();