planmode 0.1.0

package/src/commands/update.ts

@@ -0,0 +1,49 @@
+import { Command } from "commander";
+import { updatePackage } from "../lib/installer.js";
+import { readLockfile } from "../lib/lockfile.js";
+import { logger } from "../lib/logger.js";
+
+export const updateCommand = new Command("update")
+  .description("Update installed packages to latest compatible versions")
+  .argument("[package]", "Package name (omit to update all)")
+  .action(async (packageName?: string) => {
+    try {
+      logger.blank();
+
+      if (packageName) {
+        const updated = await updatePackage(packageName);
+        if (!updated) {
+          logger.info("Already up to date.");
+        }
+      } else {
+        const lockfile = readLockfile();
+        const names = Object.keys(lockfile.packages);
+
+        if (names.length === 0) {
+          logger.info("No packages installed.");
+          return;
+        }
+
+        let updatedCount = 0;
+        for (const name of names) {
+          try {
+            const updated = await updatePackage(name);
+            if (updated) updatedCount++;
+          } catch (err) {
+            logger.warn(`Failed to update ${name}: ${(err as Error).message}`);
+          }
+        }
+
+        if (updatedCount === 0) {
+          logger.info("All packages are up to date.");
+        } else {
+          logger.success(`Updated ${updatedCount} package${updatedCount > 1 ? "s" : ""}.`);
+        }
+      }
+
+      logger.blank();
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });

package/src/index.ts

@@ -0,0 +1,31 @@
+import { Command } from "commander";
+import { installCommand } from "./commands/install.js";
+import { uninstallCommand } from "./commands/uninstall.js";
+import { searchCommand } from "./commands/search.js";
+import { runCommand } from "./commands/run.js";
+import { publishCommand } from "./commands/publish.js";
+import { updateCommand } from "./commands/update.js";
+import { listCommand } from "./commands/list.js";
+import { infoCommand } from "./commands/info.js";
+import { initCommand } from "./commands/init.js";
+import { loginCommand } from "./commands/login.js";
+
+const program = new Command();
+
+program
+  .name("planmode")
+  .description("The open source package manager for AI plans, rules, and prompts.")
+  .version("0.1.0");
+
+program.addCommand(installCommand);
+program.addCommand(uninstallCommand);
+program.addCommand(searchCommand);
+program.addCommand(runCommand);
+program.addCommand(publishCommand);
+program.addCommand(updateCommand);
+program.addCommand(listCommand);
+program.addCommand(infoCommand);
+program.addCommand(initCommand);
+program.addCommand(loginCommand);
+
+program.parse();

package/src/lib/claude-md.ts

@@ -0,0 +1,74 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const CLAUDE_MD = "CLAUDE.md";
+const PLANMODE_SECTION = "# Planmode";
+
+export function getClaudeMdPath(projectDir: string = process.cwd()): string {
+  return path.join(projectDir, CLAUDE_MD);
+}
+
+export function addImport(
+  planName: string,
+  projectDir: string = process.cwd(),
+): void {
+  const claudeMdPath = getClaudeMdPath(projectDir);
+  const importLine = `- @plans/${planName}.md`;
+
+  if (!fs.existsSync(claudeMdPath)) {
+    // Create CLAUDE.md with the import
+    const content = `${PLANMODE_SECTION}\n${importLine}\n`;
+    fs.writeFileSync(claudeMdPath, content, "utf-8");
+    return;
+  }
+
+  const content = fs.readFileSync(claudeMdPath, "utf-8");
+
+  // Check if import already exists
+  if (content.includes(importLine)) {
+    return;
+  }
+
+  // Find or create Planmode section
+  if (content.includes(PLANMODE_SECTION)) {
+    // Append under existing section
+    const updated = content.replace(PLANMODE_SECTION, `${PLANMODE_SECTION}\n${importLine}`);
+    fs.writeFileSync(claudeMdPath, updated, "utf-8");
+  } else {
+    // Append new section at the end
+    const separator = content.endsWith("\n") ? "\n" : "\n\n";
+    const updated = content + separator + `${PLANMODE_SECTION}\n${importLine}\n`;
+    fs.writeFileSync(claudeMdPath, updated, "utf-8");
+  }
+}
+
+export function removeImport(
+  planName: string,
+  projectDir: string = process.cwd(),
+): void {
+  const claudeMdPath = getClaudeMdPath(projectDir);
+  if (!fs.existsSync(claudeMdPath)) return;
+
+  const content = fs.readFileSync(claudeMdPath, "utf-8");
+  const importLine = `- @plans/${planName}.md`;
+  const updated = content
+    .split("\n")
+    .filter((line) => line.trim() !== importLine)
+    .join("\n");
+
+  fs.writeFileSync(claudeMdPath, updated, "utf-8");
+}
+
+export function listImports(projectDir: string = process.cwd()): string[] {
+  const claudeMdPath = getClaudeMdPath(projectDir);
+  if (!fs.existsSync(claudeMdPath)) return [];
+
+  const content = fs.readFileSync(claudeMdPath, "utf-8");
+  const importRegex = /^-\s*@plans\/(.+)\.md$/gm;
+  const imports: string[] = [];
+  let match;
+  while ((match = importRegex.exec(content)) !== null) {
+    imports.push(match[1]!);
+  }
+  return imports;
+}

package/src/lib/config.ts

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { parse, stringify } from "yaml";
+import type { PlanmodeConfig } from "../types/index.js";
+
+const CONFIG_DIR = path.join(os.homedir(), ".planmode");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config");
+const CACHE_DIR = path.join(CONFIG_DIR, "cache");
+
+export function getConfigDir(): string {
+  return CONFIG_DIR;
+}
+
+export function getCacheDir(): string {
+  const config = readConfig();
+  return config.cache?.dir ?? CACHE_DIR;
+}
+
+export function getCacheTTL(): number {
+  const config = readConfig();
+  return config.cache?.ttl ?? 3600;
+}
+
+export function readConfig(): PlanmodeConfig {
+  try {
+    const raw = fs.readFileSync(CONFIG_PATH, "utf-8");
+    return (parse(raw) as PlanmodeConfig) ?? {};
+  } catch {
+    return {};
+  }
+}
+
+export function writeConfig(config: PlanmodeConfig): void {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_PATH, stringify(config), "utf-8");
+}
+
+export function getGitHubToken(): string | undefined {
+  const envToken = process.env["PLANMODE_GITHUB_TOKEN"];
+  if (envToken) return envToken;
+  const config = readConfig();
+  return config.auth?.github_token;
+}
+
+export function setGitHubToken(token: string): void {
+  const config = readConfig();
+  config.auth = { ...config.auth, github_token: token };
+  writeConfig(config);
+}
+
+export function getRegistries(): Record<string, string> {
+  const config = readConfig();
+  return {
+    default: "github.com/planmode/registry",
+    ...config.registries,
+  };
+}
+
+export function addRegistry(name: string, url: string): void {
+  const config = readConfig();
+  config.registries = { ...config.registries, [name]: url };
+  writeConfig(config);
+}

package/src/lib/git.ts

@@ -0,0 +1,121 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { simpleGit } from "simple-git";
+import { getGitHubToken } from "./config.js";
+
+function repoCloneUrl(repoUrl: string): string {
+  const token = getGitHubToken();
+  // Convert github.com/org/repo to https clone URL
+  const match = repoUrl.match(/^github\.com\/(.+)$/);
+  if (!match) return `https://${repoUrl}.git`;
+  if (token) {
+    return `https://${token}@github.com/${match[1]}.git`;
+  }
+  return `https://github.com/${match[1]}.git`;
+}
+
+export async function cloneAtTag(
+  repoUrl: string,
+  tag: string,
+  targetDir: string,
+): Promise<void> {
+  const cloneUrl = repoCloneUrl(repoUrl);
+  const git = simpleGit();
+  await git.clone(cloneUrl, targetDir, [
+    "--depth",
+    "1",
+    "--branch",
+    tag,
+    "--single-branch",
+  ]);
+}
+
+export async function fetchFileAtTag(
+  repoUrl: string,
+  tag: string,
+  filePath: string,
+): Promise<string> {
+  // Use GitHub raw content API for efficiency
+  const match = repoUrl.match(/^github\.com\/([^/]+)\/([^/]+)$/);
+  if (match) {
+    const token = getGitHubToken();
+    const rawUrl = `https://raw.githubusercontent.com/${match[1]}/${match[2]}/${tag}/${filePath}`;
+    const headers: Record<string, string> = { "User-Agent": "planmode-cli" };
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+
+    const response = await fetch(rawUrl, { headers });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${filePath} from ${repoUrl}@${tag}: ${response.status}`);
+    }
+    return response.text();
+  }
+
+  // Fallback: clone and read
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "planmode-"));
+  try {
+    await cloneAtTag(repoUrl, tag, tmpDir);
+    const fullPath = path.join(tmpDir, filePath);
+    if (!fs.existsSync(fullPath)) {
+      throw new Error(`File not found: ${filePath} in ${repoUrl}@${tag}`);
+    }
+    return fs.readFileSync(fullPath, "utf-8");
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+export async function fetchPackageFiles(
+  repoUrl: string,
+  tag: string,
+  files: string[],
+): Promise<Record<string, string>> {
+  const result: Record<string, string> = {};
+  for (const file of files) {
+    result[file] = await fetchFileAtTag(repoUrl, tag, file);
+  }
+  return result;
+}
+
+export async function getLatestTag(repoUrl: string): Promise<string | null> {
+  const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "planmode-tags-"));
+  try {
+    const cloneUrl = repoCloneUrl(repoUrl);
+    const git = simpleGit();
+    const result = await git.listRemote(["--tags", "--sort=-v:refname", cloneUrl]);
+    const lines = result.trim().split("\n");
+    if (lines.length === 0 || !lines[0]) return null;
+
+    const match = lines[0].match(/refs\/tags\/(.+)$/);
+    return match ? match[1]! : null;
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  }
+}
+
+export async function createTag(dir: string, tag: string): Promise<void> {
+  const git = simpleGit(dir);
+  await git.addTag(tag);
+}
+
+export async function pushTag(dir: string, tag: string): Promise<void> {
+  const git = simpleGit(dir);
+  await git.push("origin", tag);
+}
+
+export async function getRemoteUrl(dir: string): Promise<string | null> {
+  try {
+    const git = simpleGit(dir);
+    const remotes = await git.getRemotes(true);
+    const origin = remotes.find((r) => r.name === "origin");
+    return origin?.refs?.fetch ?? null;
+  } catch {
+    return null;
+  }
+}
+
+export async function getHeadSha(dir: string): Promise<string> {
+  const git = simpleGit(dir);
+  const log = await git.log({ n: 1 });
+  return log.latest?.hash ?? "";
+}

package/src/lib/installer.ts

@@ -0,0 +1,204 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import type { PackageManifest, PackageType, LockfileEntry, ResolvedPackage } from "../types/index.js";
+import { resolveVersion, parseDepString } from "./resolver.js";
+import { fetchVersionMetadata, fetchPackageMetadata } from "./registry.js";
+import { fetchFileAtTag } from "./git.js";
+import { addToLockfile, removeFromLockfile, getLockedVersion } from "./lockfile.js";
+import { addImport, removeImport } from "./claude-md.js";
+import { parseManifest, readPackageContent } from "./manifest.js";
+import { renderTemplate, collectVariableValues } from "./template.js";
+import { logger } from "./logger.js";
+
+function getInstallDir(type: PackageType): string {
+  switch (type) {
+    case "plan":
+      return "plans";
+    case "rule":
+      return path.join(".claude", "rules");
+    case "prompt":
+      return "prompts";
+  }
+}
+
+function getInstallPath(name: string, type: PackageType): string {
+  return path.join(getInstallDir(type), `${name}.md`);
+}
+
+function contentHash(content: string): string {
+  return `sha256:${crypto.createHash("sha256").update(content).digest("hex")}`;
+}
+
+export interface InstallOptions {
+  version?: string;
+  forceRule?: boolean;
+  noInput?: boolean;
+  variables?: Record<string, string>;
+  projectDir?: string;
+}
+
+export async function installPackage(
+  packageName: string,
+  options: InstallOptions = {},
+): Promise<void> {
+  const projectDir = options.projectDir ?? process.cwd();
+
+  // Check lockfile first
+  const locked = getLockedVersion(packageName, projectDir);
+  if (locked && !options.version) {
+    logger.dim(`${packageName}@${locked.version} already installed`);
+    return;
+  }
+
+  // Resolve version
+  logger.info(`Resolving ${packageName}...`);
+  const { version, metadata } = await resolveVersion(packageName, options.version);
+
+  // Fetch version metadata
+  const versionMeta = await fetchVersionMetadata(packageName, version);
+
+  // Fetch manifest
+  logger.info(`Fetching ${packageName}@${version}...`);
+  const manifestRaw = await fetchFileAtTag(
+    versionMeta.source.repository,
+    versionMeta.source.tag,
+    "planmode.yaml",
+  );
+  const manifest = parseManifest(manifestRaw);
+
+  // Fetch content
+  let content: string;
+  if (manifest.content) {
+    content = manifest.content;
+  } else if (manifest.content_file) {
+    content = await fetchFileAtTag(
+      versionMeta.source.repository,
+      versionMeta.source.tag,
+      manifest.content_file,
+    );
+  } else {
+    throw new Error("Package has no content or content_file");
+  }
+
+  // Process variables if templated
+  if (manifest.variables && Object.keys(manifest.variables).length > 0) {
+    const provided = options.variables ?? {};
+    if (options.noInput) {
+      const values = collectVariableValues(manifest.variables, provided);
+      content = renderTemplate(content, values);
+    } else {
+      // Use defaults for non-provided values
+      const values = collectVariableValues(manifest.variables, provided);
+      content = renderTemplate(content, values);
+    }
+  }
+
+  // Determine type (--rule overrides)
+  const type = options.forceRule ? "rule" : manifest.type;
+  const installPath = getInstallPath(packageName, type);
+  const fullPath = path.join(projectDir, installPath);
+
+  // Check for conflicts
+  if (fs.existsSync(fullPath)) {
+    const existingContent = fs.readFileSync(fullPath, "utf-8");
+    const existingHash = contentHash(existingContent);
+    const newHash = contentHash(content);
+    if (existingHash === newHash) {
+      logger.dim(`${packageName} already installed (identical content)`);
+    } else {
+      logger.warn(`Overwriting ${installPath} with new content`);
+    }
+  }
+
+  // Create directory and write file
+  fs.mkdirSync(path.dirname(fullPath), { recursive: true });
+  fs.writeFileSync(fullPath, content, "utf-8");
+  logger.success(`Installed ${packageName}@${version} → ${installPath}`);
+
+  // Update CLAUDE.md for plans
+  if (type === "plan") {
+    addImport(packageName, projectDir);
+    logger.dim(`Added @import to CLAUDE.md`);
+  }
+
+  // Update lockfile
+  const hash = contentHash(content);
+  const entry: LockfileEntry = {
+    version,
+    type,
+    source: versionMeta.source.repository,
+    tag: versionMeta.source.tag,
+    sha: versionMeta.source.sha,
+    content_hash: hash,
+    installed_to: installPath,
+  };
+  addToLockfile(packageName, entry, projectDir);
+
+  // Install dependencies
+  if (manifest.dependencies) {
+    const deps = [
+      ...(manifest.dependencies.rules ?? []).map((d) => ({ dep: d, type: "rule" as const })),
+      ...(manifest.dependencies.plans ?? []).map((d) => ({ dep: d, type: "plan" as const })),
+    ];
+
+    for (const { dep } of deps) {
+      const { name, range } = parseDepString(dep);
+      await installPackage(name, {
+        version: range === "*" ? undefined : range,
+        projectDir,
+        noInput: options.noInput,
+      });
+    }
+  }
+}
+
+export async function uninstallPackage(
+  packageName: string,
+  projectDir: string = process.cwd(),
+): Promise<void> {
+  const locked = getLockedVersion(packageName, projectDir);
+  if (!locked) {
+    throw new Error(`Package '${packageName}' is not installed.`);
+  }
+
+  // Remove file
+  const fullPath = path.join(projectDir, locked.installed_to);
+  if (fs.existsSync(fullPath)) {
+    fs.unlinkSync(fullPath);
+    logger.success(`Removed ${locked.installed_to}`);
+  }
+
+  // Remove import from CLAUDE.md
+  if (locked.type === "plan") {
+    removeImport(packageName, projectDir);
+    logger.dim(`Removed @import from CLAUDE.md`);
+  }
+
+  // Update lockfile
+  removeFromLockfile(packageName, projectDir);
+  logger.success(`Uninstalled ${packageName}`);
+}
+
+export async function updatePackage(
+  packageName: string,
+  projectDir: string = process.cwd(),
+): Promise<boolean> {
+  const locked = getLockedVersion(packageName, projectDir);
+  if (!locked) {
+    throw new Error(`Package '${packageName}' is not installed.`);
+  }
+
+  const { version, metadata } = await resolveVersion(packageName);
+  if (version === locked.version) {
+    logger.dim(`${packageName}@${version} is already up to date`);
+    return false;
+  }
+
+  logger.info(`Updating ${packageName}: ${locked.version} → ${version}`);
+
+  // Uninstall old, install new
+  await uninstallPackage(packageName, projectDir);
+  await installPackage(packageName, { version, projectDir });
+  return true;
+}

package/src/lib/lockfile.ts

@@ -0,0 +1,63 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse, stringify } from "yaml";
+import type { Lockfile, LockfileEntry } from "../types/index.js";
+
+const LOCKFILE_NAME = "planmode.lock";
+
+export function getLockfilePath(projectDir: string = process.cwd()): string {
+  return path.join(projectDir, LOCKFILE_NAME);
+}
+
+export function readLockfile(projectDir: string = process.cwd()): Lockfile {
+  const lockfilePath = getLockfilePath(projectDir);
+  try {
+    const raw = fs.readFileSync(lockfilePath, "utf-8");
+    const data = parse(raw) as Lockfile;
+    return data ?? { lockfile_version: 1, packages: {} };
+  } catch {
+    return { lockfile_version: 1, packages: {} };
+  }
+}
+
+export function writeLockfile(lockfile: Lockfile, projectDir: string = process.cwd()): void {
+  const lockfilePath = getLockfilePath(projectDir);
+  fs.writeFileSync(lockfilePath, stringify(lockfile), "utf-8");
+}
+
+export function addToLockfile(
+  packageName: string,
+  entry: LockfileEntry,
+  projectDir: string = process.cwd(),
+): void {
+  const lockfile = readLockfile(projectDir);
+  lockfile.packages[packageName] = entry;
+  writeLockfile(lockfile, projectDir);
+}
+
+export function removeFromLockfile(
+  packageName: string,
+  projectDir: string = process.cwd(),
+): void {
+  const lockfile = readLockfile(projectDir);
+  delete lockfile.packages[packageName];
+  writeLockfile(lockfile, projectDir);
+}
+
+export function getLockedVersion(
+  packageName: string,
+  projectDir: string = process.cwd(),
+): LockfileEntry | undefined {
+  const lockfile = readLockfile(projectDir);
+  return lockfile.packages[packageName];
+}
+
+export function getDependents(
+  packageName: string,
+  projectDir: string = process.cwd(),
+): string[] {
+  // Check which installed packages depend on the given package
+  // This is a simplified check — in a full implementation we'd read manifests
+  const lockfile = readLockfile(projectDir);
+  return Object.keys(lockfile.packages).filter((name) => name !== packageName);
+}

package/src/lib/logger.ts

@@ -0,0 +1,53 @@
+const RESET = "\x1b[0m";
+const RED = "\x1b[31m";
+const GREEN = "\x1b[32m";
+const YELLOW = "\x1b[33m";
+const CYAN = "\x1b[36m";
+const DIM = "\x1b[2m";
+const BOLD = "\x1b[1m";
+
+export const logger = {
+  info(msg: string) {
+    console.log(`${CYAN}info${RESET} ${msg}`);
+  },
+
+  success(msg: string) {
+    console.log(`${GREEN}✓${RESET} ${msg}`);
+  },
+
+  warn(msg: string) {
+    console.log(`${YELLOW}warn${RESET} ${msg}`);
+  },
+
+  error(msg: string) {
+    console.error(`${RED}error${RESET} ${msg}`);
+  },
+
+  dim(msg: string) {
+    console.log(`${DIM}${msg}${RESET}`);
+  },
+
+  bold(msg: string) {
+    console.log(`${BOLD}${msg}${RESET}`);
+  },
+
+  table(headers: string[], rows: string[][]) {
+    const colWidths = headers.map((h, i) =>
+      Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length)),
+    );
+
+    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}`);
+    }
+  },
+
+  blank() {
+    console.log();
+  },
+};