planmode 0.2.2 → 0.3.0

package/dist/mcp.js

@@ -35,33 +35,33 @@ var logger = {
     return capturing;
   },
   info(msg) {
-    const text = `info ${msg}`;
+    const text2 = `info ${msg}`;
     if (capturing) {
-      captured.push(stripAnsi(text));
+      captured.push(stripAnsi(text2));
     } else {
       console.log(`${CYAN}info${RESET} ${msg}`);
     }
   },
   success(msg) {
-    const text = `\u2713 ${msg}`;
+    const text2 = `\u2713 ${msg}`;
     if (capturing) {
-      captured.push(stripAnsi(text));
+      captured.push(stripAnsi(text2));
     } else {
       console.log(`${GREEN}\u2713${RESET} ${msg}`);
     }
   },
   warn(msg) {
-    const text = `warn ${msg}`;
+    const text2 = `warn ${msg}`;
     if (capturing) {
-      captured.push(stripAnsi(text));
+      captured.push(stripAnsi(text2));
     } else {
       console.log(`${YELLOW}warn${RESET} ${msg}`);
     }
   },
   error(msg) {
-    const text = `error ${msg}`;
+    const text2 = `error ${msg}`;
     if (capturing) {
-      captured.push(stripAnsi(text));
+      captured.push(stripAnsi(text2));
     } else {
       console.error(`${RED}error${RESET} ${msg}`);
     }
@@ -660,6 +660,118 @@ function trackDownload(packageName) {
   });
 }
 
+// src/lib/prompts.ts
+import * as p from "@clack/prompts";
+function isInteractive() {
+  return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+function handleCancel(value) {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value;
+}
+async function promptForVariable(name, def) {
+  switch (def.type) {
+    case "enum": {
+      const value = await p.select({
+        message: def.description || name,
+        options: (def.options ?? []).map((opt) => ({
+          value: opt,
+          label: opt
+        })),
+        initialValue: def.default !== void 0 ? String(def.default) : void 0
+      });
+      return handleCancel(value);
+    }
+    case "boolean": {
+      const value = await p.confirm({
+        message: def.description || name,
+        initialValue: def.default !== void 0 ? Boolean(def.default) : false
+      });
+      return handleCancel(value);
+    }
+    case "number": {
+      const value = await p.text({
+        message: def.description || name,
+        placeholder: def.default !== void 0 ? String(def.default) : void 0,
+        defaultValue: def.default !== void 0 ? String(def.default) : void 0,
+        validate(input) {
+          if (isNaN(Number(input))) return "Must be a number";
+        }
+      });
+      return Number(handleCancel(value));
+    }
+    case "string":
+    default: {
+      const value = await p.text({
+        message: def.description || name,
+        placeholder: def.default !== void 0 ? String(def.default) : void 0,
+        defaultValue: def.default !== void 0 ? String(def.default) : void 0,
+        validate(input) {
+          if (def.required && !input) return `${name} is required`;
+        }
+      });
+      return handleCancel(value);
+    }
+  }
+}
+async function promptForVariables(variableDefs, provided, noInput = false) {
+  const values = {};
+  for (const [name, def] of Object.entries(variableDefs)) {
+    if (def.type === "resolved") continue;
+    if (provided[name] !== void 0) {
+      values[name] = coerceValue2(provided[name], def);
+    } else if (def.default !== void 0) {
+      if (isInteractive() && !noInput) {
+        values[name] = await promptForVariable(name, def);
+      } else {
+        values[name] = def.default;
+      }
+    } else if (def.required) {
+      if (isInteractive() && !noInput) {
+        values[name] = await promptForVariable(name, def);
+      } else {
+        throw new Error(`Missing required variable: ${name} -- ${def.description}`);
+      }
+    }
+  }
+  return values;
+}
+function coerceValue2(raw, def) {
+  switch (def.type) {
+    case "number":
+      return Number(raw);
+    case "boolean":
+      return raw === "true" || raw === "1" || raw === "yes";
+    case "enum":
+      if (def.options && !def.options.includes(raw)) {
+        throw new Error(
+          `Invalid value "${raw}" for enum variable. Options: ${def.options.join(", ")}`
+        );
+      }
+      return raw;
+    default:
+      return raw;
+  }
+}
+async function withSpinner(message, fn, successMessage) {
+  if (!isInteractive()) {
+    return fn();
+  }
+  const s = p.spinner();
+  s.start(message);
+  try {
+    const result = await fn();
+    s.stop(successMessage ?? message);
+    return result;
+  } catch (err) {
+    s.stop(`Failed: ${message}`);
+    throw err;
+  }
+}
+
 // src/lib/installer.ts
 function getInstallDir(type) {
   switch (type) {
@@ -679,38 +791,60 @@ function contentHash(content) {
 }
 async function installPackage(packageName, options = {}) {
   const projectDir = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? (isInteractive() && !options.noInput);
   const locked = getLockedVersion(packageName, projectDir);
   if (locked && !options.version) {
     logger.dim(`${packageName}@${locked.version} already installed`);
     return;
   }
-  logger.info(`Resolving ${packageName}...`);
-  const { version, metadata } = await resolveVersion(packageName, options.version);
-  const versionMeta = await fetchVersionMetadata(packageName, version);
-  logger.info(`Fetching ${packageName}@${version}...`);
-  const basePath = versionMeta.source.path ? `${versionMeta.source.path}/` : "";
-  const manifestRaw = await fetchFileAtTag(
-    versionMeta.source.repository,
-    versionMeta.source.tag,
-    `${basePath}planmode.yaml`
-  );
-  const manifest = parseManifest(manifestRaw);
-  let content;
-  if (manifest.content) {
-    content = manifest.content;
-  } else if (manifest.content_file) {
-    content = await fetchFileAtTag(
+  const resolveAndFetch = async () => {
+    const { version: version2, metadata: metadata2 } = await resolveVersion(packageName, options.version);
+    const versionMeta2 = await fetchVersionMetadata(packageName, version2);
+    return { version: version2, metadata: metadata2, versionMeta: versionMeta2 };
+  };
+  const { version, metadata, versionMeta } = interactive ? await withSpinner(
+    `Resolving ${packageName}...`,
+    resolveAndFetch,
+    `Resolved ${packageName}`
+  ) : await (async () => {
+    logger.info(`Resolving ${packageName}...`);
+    return resolveAndFetch();
+  })();
+  const fetchContent = async () => {
+    const basePath = versionMeta.source.path ? `${versionMeta.source.path}/` : "";
+    const manifestRaw = await fetchFileAtTag(
       versionMeta.source.repository,
       versionMeta.source.tag,
-      `${basePath}${manifest.content_file}`
+      `${basePath}planmode.yaml`
     );
-  } else {
-    throw new Error("Package has no content or content_file");
-  }
+    const manifest2 = parseManifest(manifestRaw);
+    let content2;
+    if (manifest2.content) {
+      content2 = manifest2.content;
+    } else if (manifest2.content_file) {
+      content2 = await fetchFileAtTag(
+        versionMeta.source.repository,
+        versionMeta.source.tag,
+        `${basePath}${manifest2.content_file}`
+      );
+    } else {
+      throw new Error("Package has no content or content_file");
+    }
+    return { manifest: manifest2, content: content2 };
+  };
+  const { manifest, content: rawContent } = interactive ? await withSpinner(
+    `Fetching ${packageName}@${version}...`,
+    fetchContent,
+    `Fetched ${packageName}@${version}`
+  ) : await (async () => {
+    logger.info(`Fetching ${packageName}@${version}...`);
+    return fetchContent();
+  })();
+  let content = rawContent;
   if (manifest.variables && Object.keys(manifest.variables).length > 0) {
     const provided = options.variables ?? {};
-    if (options.noInput) {
-      const values = collectVariableValues(manifest.variables, provided);
+    if (interactive) {
+      const values = await promptForVariables(manifest.variables, provided, false);
       content = renderTemplate(content, values);
     } else {
       const values = collectVariableValues(manifest.variables, provided);
@@ -772,7 +906,8 @@ async function installPackage(packageName, options = {}) {
       await installPackage(name, {
         version: range === "*" ? void 0 : range,
         projectDir,
-        noInput: options.noInput
+        noInput: options.noInput,
+        interactive: options.interactive
       });
     }
   }
@@ -919,139 +1054,151 @@ function createPackage(options) {
 // src/lib/publisher.ts
 async function publishPackage(options = {}) {
   const cwd = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? false;
   const token = options.token ?? getGitHubToken();
   if (!token) {
     throw new Error("Not authenticated. Run `planmode login` first.");
   }
-  logger.info("Reading planmode.yaml...");
-  const manifest = readManifest(cwd);
-  const errors = validateManifest(manifest, true);
-  if (errors.length > 0) {
-    throw new Error(`Invalid manifest:
+  const doValidate = async () => {
+    const manifest2 = readManifest(cwd);
+    const errors = validateManifest(manifest2, true);
+    if (errors.length > 0) {
+      throw new Error(`Invalid manifest:
 ${errors.map((e) => `  - ${e}`).join("\n")}`);
-  }
+    }
+    return manifest2;
+  };
+  const manifest = interactive ? await withSpinner("Validating manifest...", doValidate, "Manifest valid") : await (async () => {
+    logger.info("Reading planmode.yaml...");
+    return doValidate();
+  })();
   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}`;
-  logger.info(`Creating tag ${tag}...`);
-  try {
-    await createTag(cwd, tag);
-  } catch {
-    logger.dim(`Tag ${tag} already exists, using existing`);
-  }
-  try {
-    await pushTag(cwd, tag);
+  const doTag = async () => {
+    try {
+      await createTag(cwd, tag);
+    } catch {
+    }
+    try {
+      await pushTag(cwd, tag);
+    } catch {
+    }
+  };
+  if (interactive) {
+    await withSpinner(`Creating tag ${tag}...`, doTag, `Tag ${tag} ready`);
+  } else {
+    logger.info(`Creating tag ${tag}...`);
+    await doTag();
     logger.success(`Pushed tag ${tag}`);
-  } catch {
-    logger.dim(`Tag ${tag} already pushed`);
   }
-  logger.info("Submitting to registry...");
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    Accept: "application/vnd.github.v3+json",
-    "User-Agent": "planmode-cli",
-    "Content-Type": "application/json"
-  };
-  await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
-    method: "POST",
-    headers
-  });
-  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();
-  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: (/* @__PURE__ */ new Date()).toISOString(),
-      updated_at: (/* @__PURE__ */ new Date()).toISOString(),
-      dependencies: manifest.dependencies,
-      variables: manifest.variables
-    },
-    null,
-    2
-  );
-  const versionContent = JSON.stringify(
-    {
-      version: manifest.version,
-      published_at: (/* @__PURE__ */ new Date()).toISOString(),
-      source: {
+  const doSubmit = async () => {
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "planmode-cli",
+      "Content-Type": "application/json"
+    };
+    await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
+      method: "POST",
+      headers
+    });
+    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();
+    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,
-        tag,
-        sha
+        category: manifest.category ?? "other",
+        tags: manifest.tags ?? [],
+        type: manifest.type,
+        models: manifest.models ?? [],
+        latest_version: manifest.version,
+        versions: [manifest.version],
+        downloads: 0,
+        created_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_at: (/* @__PURE__ */ new Date()).toISOString(),
+        dependencies: manifest.dependencies,
+        variables: manifest.variables
       },
-      files: ["planmode.yaml", manifest.content_file ?? "inline"],
-      content_hash: `sha256:${sha.slice(0, 16)}`
-    },
-    null,
-    2
-  );
-  const branchName = `add-${manifest.name}-${manifest.version}`;
-  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();
-  const baseSha = refData.object.sha;
-  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
-    })
-  });
-  await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/metadata.json`,
-    {
-      method: "PUT",
+      null,
+      2
+    );
+    const versionContent = JSON.stringify(
+      {
+        version: manifest.version,
+        published_at: (/* @__PURE__ */ new Date()).toISOString(),
+        source: {
+          repository: repoPath,
+          tag,
+          sha
+        },
+        files: ["planmode.yaml", manifest.content_file ?? "inline"],
+        content_hash: `sha256:${sha.slice(0, 16)}`
+      },
+      null,
+      2
+    );
+    const branchName = `add-${manifest.name}-${manifest.version}`;
+    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();
+    const baseSha = refData.object.sha;
+    await fetch(`https://api.github.com/repos/${user.login}/planmode.org/git/refs`, {
+      method: "POST",
       headers,
       body: JSON.stringify({
-        message: `Add ${manifest.name}@${manifest.version}`,
-        content: Buffer.from(metadataContent).toString("base64"),
-        branch: branchName
+        ref: `refs/heads/${branchName}`,
+        sha: baseSha
       })
-    }
-  );
-  await fetch(
-    `https://api.github.com/repos/${user.login}/planmode.org/contents/registry/packages/${manifest.name}/versions/${manifest.version}.json`,
-    {
-      method: "PUT",
+    });
+    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
+        })
+      }
+    );
+    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
+        })
+      }
+    );
+    const prRes = await fetch("https://api.github.com/repos/kaihannonen/planmode.org/pulls", {
+      method: "POST",
       headers,
       body: JSON.stringify({
-        message: `Add ${manifest.name}@${manifest.version} version metadata`,
-        content: Buffer.from(versionContent).toString("base64"),
-        branch: branchName
-      })
-    }
-  );
-  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}
+        title: `Add ${manifest.name}@${manifest.version}`,
+        head: `${user.login}:${branchName}`,
+        base: "main",
+        body: `## New package: ${manifest.name}
 
 - **Type:** ${manifest.type}
 - **Version:** ${manifest.version}
@@ -1059,17 +1206,30 @@ ${errors.map((e) => `  - ${e}`).join("\n")}`);
 - **Author:** ${manifest.author}
 
 Submitted via \`planmode publish\`.`
-    })
-  });
-  if (!prRes.ok) {
-    const err = await prRes.text();
-    throw new Error(`Failed to create PR: ${err}`);
+      })
+    });
+    if (!prRes.ok) {
+      const err = await prRes.text();
+      throw new Error(`Failed to create PR: ${err}`);
+    }
+    const pr = await prRes.json();
+    return pr.html_url;
+  };
+  let prUrl;
+  if (interactive) {
+    prUrl = await withSpinner(
+      "Submitting to registry...",
+      doSubmit,
+      "Submitted to registry"
+    );
+  } else {
+    logger.info("Submitting to registry...");
+    prUrl = await doSubmit();
+    logger.success(`Published ${manifest.name}@${manifest.version}`);
+    logger.info(`PR: ${prUrl}`);
   }
-  const pr = await prRes.json();
-  logger.success(`Published ${manifest.name}@${manifest.version}`);
-  logger.info(`PR: ${pr.html_url}`);
   return {
-    prUrl: pr.html_url,
+    prUrl,
     packageName: manifest.name,
     version: manifest.version
   };
@@ -1714,9 +1874,9 @@ async function withCaptureAsync(fn) {
     throw Object.assign(err, { capturedMessages: messages });
   }
 }
-function textResult(text, isError = false) {
+function textResult(text2, isError = false) {
   return {
-    content: [{ type: "text", text }],
+    content: [{ type: "text", text: text2 }],
     isError
   };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "planmode",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "The open source package manager for AI plans, rules, and prompts.",
   "type": "module",
   "bin": {
@@ -16,6 +16,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@clack/prompts": "^0.9.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
     "commander": "^13.1.0",
     "handlebars": "^4.7.8",

package/src/commands/doctor.ts

@@ -1,19 +1,35 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import { runDoctor } from "../lib/doctor.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive } from "../lib/prompts.js";
 
 export const doctorCommand = new Command("doctor")
   .description("Check project health: verify installed packages, imports, and file integrity")
   .action(() => {
+    const interactive = isInteractive();
     const result = runDoctor();
 
-    logger.blank();
-    logger.bold(`Checked ${result.packagesChecked} package(s)`);
-    logger.blank();
+    if (interactive) {
+      p.intro("Health check");
+    } else {
+      logger.blank();
+    }
 
-    if (result.issues.length === 0) {
-      logger.success("Everything looks good. No issues found.");
+    if (interactive) {
+      p.log.info(`Checked ${result.packagesChecked} package(s)`);
+    } else {
+      logger.bold(`Checked ${result.packagesChecked} package(s)`);
       logger.blank();
+    }
+
+    if (result.issues.length === 0) {
+      if (interactive) {
+        p.outro("Everything looks good. No issues found.");
+      } else {
+        logger.success("Everything looks good. No issues found.");
+        logger.blank();
+      }
       return;
     }
 
@@ -21,21 +37,37 @@ export const doctorCommand = new Command("doctor")
     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}`);
+      if (interactive) {
+        p.log.error(issue.message);
+      } else {
+        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}`);
+      if (interactive) {
+        p.log.warn(issue.message);
+      } else {
+        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)`);
+    if (interactive) {
+      if (errors.length > 0) {
+        p.outro(`${errors.length} error(s), ${warnings.length} warning(s)`);
+      } else {
+        p.outro(`${warnings.length} warning(s)`);
+      }
     } else {
-      logger.warn(`${warnings.length} warning(s)`);
+      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();
     }
-    logger.blank();
 
     if (errors.length > 0) {
       process.exit(1);