planmode 0.2.2 → 0.3.0

package/src/lib/installer.ts

@@ -11,6 +11,7 @@ import { parseManifest, readPackageContent } from "./manifest.js";
 import { renderTemplate, collectVariableValues } from "./template.js";
 import { logger } from "./logger.js";
 import { trackDownload } from "./analytics.js";
+import { isInteractive, promptForVariables, withSpinner } from "./prompts.js";
 
 function getInstallDir(type: PackageType): string {
   switch (type) {
@@ -37,6 +38,7 @@ export interface InstallOptions {
   noInput?: boolean;
   variables?: Record<string, string>;
   projectDir?: string;
+  interactive?: boolean;
 }
 
 export async function installPackage(
@@ -44,6 +46,7 @@ export async function installPackage(
   options: InstallOptions = {},
 ): Promise<void> {
   const projectDir = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? (isInteractive() && !options.noInput);
 
   // Check lockfile first
   const locked = getLockedVersion(packageName, projectDir);
@@ -53,44 +56,68 @@ export async function installPackage(
   }
 
   // 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 basePath = versionMeta.source.path ? `${versionMeta.source.path}/` : "";
-  const manifestRaw = await fetchFileAtTag(
-    versionMeta.source.repository,
-    versionMeta.source.tag,
-    `${basePath}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(
+  const resolveAndFetch = async () => {
+    const { version, metadata } = await resolveVersion(packageName, options.version);
+    const versionMeta = await fetchVersionMetadata(packageName, version);
+    return { version, metadata, versionMeta };
+  };
+
+  const { version, metadata, versionMeta } = interactive
+    ? await withSpinner(
+        `Resolving ${packageName}...`,
+        resolveAndFetch,
+        `Resolved ${packageName}`,
+      )
+    : await (async () => {
+        logger.info(`Resolving ${packageName}...`);
+        return resolveAndFetch();
+      })();
+
+  // Fetch manifest and content
+  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 manifest = parseManifest(manifestRaw);
+
+    let content: string;
+    if (manifest.content) {
+      content = manifest.content;
+    } else if (manifest.content_file) {
+      content = await fetchFileAtTag(
+        versionMeta.source.repository,
+        versionMeta.source.tag,
+        `${basePath}${manifest.content_file}`,
+      );
+    } else {
+      throw new Error("Package has no content or content_file");
+    }
+
+    return { manifest, content };
+  };
+
+  const { manifest, content: rawContent } = interactive
+    ? await withSpinner(
+        `Fetching ${packageName}@${version}...`,
+        fetchContent,
+        `Fetched ${packageName}@${version}`,
+      )
+    : await (async () => {
+        logger.info(`Fetching ${packageName}@${version}...`);
+        return fetchContent();
+      })();
 
   // Process variables if templated
+  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 {
-      // Use defaults for non-provided values
       const values = collectVariableValues(manifest.variables, provided);
       content = renderTemplate(content, values);
     }
@@ -170,6 +197,7 @@ export async function installPackage(
         version: range === "*" ? undefined : range,
         projectDir,
         noInput: options.noInput,
+        interactive: options.interactive,
       });
     }
   }

package/src/lib/prompts.ts

@@ -0,0 +1,159 @@
+import * as p from "@clack/prompts";
+import type { VariableDefinition } from "../types/index.js";
+
+/**
+ * Returns true if the CLI is running in an interactive terminal.
+ * False when piped, in CI, or when --no-input is set.
+ */
+export function isInteractive(): boolean {
+  return Boolean(process.stdin.isTTY) && !process.env.CI;
+}
+
+/**
+ * Wraps a clack prompt result — if the user cancels (Ctrl+C),
+ * prints a cancel message and exits cleanly.
+ */
+export function handleCancel<T>(value: T | symbol): T {
+  if (p.isCancel(value)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return value as T;
+}
+
+/**
+ * Prompts for a single manifest variable using the appropriate clack widget.
+ */
+async function promptForVariable(
+  name: string,
+  def: VariableDefinition,
+): Promise<string | number | boolean> {
+  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 !== undefined ? String(def.default) : undefined,
+      });
+      return handleCancel(value);
+    }
+
+    case "boolean": {
+      const value = await p.confirm({
+        message: def.description || name,
+        initialValue: def.default !== undefined ? Boolean(def.default) : false,
+      });
+      return handleCancel(value);
+    }
+
+    case "number": {
+      const value = await p.text({
+        message: def.description || name,
+        placeholder: def.default !== undefined ? String(def.default) : undefined,
+        defaultValue: def.default !== undefined ? String(def.default) : undefined,
+        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 !== undefined ? String(def.default) : undefined,
+        defaultValue: def.default !== undefined ? String(def.default) : undefined,
+        validate(input) {
+          if (def.required && !input) return `${name} is required`;
+        },
+      });
+      return handleCancel(value);
+    }
+  }
+}
+
+/**
+ * Collects all missing variable values interactively.
+ * Merges with already-provided values.
+ * Falls back to defaults or throws if not interactive.
+ */
+export async function promptForVariables(
+  variableDefs: Record<string, VariableDefinition>,
+  provided: Record<string, string>,
+  noInput: boolean = false,
+): Promise<Record<string, string | number | boolean>> {
+  const values: Record<string, string | number | boolean> = {};
+
+  for (const [name, def] of Object.entries(variableDefs)) {
+    if (def.type === "resolved") continue;
+
+    if (provided[name] !== undefined) {
+      values[name] = coerceValue(provided[name]!, def);
+    } else if (def.default !== undefined) {
+      if (isInteractive() && !noInput) {
+        // In interactive mode, let user confirm/change defaults
+        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 coerceValue(
+  raw: string,
+  def: VariableDefinition,
+): string | number | boolean {
+  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;
+  }
+}
+
+/**
+ * Wraps an async operation with a clack spinner.
+ * Only shows spinner when interactive.
+ */
+export async function withSpinner<T>(
+  message: string,
+  fn: () => Promise<T>,
+  successMessage?: string,
+): Promise<T> {
+  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;
+  }
+}

package/src/lib/publisher.ts

@@ -2,10 +2,12 @@ import { readManifest, validateManifest } from "./manifest.js";
 import { getGitHubToken } from "./config.js";
 import { getRemoteUrl, getHeadSha, createTag, pushTag } from "./git.js";
 import { logger } from "./logger.js";
+import { withSpinner } from "./prompts.js";
 
 export interface PublishOptions {
   projectDir?: string;
   token?: string;
+  interactive?: boolean;
 }
 
 export interface PublishResult {
@@ -16,6 +18,7 @@ export interface PublishResult {
 
 export async function publishPackage(options: PublishOptions = {}): Promise<PublishResult> {
   const cwd = options.projectDir ?? process.cwd();
+  const interactive = options.interactive ?? false;
 
   // Check auth
   const token = options.token ?? getGitHubToken();
@@ -24,12 +27,21 @@ export async function publishPackage(options: PublishOptions = {}): Promise<Publ
   }
 
   // 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")}`);
-  }
+  const doValidate = async () => {
+    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")}`);
+    }
+    return manifest;
+  };
+
+  const manifest = interactive
+    ? await withSpinner("Validating manifest...", doValidate, "Manifest valid")
+    : await (async () => {
+        logger.info("Reading planmode.yaml...");
+        return doValidate();
+      })();
 
   // Check git remote
   const remoteUrl = await getRemoteUrl(cwd);
@@ -41,162 +53,182 @@ export async function publishPackage(options: PublishOptions = {}): Promise<Publ
   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`);
-  }
+  const doTag = async () => {
+    try {
+      await createTag(cwd, tag);
+    } catch {
+      // Tag already exists
+    }
+    try {
+      await pushTag(cwd, tag);
+    } catch {
+      // Tag already pushed
+    }
+  };
 
-  try {
-    await pushTag(cwd, tag);
+  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`);
   }
 
   // Fork registry and create PR via GitHub API
-  logger.info("Submitting to registry...");
+  const doSubmit = async () => {
+    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,
+    );
 
-  const headers = {
-    Authorization: `Bearer ${token}`,
-    Accept: "application/vnd.github.v3+json",
-    "User-Agent": "planmode-cli",
-    "Content-Type": "application/json",
-  };
+    // Create branch on fork
+    const branchName = `add-${manifest.name}-${manifest.version}`;
 
-  // Fork the registry repo (idempotent)
-  await fetch("https://api.github.com/repos/kaihannonen/planmode.org/forks", {
-    method: "POST",
-    headers,
-  });
+    // Get main branch ref
+    const refRes = await fetch(
+      `https://api.github.com/repos/${user.login}/planmode.org/git/ref/heads/main`,
+      { 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.");
-  }
+    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;
 
-  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",
+    // Create branch
+    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,
       }),
-    },
-  );
-
-  // 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",
+    });
+
+    // 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({
-        message: `Add ${manifest.name}@${manifest.version} version metadata`,
-        content: Buffer.from(versionContent).toString("base64"),
-        branch: branchName,
+        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\`.`,
       }),
-    },
-  );
-
-  // 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}`);
-  }
+    });
+
+    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}`);
+    const pr = (await prRes.json()) as { html_url: string };
+    return pr.html_url;
+  };
+
+  let prUrl: string;
+  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}`);
+  }
 
   return {
-    prUrl: pr.html_url,
+    prUrl,
     packageName: manifest.name,
     version: manifest.version,
   };