planmode 0.1.5 → 0.2.0

package/src/lib/doctor.ts

@@ -0,0 +1,123 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { readLockfile } from "./lockfile.js";
+import { listImports } from "./claude-md.js";
+
+export interface DiagnosticIssue {
+  severity: "error" | "warning";
+  message: string;
+  fix?: string;
+}
+
+export interface DoctorResult {
+  issues: DiagnosticIssue[];
+  packagesChecked: number;
+  healthy: boolean;
+}
+
+function computeHash(content: string): string {
+  return `sha256:${crypto.createHash("sha256").update(content).digest("hex")}`;
+}
+
+export function runDoctor(projectDir: string = process.cwd()): DoctorResult {
+  const issues: DiagnosticIssue[] = [];
+  const lockfile = readLockfile(projectDir);
+  const entries = Object.entries(lockfile.packages);
+
+  // Check each lockfile entry
+  for (const [name, entry] of entries) {
+    const fullPath = path.join(projectDir, entry.installed_to);
+
+    // File exists?
+    if (!fs.existsSync(fullPath)) {
+      issues.push({
+        severity: "error",
+        message: `Missing file for "${name}": ${entry.installed_to}`,
+        fix: `Run \`planmode install ${name}\` to reinstall`,
+      });
+      continue;
+    }
+
+    // Content hash matches?
+    const content = fs.readFileSync(fullPath, "utf-8");
+    const actualHash = computeHash(content);
+    if (actualHash !== entry.content_hash) {
+      issues.push({
+        severity: "warning",
+        message: `Content hash mismatch for "${name}" at ${entry.installed_to}`,
+        fix: "File was modified locally. Run `planmode update " + name + "` to restore, or ignore if intentional",
+      });
+    }
+  }
+
+  // Check CLAUDE.md imports match installed plans
+  const claudeMdPath = path.join(projectDir, "CLAUDE.md");
+  const imports = listImports(projectDir);
+  const installedPlans = entries
+    .filter(([, entry]) => entry.type === "plan")
+    .map(([name]) => name);
+
+  // Plans in lockfile but missing from CLAUDE.md
+  for (const planName of installedPlans) {
+    if (!imports.includes(planName)) {
+      issues.push({
+        severity: "error",
+        message: `Plan "${planName}" is installed but missing from CLAUDE.md imports`,
+        fix: `Add \`- @plans/${planName}.md\` to the # Planmode section of CLAUDE.md`,
+      });
+    }
+  }
+
+  // Imports in CLAUDE.md that aren't in the lockfile
+  for (const importName of imports) {
+    if (!installedPlans.includes(importName)) {
+      // Check if the file at least exists
+      const filePath = path.join(projectDir, "plans", `${importName}.md`);
+      if (!fs.existsSync(filePath)) {
+        issues.push({
+          severity: "error",
+          message: `CLAUDE.md imports "${importName}" but the file doesn't exist at plans/${importName}.md`,
+          fix: `Run \`planmode install ${importName}\` or remove the import from CLAUDE.md`,
+        });
+      } else {
+        issues.push({
+          severity: "warning",
+          message: `CLAUDE.md imports "${importName}" but it's not tracked in planmode.lock`,
+          fix: "This plan was added manually. No action needed unless you want lockfile tracking.",
+        });
+      }
+    }
+  }
+
+  // Check CLAUDE.md exists if there are plans
+  if (installedPlans.length > 0 && !fs.existsSync(claudeMdPath)) {
+    issues.push({
+      severity: "error",
+      message: "CLAUDE.md is missing but plans are installed",
+      fix: "Run `planmode install <any-plan>` to recreate it, or create it manually with a # Planmode section",
+    });
+  }
+
+  // Check for orphaned files in plans/ that aren't tracked
+  const plansDir = path.join(projectDir, "plans");
+  if (fs.existsSync(plansDir)) {
+    const planFiles = fs.readdirSync(plansDir).filter((f) => f.endsWith(".md"));
+    for (const file of planFiles) {
+      const name = file.replace(/\.md$/, "");
+      if (!lockfile.packages[name]) {
+        issues.push({
+          severity: "warning",
+          message: `Untracked plan file: plans/${file}`,
+          fix: "This file isn't managed by planmode. Ignore if intentional.",
+        });
+      }
+    }
+  }
+
+  return {
+    issues,
+    packagesChecked: entries.length,
+    healthy: issues.filter((i) => i.severity === "error").length === 0,
+  };
+}

package/src/lib/init.ts

@@ -0,0 +1,71 @@
+import fs from "node:fs";
+import path from "node:path";
+import { stringify } from "yaml";
+import type { PackageType, Category } from "../types/index.js";
+import { getPlanTemplate, getRuleTemplate, getPromptTemplate } from "./templates.js";
+
+export interface InitOptions {
+  name: string;
+  type: PackageType;
+  description: string;
+  author: string;
+  license?: string;
+  tags?: string[];
+  category?: Category;
+  projectDir?: string;
+}
+
+export interface InitResult {
+  files: string[];
+  manifestPath: string;
+  contentPath: string;
+}
+
+export function createPackage(options: InitOptions): InitResult {
+  const {
+    name,
+    type,
+    description,
+    author,
+    license = "MIT",
+    tags = [],
+    category = "other",
+    projectDir = process.cwd(),
+  } = options;
+
+  const manifest: Record<string, unknown> = {
+    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);
+  const manifestPath = path.join(projectDir, "planmode.yaml");
+  fs.writeFileSync(manifestPath, yamlContent, "utf-8");
+
+  // Write stub content file
+  const stubs: Record<string, string> = {
+    plan: getPlanTemplate(name),
+    rule: getRuleTemplate(name),
+    prompt: getPromptTemplate(name),
+  };
+
+  const contentPath = path.join(projectDir, contentFile);
+  fs.writeFileSync(contentPath, stubs[type] ?? stubs["plan"]!, "utf-8");
+
+  return {
+    files: ["planmode.yaml", contentFile],
+    manifestPath,
+    contentPath,
+  };
+}

package/src/lib/installer.ts

@@ -113,6 +113,16 @@ export async function installPackage(
     }
   }
 
+  // Verify content hash against registry
+  const computedHash = contentHash(content);
+  if (versionMeta.content_hash && computedHash !== versionMeta.content_hash) {
+    logger.warn(
+      `Content hash mismatch for ${packageName}@${version}. ` +
+      `Expected ${versionMeta.content_hash.slice(0, 20)}..., got ${computedHash.slice(0, 20)}... ` +
+      `The package content may have been modified after review.`,
+    );
+  }
+
   // Create directory and write file
   fs.mkdirSync(path.dirname(fullPath), { recursive: true });
   fs.writeFileSync(fullPath, content, "utf-8");
@@ -122,7 +132,16 @@ export async function installPackage(
   // Update CLAUDE.md for plans
   if (type === "plan") {
     addImport(packageName, projectDir);
-    logger.dim(`Added @import to CLAUDE.md`);
+    logger.dim(`Added @plans/${packageName}.md to CLAUDE.md`);
+    logger.dim(`Claude Code will automatically see this plan in your next conversation.`);
+  }
+
+  if (type === "rule") {
+    logger.dim(`Rule is active — Claude Code auto-loads all files in .claude/rules/.`);
+  }
+
+  if (type === "prompt") {
+    logger.dim(`Run it with: planmode run ${packageName}`);
   }
 
   // Update lockfile

package/src/lib/logger.ts

@@ -6,29 +6,80 @@ const CYAN = "\x1b[36m";
 const DIM = "\x1b[2m";
 const BOLD = "\x1b[1m";
 
+function stripAnsi(str: string): string {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+let capturing = false;
+let captured: string[] = [];
+
 export const logger = {
+  capture() {
+    capturing = true;
+    captured = [];
+  },
+
+  flush(): string[] {
+    const messages = captured;
+    captured = [];
+    capturing = false;
+    return messages;
+  },
+
+  isCapturing(): boolean {
+    return capturing;
+  },
+
   info(msg: string) {
-    console.log(`${CYAN}info${RESET} ${msg}`);
+    const text = `info ${msg}`;
+    if (capturing) {
+      captured.push(stripAnsi(text));
+    } else {
+      console.log(`${CYAN}info${RESET} ${msg}`);
+    }
   },
 
   success(msg: string) {
-    console.log(`${GREEN}✓${RESET} ${msg}`);
+    const text = `✓ ${msg}`;
+    if (capturing) {
+      captured.push(stripAnsi(text));
+    } else {
+      console.log(`${GREEN}✓${RESET} ${msg}`);
+    }
   },
 
   warn(msg: string) {
-    console.log(`${YELLOW}warn${RESET} ${msg}`);
+    const text = `warn ${msg}`;
+    if (capturing) {
+      captured.push(stripAnsi(text));
+    } else {
+      console.log(`${YELLOW}warn${RESET} ${msg}`);
+    }
   },
 
   error(msg: string) {
-    console.error(`${RED}error${RESET} ${msg}`);
+    const text = `error ${msg}`;
+    if (capturing) {
+      captured.push(stripAnsi(text));
+    } else {
+      console.error(`${RED}error${RESET} ${msg}`);
+    }
   },
 
   dim(msg: string) {
-    console.log(`${DIM}${msg}${RESET}`);
+    if (capturing) {
+      captured.push(msg);
+    } else {
+      console.log(`${DIM}${msg}${RESET}`);
+    }
   },
 
   bold(msg: string) {
-    console.log(`${BOLD}${msg}${RESET}`);
+    if (capturing) {
+      captured.push(msg);
+    } else {
+      console.log(`${BOLD}${msg}${RESET}`);
+    }
   },
 
   table(headers: string[], rows: string[][]) {
@@ -39,15 +90,27 @@ export const logger = {
     const header = headers
       .map((h, i) => h.toUpperCase().padEnd(colWidths[i]!))
       .join("  ");
-    console.log(`  ${DIM}${header}${RESET}`);
 
-    for (const row of rows) {
-      const line = row.map((cell, i) => cell.padEnd(colWidths[i]!)).join("  ");
-      console.log(`  ${line}`);
+    if (capturing) {
+      captured.push(`  ${header}`);
+      for (const row of rows) {
+        const line = row.map((cell, i) => cell.padEnd(colWidths[i]!)).join("  ");
+        captured.push(`  ${line}`);
+      }
+    } else {
+      console.log(`  ${DIM}${header}${RESET}`);
+      for (const row of rows) {
+        const line = row.map((cell, i) => cell.padEnd(colWidths[i]!)).join("  ");
+        console.log(`  ${line}`);
+      }
     }
   },
 
   blank() {
-    console.log();
+    if (capturing) {
+      captured.push("");
+    } else {
+      console.log();
+    }
   },
 };

package/src/lib/publisher.ts

@@ -0,0 +1,203 @@
+import { readManifest, validateManifest } from "./manifest.js";
+import { getGitHubToken } from "./config.js";
+import { getRemoteUrl, getHeadSha, createTag, pushTag } from "./git.js";
+import { logger } from "./logger.js";
+
+export interface PublishOptions {
+  projectDir?: string;
+  token?: string;
+}
+
+export interface PublishResult {
+  prUrl: string;
+  packageName: string;
+  version: string;
+}
+
+export async function publishPackage(options: PublishOptions = {}): Promise<PublishResult> {
+  const cwd = options.projectDir ?? process.cwd();
+
+  // Check auth
+  const token = options.token ?? getGitHubToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run `planmode login` first.");
+  }
+
+  // Read and validate manifest
+  logger.info("Reading planmode.yaml...");
+  const manifest = readManifest(cwd);
+  const errors = validateManifest(manifest, true);
+  if (errors.length > 0) {
+    throw new Error(`Invalid manifest:\n${errors.map((e) => `  - ${e}`).join("\n")}`);
+  }
+
+  // Check git remote
+  const remoteUrl = await getRemoteUrl(cwd);
+  if (!remoteUrl) {
+    throw new Error("No git remote found. Push your code to GitHub first.");
+  }
+
+  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 });
+  if (!userRes.ok) {
+    throw new Error("Failed to authenticate with GitHub. Check your token.");
+  }
+  const user = (await userRes.json()) as { login: string };
+
+  // Create metadata files content
+  const repoPath = remoteUrl.replace(/^https?:\/\//, "").replace(/\.git$/, "");
+
+  const metadataContent = JSON.stringify(
+    {
+      name: manifest.name,
+      description: manifest.description,
+      author: manifest.author,
+      license: manifest.license,
+      repository: repoPath,
+      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: repoPath,
+        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) {
+    throw new Error("Failed to access registry fork. Make sure the fork exists.");
+  }
+
+  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 err = await prRes.text();
+    throw new Error(`Failed to create PR: ${err}`);
+  }
+
+  const pr = (await prRes.json()) as { html_url: string };
+  logger.success(`Published ${manifest.name}@${manifest.version}`);
+  logger.info(`PR: ${pr.html_url}`);
+
+  return {
+    prUrl: pr.html_url,
+    packageName: manifest.name,
+    version: manifest.version,
+  };
+}