planmode 0.2.2 → 0.3.0

package/src/commands/login.ts

@@ -1,7 +1,9 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import { execSync } from "node:child_process";
 import { setGitHubToken, getGitHubToken } from "../lib/config.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive, handleCancel, withSpinner } from "../lib/prompts.js";
 
 export const loginCommand = new Command("login")
   .description("Configure GitHub authentication")
@@ -19,16 +21,18 @@ export const loginCommand = new Command("login")
         logger.error("Failed to read token from GitHub CLI. Make sure `gh` is installed and authenticated.");
         process.exit(1);
       }
-    } else {
-      // Interactive prompt via stdin
-      const { createInterface } = await import("node:readline");
-      const rl = createInterface({ input: process.stdin, output: process.stdout });
-      token = await new Promise<string>((resolve) => {
-        rl.question("GitHub personal access token: ", (answer) => {
-          rl.close();
-          resolve(answer.trim());
-        });
+    } else if (isInteractive()) {
+      p.intro("planmode login");
+      const value = await p.password({
+        message: "GitHub personal access token:",
+        validate(input) {
+          if (!input) return "Token is required";
+        },
       });
+      token = handleCancel(value);
+    } else {
+      logger.error("No token provided. Use --token <token> or --gh.");
+      process.exit(1);
     }
 
     if (!token) {
@@ -37,20 +41,43 @@ export const loginCommand = new Command("login")
     }
 
     // Validate token
-    logger.info("Validating token...");
-    const response = await fetch("https://api.github.com/user", {
-      headers: {
-        Authorization: `Bearer ${token}`,
-        "User-Agent": "planmode-cli",
-      },
-    });
-
-    if (!response.ok) {
-      logger.error("Invalid token. GitHub API returned: " + response.status);
+    const validateToken = async () => {
+      const response = await fetch("https://api.github.com/user", {
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "User-Agent": "planmode-cli",
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error("Invalid token. GitHub API returned: " + response.status);
+      }
+
+      return (await response.json()) as { login: string };
+    };
+
+    try {
+      const user = await withSpinner(
+        "Validating token...",
+        validateToken,
+        "Token validated",
+      );
+
+      setGitHubToken(token);
+
+      if (isInteractive()) {
+        p.log.success(`Authenticated as ${user.login}`);
+        p.outro("You're all set!");
+      } else {
+        logger.success(`Authenticated as ${user.login}`);
+      }
+    } catch (err) {
+      if (isInteractive()) {
+        p.log.error((err as Error).message);
+        p.outro("Authentication failed.");
+      } else {
+        logger.error((err as Error).message);
+      }
       process.exit(1);
     }
-
-    const user = (await response.json()) as { login: string };
-    setGitHubToken(token);
-    logger.success(`Authenticated as ${user.login}`);
   });

package/src/commands/publish.ts

@@ -1,14 +1,26 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import { publishPackage } from "../lib/publisher.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive } from "../lib/prompts.js";
 
 export const publishCommand = new Command("publish")
   .description("Publish the current directory as a package to the registry")
   .action(async () => {
     try {
-      logger.blank();
-      const result = await publishPackage();
-      logger.blank();
+      if (isInteractive()) {
+        p.intro("Publishing package");
+      } else {
+        logger.blank();
+      }
+
+      const result = await publishPackage({ interactive: isInteractive() });
+
+      if (isInteractive()) {
+        p.outro(`Published ${result.packageName}@${result.version} — PR: ${result.prUrl}`);
+      } else {
+        logger.blank();
+      }
     } catch (err) {
       logger.error((err as Error).message);
       process.exit(1);

package/src/commands/record.ts

@@ -1,8 +1,10 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import fs from "node:fs";
 import path from "node:path";
 import { startRecordingAsync, stopRecording, isRecording } from "../lib/recorder.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive, withSpinner } from "../lib/prompts.js";
 
 export const recordCommand = new Command("record")
   .description("Record git activity and generate a plan from commits");
@@ -31,13 +33,30 @@ recordCommand
   .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 interactive = isInteractive();
+
+      if (interactive) {
+        p.intro("Generating plan from recording");
+      } else {
+        logger.blank();
+      }
 
-      const result = await stopRecording(process.cwd(), {
-        name: options.name,
-        author: options.author,
-      });
+      const result = interactive
+        ? await withSpinner(
+            "Analyzing commits...",
+            () => stopRecording(process.cwd(), {
+              name: options.name,
+              author: options.author,
+            }),
+            "Analysis complete",
+          )
+        : await (async () => {
+            logger.info("Analyzing commits...");
+            return stopRecording(process.cwd(), {
+              name: options.name,
+              author: options.author,
+            });
+          })();
 
       // Write to output directory
       const outDir = options.dir ?? process.cwd();
@@ -56,8 +75,13 @@ recordCommand
 
       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();
+
+      if (interactive) {
+        p.outro("Edit the generated plan, then run `planmode test` to validate and `planmode publish` when ready.");
+      } else {
+        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/run.ts

@@ -2,8 +2,9 @@ import { Command } from "commander";
 import fs from "node:fs";
 import path from "node:path";
 import { parseManifest, readPackageContent } from "../lib/manifest.js";
-import { renderTemplate, collectVariableValues, resolveVariable } from "../lib/template.js";
+import { renderTemplate, resolveVariable } from "../lib/template.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive, promptForVariables } from "../lib/prompts.js";
 
 export const runCommand = new Command("run")
   .description("Run a templated prompt and output to stdout")
@@ -49,22 +50,12 @@ export const runCommand = new Command("run")
 
       // Resolve variables
       if (manifest?.variables && Object.keys(manifest.variables).length > 0) {
-        const values: Record<string, string | number | boolean> = {};
+        const noInput = options.input === false;
 
-        // First pass: resolve non-resolved variables
-        for (const [name, def] of Object.entries(manifest.variables)) {
-          if (def.type === "resolved") continue;
-          if (vars[name] !== undefined) {
-            values[name] = vars[name]!;
-          } else if (def.default !== undefined) {
-            values[name] = def.default;
-          } else if (def.required && options.input === false) {
-            logger.error(`Missing required variable: --${name}`);
-            process.exit(1);
-          }
-        }
+        // Collect non-resolved variables (interactive or from flags/defaults)
+        const values = await promptForVariables(manifest.variables, vars, noInput);
 
-        // Second pass: resolve dynamic variables
+        // Resolve dynamic variables
         for (const [name, def] of Object.entries(manifest.variables)) {
           if (def.type !== "resolved") continue;
           values[name] = await resolveVariable(def, values);

package/src/commands/search.ts

@@ -1,6 +1,9 @@
 import { Command } from "commander";
-import { searchPackages } from "../lib/registry.js";
+import * as p from "@clack/prompts";
+import { searchPackages, fetchPackageMetadata } from "../lib/registry.js";
+import { installPackage } from "../lib/installer.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive, handleCancel, withSpinner } from "../lib/prompts.js";
 
 export const searchCommand = new Command("search")
   .description("Search the registry for packages")
@@ -10,13 +13,20 @@ export const searchCommand = new Command("search")
   .option("--json", "Output as JSON")
   .action(async (query: string, options: { type?: string; category?: string; json?: boolean }) => {
     try {
-      const results = await searchPackages(query, {
-        type: options.type,
-        category: options.category,
-      });
+      const results = await withSpinner(
+        "Searching registry...",
+        () => searchPackages(query, {
+          type: options.type,
+          category: options.category,
+        }),
+      );
 
       if (results.length === 0) {
-        logger.info("No packages found matching your query.");
+        if (isInteractive() && !options.json) {
+          p.log.warn("No packages found matching your query.");
+        } else {
+          logger.info("No packages found matching your query.");
+        }
         return;
       }
 
@@ -25,19 +35,80 @@ export const searchCommand = new Command("search")
         return;
       }
 
-      logger.blank();
-      logger.table(
-        ["name", "type", "version", "description"],
-        results.map((pkg) => [
-          pkg.name,
-          pkg.type,
-          pkg.version,
-          pkg.description.length > 50
-            ? pkg.description.slice(0, 50) + "..."
-            : pkg.description,
-        ]),
+      // Non-interactive: just show the table
+      if (!isInteractive()) {
+        logger.blank();
+        logger.table(
+          ["name", "type", "version", "description"],
+          results.map((pkg) => [
+            pkg.name,
+            pkg.type,
+            pkg.version,
+            pkg.description.length > 50
+              ? pkg.description.slice(0, 50) + "..."
+              : pkg.description,
+          ]),
+        );
+        logger.blank();
+        return;
+      }
+
+      // Interactive: let user select a package
+      const selected = handleCancel(
+        await p.select({
+          message: `Found ${results.length} package(s). Select one:`,
+          options: [
+            ...results.map((pkg) => ({
+              value: pkg.name,
+              label: `${pkg.name} (${pkg.type} v${pkg.version})`,
+              hint: pkg.description.length > 60
+                ? pkg.description.slice(0, 60) + "..."
+                : pkg.description,
+            })),
+            { value: "__none__", label: "Cancel" },
+          ],
+        }),
       );
-      logger.blank();
+
+      if (selected === "__none__") return;
+
+      const action = handleCancel(
+        await p.select({
+          message: `${selected}:`,
+          options: [
+            { value: "install", label: "Install" },
+            { value: "details", label: "View details" },
+            { value: "back", label: "Cancel" },
+          ],
+        }),
+      );
+
+      if (action === "install") {
+        try {
+          await installPackage(selected, { interactive: true });
+          p.log.success(`Installed ${selected}`);
+        } catch (err) {
+          p.log.error((err as Error).message);
+        }
+      } else if (action === "details") {
+        const meta = await withSpinner(
+          "Fetching package details...",
+          () => fetchPackageMetadata(selected),
+        );
+        const lines = [
+          `Type:        ${meta.type}`,
+          `Author:      ${meta.author}`,
+          `License:     ${meta.license}`,
+          `Category:    ${meta.category}`,
+          `Downloads:   ${meta.downloads.toLocaleString()}`,
+          `Versions:    ${meta.versions.join(", ")}`,
+          `Repository:  ${meta.repository}`,
+        ];
+        if (meta.tags?.length) {
+          lines.push(`Tags:        ${meta.tags.join(", ")}`);
+        }
+        p.note(lines.join("\n"), `${meta.name}@${meta.latest_version}`);
+      }
     } catch (err) {
       logger.error((err as Error).message);
       process.exit(1);

package/src/commands/snapshot.ts

@@ -1,23 +1,42 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import fs from "node:fs";
 import path from "node:path";
 import { takeSnapshot } from "../lib/snapshot.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive, withSpinner } from "../lib/prompts.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 }) => {
+  .action(async (options: { name?: string; author?: string; dir?: string }) => {
     try {
-      logger.blank();
-      logger.info("Analyzing project...");
+      const interactive = isInteractive();
+
+      if (interactive) {
+        p.intro("Taking project snapshot");
+      } else {
+        logger.blank();
+      }
+
+      const doSnapshot = () => Promise.resolve(
+        takeSnapshot(process.cwd(), {
+          name: options.name,
+          author: options.author,
+        }),
+      );
 
-      const result = takeSnapshot(process.cwd(), {
-        name: options.name,
-        author: options.author,
-      });
+      const result = interactive
+        ? await withSpinner("Analyzing project...", doSnapshot, "Analysis complete")
+        : (() => {
+            logger.info("Analyzing project...");
+            return takeSnapshot(process.cwd(), {
+              name: options.name,
+              author: options.author,
+            });
+          })();
 
       // Write to output directory
       const outDir = options.dir ?? process.cwd();
@@ -37,8 +56,13 @@ export const snapshotCommand = new Command("snapshot")
 
       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();
+
+      if (interactive) {
+        p.outro("Edit the generated plan, then run `planmode test` to validate and `planmode publish` when ready.");
+      } else {
+        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

@@ -1,39 +1,69 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import { testPackage } from "../lib/tester.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive } from "../lib/prompts.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 interactive = isInteractive();
+
+      if (interactive) {
+        p.intro("Testing package");
+      } else {
+        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);
+          if (interactive) {
+            p.log.success(check.name);
+          } else {
+            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}`);
+            if (interactive) {
+              p.log.error(`${check.name}: ${issue.message}`);
+            } else {
+              logger.error(`${check.name}: ${issue.message}`);
+            }
           } else if (issue) {
-            logger.warn(`${check.name}: ${issue.message}`);
+            if (interactive) {
+              p.log.warn(`${check.name}: ${issue.message}`);
+            } else {
+              logger.warn(`${check.name}: ${issue.message}`);
+            }
           }
         }
       }
 
-      logger.blank();
-      if (result.passed) {
-        logger.success(`All checks passed. Ready to publish.`);
+      if (interactive) {
+        if (result.passed) {
+          p.outro("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");
+          p.outro(`${errors.length} error(s), ${warnings.length} warning(s). Fix errors before publishing.`);
+        }
       } 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) {
+          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();
       }
-      logger.blank();
 
       if (!result.passed) {
         process.exit(1);

package/src/commands/update.ts

@@ -1,47 +1,89 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import { updatePackage } from "../lib/installer.js";
 import { readLockfile } from "../lib/lockfile.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive, withSpinner } from "../lib/prompts.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();
+      const interactive = isInteractive();
+
+      if (interactive) {
+        p.intro("Updating packages");
+      } else {
+        logger.blank();
+      }
 
       if (packageName) {
-        const updated = await updatePackage(packageName);
+        const updated = interactive
+          ? await withSpinner(
+              `Checking ${packageName} for updates...`,
+              () => updatePackage(packageName),
+            )
+          : await updatePackage(packageName);
+
         if (!updated) {
-          logger.info("Already up to date.");
+          if (interactive) {
+            p.log.info("Already up to date.");
+          } else {
+            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.");
+          if (interactive) {
+            p.log.info("No packages installed.");
+          } else {
+            logger.info("No packages installed.");
+          }
+          if (interactive) p.outro("Nothing to update.");
           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}`);
+        const doUpdate = async () => {
+          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}`);
+            }
           }
-        }
+          return updatedCount;
+        };
+
+        const updatedCount = interactive
+          ? await withSpinner("Checking for updates...", doUpdate)
+          : await doUpdate();
 
         if (updatedCount === 0) {
-          logger.info("All packages are up to date.");
+          if (interactive) {
+            p.log.info("All packages are up to date.");
+          } else {
+            logger.info("All packages are up to date.");
+          }
         } else {
-          logger.success(`Updated ${updatedCount} package${updatedCount > 1 ? "s" : ""}.`);
+          if (interactive) {
+            p.log.success(`Updated ${updatedCount} package${updatedCount > 1 ? "s" : ""}.`);
+          } else {
+            logger.success(`Updated ${updatedCount} package${updatedCount > 1 ? "s" : ""}.`);
+          }
         }
       }
 
-      logger.blank();
+      if (interactive) {
+        p.outro("Done!");
+      } else {
+        logger.blank();
+      }
     } catch (err) {
       logger.error((err as Error).message);
       process.exit(1);

package/src/index.ts

@@ -14,13 +14,14 @@ import { doctorCommand } from "./commands/doctor.js";
 import { testCommand } from "./commands/test.js";
 import { recordCommand } from "./commands/record.js";
 import { snapshotCommand } from "./commands/snapshot.js";
+import { isInteractive } from "./lib/prompts.js";
 
 const program = new Command();
 
 program
   .name("planmode")
   .description("The open source package manager for AI plans, rules, and prompts.")
-  .version("0.2.2");
+  .version("0.3.0");
 
 program.addCommand(installCommand);
 program.addCommand(uninstallCommand);
@@ -38,4 +39,10 @@ program.addCommand(testCommand);
 program.addCommand(recordCommand);
 program.addCommand(snapshotCommand);
 
-program.parse();
+// If no args and interactive TTY, show the interactive menu
+if (process.argv.length <= 2 && isInteractive()) {
+  const { runInteractiveMenu } = await import("./commands/interactive.js");
+  runInteractiveMenu();
+} else {
+  program.parse();
+}