planmode 0.2.2 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "planmode",
-  "version": "0.2.2",
+  "version": "0.4.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/context.ts

@@ -0,0 +1,111 @@
+import { Command } from "commander";
+import * as p from "@clack/prompts";
+import { addContextRepo, removeContextRepo, reindexContext, getContextSummary, formatSize } from "../lib/context.js";
+import { logger } from "../lib/logger.js";
+import { isInteractive, withSpinner } from "../lib/prompts.js";
+
+export const contextCommand = new Command("context")
+  .description("Manage project document context for AI");
+
+contextCommand
+  .command("add <path>")
+  .description("Add a document directory to the project context")
+  .option("--name <name>", "Human-readable label for this directory")
+  .action(async (dirPath: string, options: { name?: string }) => {
+    try {
+      const interactive = isInteractive();
+
+      if (interactive) {
+        await withSpinner(
+          "Indexing documents...",
+          async () => addContextRepo(dirPath, { name: options.name }),
+          "Indexing complete",
+        );
+      } else {
+        logger.blank();
+        addContextRepo(dirPath, { name: options.name });
+        logger.blank();
+      }
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });
+
+contextCommand
+  .command("remove <path-or-name>")
+  .description("Remove a directory from the project context")
+  .action((pathOrName: string) => {
+    try {
+      logger.blank();
+      removeContextRepo(pathOrName);
+      logger.blank();
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });
+
+contextCommand
+  .command("list")
+  .description("Show all directories in the project context")
+  .option("--json", "Output as JSON")
+  .action((options: { json?: boolean }) => {
+    try {
+      const summary = getContextSummary();
+
+      if (options.json) {
+        console.log(JSON.stringify(summary, null, 2));
+        return;
+      }
+
+      logger.blank();
+
+      if (summary.totalRepos === 0) {
+        logger.info("No context repos configured. Run `planmode context add <path>` to add one.");
+        logger.blank();
+        return;
+      }
+
+      logger.bold(`${summary.totalRepos} context repo(s) — ${summary.totalFiles} file(s), ${formatSize(summary.totalSize)}`);
+      logger.blank();
+
+      for (const repo of summary.repos) {
+        logger.info(`${repo.name}`);
+        logger.dim(`  Path: ${repo.path}`);
+        logger.dim(`  Files: ${repo.fileCount} (${formatSize(repo.totalSize)})`);
+        if (repo.typeBreakdown.length > 0) {
+          logger.dim(`  Types: ${repo.typeBreakdown.join(", ")}`);
+        }
+        logger.dim(`  Indexed: ${repo.indexedAt}`);
+        logger.blank();
+      }
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });
+
+contextCommand
+  .command("reindex [path-or-name]")
+  .description("Re-scan files in one or all context directories")
+  .action(async (pathOrName?: string) => {
+    try {
+      const interactive = isInteractive();
+
+      if (interactive) {
+        await withSpinner(
+          "Re-scanning documents...",
+          async () => reindexContext(pathOrName),
+          "Reindex complete",
+        );
+      } else {
+        logger.blank();
+        reindexContext(pathOrName);
+        logger.blank();
+      }
+    } catch (err) {
+      logger.error((err as Error).message);
+      process.exit(1);
+    }
+  });

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);

package/src/commands/init.ts

@@ -1,64 +1,112 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import { logger } from "../lib/logger.js";
 import { createPackage } from "../lib/init.js";
+import { isInteractive, handleCancel } from "../lib/prompts.js";
 import type { PackageType, Category } from "../types/index.js";
 
-async function prompt(question: string): Promise<string> {
-  const { createInterface } = await import("node:readline");
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.trim());
-    });
+const CATEGORIES: Category[] = [
+  "frontend",
+  "backend",
+  "devops",
+  "database",
+  "testing",
+  "mobile",
+  "ai-ml",
+  "design",
+  "security",
+  "other",
+];
+
+export async function initInteractive(): Promise<void> {
+  p.intro("Create a new planmode package");
+
+  const result = await p.group(
+    {
+      name: () =>
+        p.text({
+          message: "Package name",
+          placeholder: "my-awesome-plan",
+          validate(input) {
+            if (!input) return "Package name is required";
+            if (!/^[a-z0-9][a-z0-9-]*$/.test(input))
+              return "Lowercase letters, numbers, and hyphens only";
+          },
+        }),
+      type: () =>
+        p.select<PackageType>({
+          message: "Package type",
+          options: [
+            { value: "plan" as PackageType, label: "Plan", hint: "multi-step implementation guide" },
+            { value: "rule" as PackageType, label: "Rule", hint: "always-on coding constraint" },
+            { value: "prompt" as PackageType, label: "Prompt", hint: "single-use templated prompt" },
+          ],
+        }),
+      description: () =>
+        p.text({
+          message: "Description",
+          placeholder: "A short description of what this package does",
+        }),
+      author: () =>
+        p.text({
+          message: "Author (GitHub username)",
+          placeholder: "username",
+        }),
+      license: () =>
+        p.text({
+          message: "License",
+          defaultValue: "MIT",
+          placeholder: "MIT",
+        }),
+      category: () =>
+        p.select<Category>({
+          message: "Category",
+          options: CATEGORIES.map((cat) => ({ value: cat as Category, label: cat })),
+          initialValue: "other" as Category,
+        }),
+      tags: () =>
+        p.text({
+          message: "Tags (comma-separated)",
+          placeholder: "nextjs, tailwind, starter",
+        }),
+    },
+    {
+      onCancel() {
+        p.cancel("Cancelled.");
+        process.exit(0);
+      },
+    },
+  );
+
+  const tags = result.tags
+    ? result.tags.split(",").map((t) => t.trim().toLowerCase()).filter(Boolean)
+    : [];
+
+  const output = createPackage({
+    name: result.name,
+    type: result.type,
+    description: result.description ?? "",
+    author: result.author ?? "",
+    license: result.license || "MIT",
+    tags,
+    category: result.category,
   });
+
+  p.log.success(`Created ${output.files.join(", ")}`);
+  p.outro(`Edit ${output.files[1]}, then run \`planmode publish\` when ready.`);
 }
 
 export const initCommand = new Command("init")
   .description("Initialize a new package in the current directory")
   .action(async () => {
     try {
-      logger.blank();
-      logger.bold("Initialize a new Planmode package");
-      logger.blank();
-
-      const name = await prompt("Package name: ");
-      if (!name) {
-        logger.error("Package name is required.");
+      if (isInteractive()) {
+        await initInteractive();
+      } else {
+        // Non-interactive fallback: require all fields via env or fail
+        logger.error("Interactive terminal required for `planmode init`. Use a TTY.");
         process.exit(1);
       }
-
-      const typeInput = await prompt("Type (plan/rule/prompt) [plan]: ");
-      const type = (typeInput || "plan") as PackageType;
-
-      const description = await prompt("Description: ");
-      const author = await prompt("Author (GitHub username): ");
-      const license = (await prompt("License [MIT]: ")) || "MIT";
-      const tagsInput = await prompt("Tags (comma-separated): ");
-      const tags = tagsInput
-        ? tagsInput.split(",").map((t) => t.trim().toLowerCase())
-        : [];
-      const category =
-        ((await prompt(
-          "Category (frontend/backend/devops/database/testing/mobile/ai-ml/security/other) [other]: ",
-        )) || "other") as Category;
-
-      const result = createPackage({
-        name,
-        type,
-        description,
-        author,
-        license,
-        tags,
-        category,
-      });
-
-      logger.success(`Created ${result.files.join(", ")}`);
-      logger.blank();
-      logger.info(
-        `Edit ${result.files[1]}, then run \`planmode publish\` when ready.`,
-      );
-      logger.blank();
     } catch (err) {
       logger.error((err as Error).message);
       process.exit(1);

package/src/commands/install.ts

@@ -1,6 +1,8 @@
 import { Command } from "commander";
+import * as p from "@clack/prompts";
 import { installPackage } from "../lib/installer.js";
 import { logger } from "../lib/logger.js";
+import { isInteractive } from "../lib/prompts.js";
 
 function parseVariables(pairs: string[]): Record<string, string> {
   const vars: Record<string, string> = {};
@@ -27,15 +29,28 @@ export const installCommand = new Command("install")
       options: { version?: string; rule?: boolean; input?: boolean; set?: string[] },
     ) => {
       try {
-        logger.blank();
+        const interactive = isInteractive() && options.input !== false;
         const variables = options.set ? parseVariables(options.set) : undefined;
+
+        if (interactive) {
+          p.intro(`Installing ${packageName}`);
+        } else {
+          logger.blank();
+        }
+
         await installPackage(packageName, {
           version: options.version,
           forceRule: options.rule,
           noInput: options.input === false,
           variables,
+          interactive,
         });
-        logger.blank();
+
+        if (interactive) {
+          p.outro("Done!");
+        } else {
+          logger.blank();
+        }
       } catch (err) {
         logger.error((err as Error).message);
         process.exit(1);