@ollie-shop/cli 0.1.3 → 0.3.0

package/src/utils/command-suggestions.ts

@@ -0,0 +1,176 @@
+import chalk from "chalk";
+import type { CliConsole } from "./console.js";
+import { detectProjectContext } from "./context-detector.js";
+
+interface CommandSuggestion {
+  command: string;
+  description: string;
+}
+
+export class CommandSuggestions {
+  constructor(private console: CliConsole) {}
+
+  /**
+   * Show context-aware command suggestions
+   */
+  show(): void {
+    const context = detectProjectContext();
+
+    // Show header
+    this.console.log("");
+
+    // Show current context
+    this.showCurrentContext(context);
+
+    // Show relevant commands
+    this.showContextCommands(context);
+
+    // Show recent commands if available
+    this.showRecentCommands();
+
+    // Show helpful tip
+    this.showTip(context);
+  }
+
+  /**
+   * Show current directory context
+   */
+  private showCurrentContext(
+    context: ReturnType<typeof detectProjectContext>,
+  ): void {
+    this.console.log(chalk.blue("📍 Current location:"));
+
+    if (context.type === "component") {
+      this.console.log(
+        `  You're in a component directory: ${chalk.cyan(context.name || "unknown")}`,
+      );
+    } else if (context.type === "function") {
+      this.console.log(
+        `  You're in a function directory: ${chalk.cyan(context.name || "unknown")}`,
+      );
+    } else if (context.parentPath) {
+      this.console.log(`  You're in the project root`);
+    } else {
+      this.console.log(`  ${process.cwd()}`);
+    }
+
+    this.console.log("");
+  }
+
+  /**
+   * Show commands relevant to current context
+   */
+  private showContextCommands(
+    context: ReturnType<typeof detectProjectContext>,
+  ): void {
+    let commands: CommandSuggestion[] = [];
+
+    if (context.type === "component") {
+      commands = [
+        { command: "validate", description: "Check component validity" },
+        { command: "build", description: "Build for production" },
+        { command: "dev", description: "Start development server" },
+        { command: "deploy", description: "Deploy to cloud" },
+      ];
+
+      this.console.log(chalk.blue("Common commands for this component:"));
+    } else if (context.type === "function") {
+      commands = [
+        { command: "validate", description: "Check function validity" },
+        { command: "build", description: "Build function" },
+        { command: "test", description: "Run function tests" },
+        { command: "deploy", description: "Deploy to cloud" },
+      ];
+
+      this.console.log(chalk.blue("Common commands for this function:"));
+    } else {
+      commands = [
+        { command: "component create", description: "Create a new component" },
+        { command: "function create", description: "Create a new function" },
+        { command: "component list", description: "List all components" },
+        { command: "function list", description: "List all functions" },
+      ];
+
+      this.console.log(chalk.blue("Common commands:"));
+    }
+
+    // Display commands
+    const maxCmdLength = Math.max(...commands.map((c) => c.command.length));
+    for (const { command, description } of commands) {
+      const paddedCmd = command.padEnd(maxCmdLength + 2);
+      this.console.log(`  ${chalk.cyan(paddedCmd)} ${chalk.dim(description)}`);
+    }
+
+    this.console.log("");
+  }
+
+  /**
+   * Show recently used commands
+   */
+  private showRecentCommands(): void {
+    // TODO: In a real implementation, we'd read from a history file
+    // For now, we'll show some common commands
+    const recentCommands = this.getMockRecentCommands();
+
+    if (recentCommands.length > 0) {
+      this.console.log(chalk.blue("Recent commands:"));
+      for (const { command, timeAgo } of recentCommands) {
+        this.console.log(
+          chalk.dim(`  ollieshop ${command} ${chalk.dim(`(${timeAgo})`)}`),
+        );
+      }
+      this.console.log("");
+    }
+  }
+
+  /**
+   * Show helpful tip based on context
+   */
+  private showTip(context: ReturnType<typeof detectProjectContext>): void {
+    let tip = "";
+
+    if (context.type === "component") {
+      tip = "Run 'ollieshop dev' to start developing this component";
+    } else if (context.type === "function") {
+      tip = "Run 'ollieshop test' to test this function locally";
+    } else if (context.parentPath) {
+      tip =
+        "Navigate to a component with 'cd components/<name>' or create one with 'ollieshop component create'";
+    } else {
+      tip = "Run 'ollieshop --help' to see all available commands";
+    }
+
+    this.console.log(chalk.yellow(`💡 Tip: ${tip}`));
+  }
+
+  /**
+   * Get mock recent commands for demo
+   * TODO: Implement actual command history
+   */
+  private getMockRecentCommands(): Array<{ command: string; timeAgo: string }> {
+    const context = detectProjectContext();
+
+    if (context.type === "component") {
+      return [
+        { command: "validate --fix", timeAgo: "2 min ago" },
+        { command: "build --watch", timeAgo: "1 hour ago" },
+      ];
+    }
+    if (context.type === "function") {
+      return [
+        { command: "test", timeAgo: "5 min ago" },
+        { command: "validate", timeAgo: "30 min ago" },
+      ];
+    }
+
+    return [];
+  }
+}
+
+/**
+ * Show command suggestions for the current context
+ */
+export function showCommandSuggestions(console: CliConsole): void {
+  const suggestions = new CommandSuggestions(console);
+  suggestions.show();
+}

package/src/utils/console.ts

@@ -0,0 +1,291 @@
+import chalk from "chalk";
+import ora, { type Ora } from "ora";
+import type { OllieShopCLIError } from "./errors";
+
+export interface ConsoleOptions {
+  quiet?: boolean;
+  verbose?: boolean;
+  noColor?: boolean;
+}
+
+export class Console {
+  private options: ConsoleOptions = {
+    quiet: false,
+    verbose: false,
+    noColor: false,
+  };
+  private prefix = chalk.blue.bold("[ollie]");
+
+  setOptions(options: ConsoleOptions = {}) {
+    this.options = { ...this.options, ...options };
+
+    if (options.noColor) {
+      chalk.level = 0;
+    }
+  }
+
+  hint(message: string) {
+    const text = chalk.gray(message);
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  status(message: string) {
+    global.console.log(`${this.prefix} ${message}`);
+  }
+
+  info(message: string) {
+    const text = `${chalk.blue("ℹ")} ${message}`;
+
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  warn(message: string) {
+    const text = `${chalk.yellow("⚠")} ${chalk.yellow(message)}`;
+    if (!this.options.quiet) {
+      global.console.warn(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  success(message: string) {
+    const text = `${chalk.green("✓")} ${chalk.green(message)}`;
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  error(message: string | OllieShopCLIError) {
+    if (typeof message === "string") {
+      const text = `${chalk.red("✗")} ${chalk.red.bold(message)}`;
+      global.console.error(`${this.prefix} ${text}`);
+      return text;
+    }
+
+    // Handle OllieShopCLIError with rich context
+    const text = `${chalk.red("✗")} ${chalk.red.bold(message.message)}`;
+    global.console.error(`${this.prefix} ${text}`);
+
+    if (message.context.command) {
+      global.console.error(
+        `${this.prefix}   Command: ${chalk.cyan(message.context.command)}`,
+      );
+    }
+
+    if (message.context.file) {
+      global.console.error(
+        `${this.prefix}   File: ${chalk.cyan(message.context.file)}`,
+      );
+    }
+
+    if (message.recoveryActions.length > 0) {
+      global.console.error(`${this.prefix} ${chalk.yellow("💡 Suggestions")}:`);
+      for (const action of message.recoveryActions) {
+        global.console.error(`${this.prefix}   • ${action.description}`);
+        if (action.command) {
+          global.console.error(
+            `${this.prefix}     ${chalk.gray("$")} ${chalk.yellow(action.command)}`,
+          );
+        }
+      }
+    }
+
+    return text;
+  }
+
+  prompt(message: string) {
+    const text = chalk.cyan(message);
+    if (!this.options.quiet) {
+      process.stdout.write(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  header(message: string) {
+    const text = chalk.bold.blue(message);
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  processing(message: string) {
+    const text = chalk.blue(message);
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  cancelled(message: string) {
+    const text = chalk.red(message);
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  important(path: string) {
+    const text = chalk.bold(path);
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  code(message: string) {
+    const text = chalk.cyan(message);
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${text}`);
+    }
+
+    return text;
+  }
+
+  // Additional methods needed by CLI commands
+  debug(message: string) {
+    if (this.options.quiet || !this.options.verbose) return;
+
+    const text = `${chalk.gray("🐛")} ${chalk.gray(message)}`;
+    global.console.log(`${this.prefix} ${text}`);
+
+    return text;
+  }
+
+  log(message: string) {
+    if (!this.options.quiet) {
+      global.console.log(`${this.prefix} ${message}`);
+    }
+
+    return message;
+  }
+
+  newLine() {
+    if (!this.options.quiet) {
+      global.console.log("");
+    }
+  }
+
+  nextSteps(
+    title: string,
+    steps: Array<{ description: string; command?: string }>,
+  ) {
+    if (this.options.quiet) return;
+
+    this.newLine();
+    this.info(title);
+
+    for (const step of steps) {
+      this.log(`  • ${step.description}`);
+      if (step.command) {
+        this.log(`    ${chalk.gray("$")} ${chalk.yellow(step.command)}`);
+      }
+    }
+    this.newLine();
+  }
+
+  suggestions(items: string[]) {
+    if (this.options.quiet) return;
+
+    this.newLine();
+    this.info("Suggestions:");
+
+    for (const item of items) {
+      this.log(`  • ${item}`);
+    }
+    this.newLine();
+  }
+
+  dim(message: string) {
+    const text = chalk.dim(message);
+    if (!this.options.quiet) {
+      global.console.log(text);
+    }
+    return text;
+  }
+
+  bold(message: string) {
+    return chalk.bold(message);
+  }
+
+  table(data: Array<Record<string, string | number | boolean>>) {
+    if (this.options.quiet || data.length === 0) return;
+    global.console.table(data);
+  }
+
+  json(data: Record<string, unknown> | Array<unknown>) {
+    if (this.options.quiet) return;
+    global.console.log(JSON.stringify(data, null, 2));
+  }
+
+  async confirm(message: string): Promise<boolean> {
+    // For now, return false in non-interactive mode
+    // TODO: Implement interactive confirmation
+    this.warn(`${message} (y/N)`);
+    return false;
+  }
+
+  listResults<T>(items: T[], formatter: (item: T) => string) {
+    if (this.options.quiet) return;
+
+    if (items.length === 0) {
+      this.warn("No items found");
+      return;
+    }
+
+    this.info(`Found ${items.length} item(s):`);
+    this.newLine();
+
+    for (const item of items) {
+      this.log(formatter(item));
+    }
+  }
+
+  // Clean spinner implementation using ora with proper cleanup
+  spinner(options: { text: string } | string): Ora {
+    const text = typeof options === "string" ? options : options.text;
+
+    if (this.options.quiet) {
+      // Return a mock spinner for quiet mode
+      return {
+        start: () => this.spinner(options),
+        stop: () => this.spinner(options),
+        succeed: (msg?: string) => {
+          if (msg) this.success(msg);
+          return this.spinner(options);
+        },
+        fail: (msg?: string) => {
+          if (msg) this.error(msg);
+          return this.spinner(options);
+        },
+      } as Ora;
+    }
+
+    // Create a real spinner using ora with prefix
+    return ora({
+      text,
+      color: "cyan",
+      prefixText: this.prefix,
+    });
+  }
+}
+
+// Export Console type for backwards compatibility
+export type CliConsole = Console;
+
+export const console = new Console();

package/src/utils/context-detector.ts

@@ -0,0 +1,177 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface ProjectContext {
+  type: "component" | "function" | "unknown";
+  path: string;
+  name?: string;
+  parentPath?: string;
+}
+
+/**
+ * Detect if we're in a component or function directory
+ * by looking for characteristic files
+ */
+function checkForMetaType(
+  cwd: string,
+  hasComponentIndex: boolean,
+  hasFunctionIndex: boolean,
+): ProjectContext | null {
+  try {
+    const metaContent = fs.readFileSync(path.join(cwd, "meta.json"), "utf-8");
+    const meta = JSON.parse(metaContent);
+    const name = meta.name || path.basename(cwd);
+
+    if (meta.type === "component" || hasComponentIndex) {
+      return { type: "component", path: cwd, name };
+    }
+
+    if (meta.type === "function" || hasFunctionIndex) {
+      return { type: "function", path: cwd, name };
+    }
+  } catch (_error) {
+    // If meta.json is invalid, return null to fall back
+  }
+
+  return null;
+}
+
+function checkByFilePresence(
+  cwd: string,
+  hasComponentIndex: boolean,
+  hasFunctionIndex: boolean,
+): ProjectContext | null {
+  const name = path.basename(cwd);
+
+  if (hasComponentIndex) {
+    return { type: "component", path: cwd, name };
+  }
+
+  if (hasFunctionIndex) {
+    return { type: "function", path: cwd, name };
+  }
+
+  return null;
+}
+
+function checkParentDirectory(cwd: string): ProjectContext | null {
+  const componentsDir = path.join(cwd, "components");
+  const functionsDir = path.join(cwd, "functions");
+
+  if (
+    fs.existsSync(componentsDir) &&
+    fs.statSync(componentsDir).isDirectory()
+  ) {
+    return { type: "unknown", path: cwd, parentPath: cwd };
+  }
+
+  if (fs.existsSync(functionsDir) && fs.statSync(functionsDir).isDirectory()) {
+    return { type: "unknown", path: cwd, parentPath: cwd };
+  }
+
+  return null;
+}
+
+function checkInsideSubdirectory(cwd: string): ProjectContext | null {
+  const pathParts = cwd.split(path.sep);
+  const componentsIndex = pathParts.lastIndexOf("components");
+  const functionsIndex = pathParts.lastIndexOf("functions");
+
+  if (componentsIndex !== -1 && componentsIndex === pathParts.length - 2) {
+    return {
+      type: "component",
+      path: cwd,
+      name: pathParts[componentsIndex + 1],
+    };
+  }
+
+  if (functionsIndex !== -1 && functionsIndex === pathParts.length - 2) {
+    return {
+      type: "function",
+      path: cwd,
+      name: pathParts[functionsIndex + 1],
+    };
+  }
+
+  return null;
+}
+
+export function detectProjectContext(
+  cwd: string = process.cwd(),
+): ProjectContext {
+  const hasPackageJson = fs.existsSync(path.join(cwd, "package.json"));
+  const hasMetaJson = fs.existsSync(path.join(cwd, "meta.json"));
+  const hasComponentIndex =
+    fs.existsSync(path.join(cwd, "index.tsx")) ||
+    fs.existsSync(path.join(cwd, "index.jsx"));
+  const hasFunctionIndex =
+    fs.existsSync(path.join(cwd, "index.ts")) ||
+    fs.existsSync(path.join(cwd, "index.js"));
+
+  // If we have the basic files, determine the type
+  if (hasPackageJson && hasMetaJson) {
+    const metaResult = checkForMetaType(
+      cwd,
+      hasComponentIndex,
+      hasFunctionIndex,
+    );
+    if (metaResult) return metaResult;
+
+    const fileResult = checkByFilePresence(
+      cwd,
+      hasComponentIndex,
+      hasFunctionIndex,
+    );
+    if (fileResult) return fileResult;
+  }
+
+  // Check parent directory
+  const parentResult = checkParentDirectory(cwd);
+  if (parentResult) return parentResult;
+
+  // Check if inside subdirectory
+  const subdirResult = checkInsideSubdirectory(cwd);
+  if (subdirResult) return subdirResult;
+
+  return { type: "unknown", path: cwd };
+}
+
+/**
+ * Get the appropriate path for a command based on context
+ */
+export function getContextualPath(
+  explicitPath: string | undefined,
+  expectedType: "component" | "function",
+): string {
+  // If explicit path provided, use it
+  if (explicitPath) {
+    return explicitPath;
+  }
+
+  // Detect current context
+  const context = detectProjectContext();
+
+  // If we're in the right type of directory, use current directory
+  if (context.type === expectedType) {
+    return context.path;
+  }
+
+  // If we're in a parent directory, provide helpful error
+  if (context.type === "unknown" && context.parentPath) {
+    const subdir = expectedType === "component" ? "components" : "functions";
+    throw new Error(
+      `No ${expectedType} found in current directory.\nTry navigating to a ${expectedType} directory:\n  cd ${subdir}/<${expectedType}-name>\nOr specify the path:\n  --path ./${subdir}/<${expectedType}-name>`,
+    );
+  }
+
+  // Wrong context type
+  if (context.type !== "unknown" && context.type !== expectedType) {
+    throw new Error(
+      `Current directory appears to be a ${context.type}, not a ${expectedType}.\n` +
+        `Please navigate to a ${expectedType} directory or specify --path`,
+    );
+  }
+
+  // Default to current directory
+  return process.cwd();
+}