@usemeno/meno-cli 0.1.0

package/src/commands/log.ts

@@ -0,0 +1,112 @@
+import enquirer from "enquirer";
+import chalk from "chalk";
+import ora from "ora";
+import { getSelectedProject } from "../config.js";
+import { apiRequest, ApiError, Project } from "../utils/api.js";
+import { parseDuration } from "../utils/timer.js";
+
+interface LogOptions {
+  duration?: string;
+  project?: string;
+}
+
+export async function logTime(description: string, options: LogOptions) {
+  console.log(chalk.bold("\n📝 Log Time Entry\n"));
+
+  let projectId = options.project;
+  let duration = options.duration ? parseDuration(options.duration) : null;
+  let projectName = "";
+  let hourlyRate = 0;
+
+  // Determine project
+  if (!projectId) {
+    const selected = getSelectedProject();
+    if (selected) {
+      projectId = selected.id;
+      projectName = selected.name;
+      hourlyRate = selected.hourlyRate;
+    } else {
+      // Need to prompt for project
+      const spinner = ora("Loading projects...").start();
+      try {
+        const { projects } = await apiRequest<{ projects: Project[] }>("/api/external/projects");
+        spinner.stop();
+
+        if (projects.length === 0) {
+          console.log(chalk.yellow("No active projects found.\n"));
+          return;
+        }
+
+        const result = await enquirer.prompt({
+          type: "select",
+          name: "project",
+          message: "Select a project:",
+          choices: projects.map((p) => ({
+            name: p.id,
+            message: `${p.name} (${p.clientName}) • $${p.hourlyRate}/hr`,
+            value: p,
+          })),
+        });
+
+        const answer = (result as any).project;
+
+        // enquirer returns the choice "name" (ID) not "value" (object)
+        const project = projects.find((p) => p.id === answer);
+        if (!project) {
+          console.log(chalk.red("Error: Selected project not found\n"));
+          return;
+        }
+
+        projectId = project.id;
+        projectName = project.name;
+        hourlyRate = project.hourlyRate;
+      } catch (error) {
+        spinner.fail(chalk.red("Failed to load projects"));
+        if (error instanceof ApiError) {
+          console.log(chalk.red(`\nError: ${error.message}\n`));
+        }
+        return;
+      }
+    }
+  }
+
+  // Parse duration if not provided
+  if (!duration) {
+    console.log(chalk.yellow("\n⚠ Duration is required. Use --duration flag (e.g., 45m, 1.5h)\n"));
+    return;
+  }
+
+  if (duration <= 0) {
+    console.log(chalk.red("\n✗ Invalid duration\n"));
+    return;
+  }
+
+  // Log the entry
+  const spinner = ora("Logging entry...").start();
+
+  try {
+    const response = await apiRequest("/api/external/time-entries", {
+      method: "POST",
+      body: JSON.stringify({
+        projectId,
+        description,
+        duration,
+        billable: true,
+      }),
+    });
+
+    const amount = duration * (hourlyRate || response.entry.amount / duration);
+    spinner.succeed(
+      chalk.green(`✓ Logged ${duration.toFixed(2)} hours to ${projectName || response.entry.projectName} ($${amount.toFixed(2)})`)
+    );
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to log entry"));
+    
+    if (error instanceof ApiError) {
+      console.log(chalk.red(`\nError: ${error.message}\n`));
+    } else {
+      console.log(chalk.red(`\nUnexpected error: ${(error as Error).message}\n`));
+    }
+  }
+}

package/src/commands/login.ts

@@ -0,0 +1,68 @@
+import enquirer from "enquirer";
+import ora from "ora";
+import chalk from "chalk";
+import { setApiKey, setBaseUrl } from "../config.js";
+import { apiRequest, ApiError} from "../utils/api.js";
+
+export async function login() {
+  console.log(chalk.bold("\n🔑 Meno CLI Login\n"));
+
+  try {
+    // Prompt for API key
+    const apiKeyPrompt = await enquirer.prompt({
+      type: "password",
+      name: "apiKey",
+      message: "Enter your API key:",
+      validate: (value: string) => {
+        if (!value || !value.startsWith("meno_sk_")) {
+          return "Invalid API key format. Expected: meno_sk_...";
+        }
+        return true;
+      },
+    });
+
+    const apiKey = (apiKeyPrompt as any).apiKey;
+
+    // Optional: Custom base URL
+    const baseUrlPrompt = await enquirer.prompt({
+      type: "input",
+      name: "baseUrl",
+      message: "Base URL (press Enter for default):",
+      initial: "http://localhost:3000",
+    });
+
+    const baseUrl = (baseUrlPrompt as any).baseUrl;
+
+    // Validate API key by making a test request
+    const spinner = ora("Validating API key...").start();
+
+    try {
+      // Temporarily set the key to test it
+      setApiKey(apiKey as string);
+      if (baseUrl) {
+        setBaseUrl(baseUrl as string);
+      }
+
+      // Test the key
+      await apiRequest("/api/external/projects");
+
+      spinner.succeed(chalk.green("✓ Logged in successfully!"));
+      console.log(chalk.dim(`\nAPI key stored securely.`));
+      console.log(chalk.dim(`Run ${chalk.bold("meno select")} to choose a project.\n`));
+    } catch (error) {
+      spinner.fail(chalk.red("✗ Authentication failed"));
+      
+      if (error instanceof ApiError) {
+        console.log(chalk.red(`\nError: ${error.message}\n`));
+      } else {
+        console.log(chalk.red(`\nUnexpected error: ${(error as Error).message}\n`));
+      }
+      
+      process.exit(1);
+    }
+  } catch (error) {
+    // User cancelled
+    console.log(chalk.yellow("\n✗ Login cancelled\n"));
+    process.exit(0);
+  }
+}

package/src/commands/select.ts

@@ -0,0 +1,86 @@
+import enquirer from "enquirer";
+import ora from "ora";
+import chalk from "chalk";
+import { setSelectedProject, clearSelectedProject, getSelectedProject } from "../config.js";
+import { apiRequest, ApiError, Project as ApiProject } from "../utils/api.js";
+
+export async function selectProject() {
+  console.log(chalk.bold("\n📂 Select Project\n"));
+
+  const spinner = ora("Loading projects...").start();
+
+  try {
+    const { projects } = await apiRequest<{ projects: ApiProject[] }>("/api/external/projects");
+
+    spinner.stop();
+
+    if (projects.length === 0) {
+      console.log(chalk.yellow("No active projects found."));
+      console.log(chalk.dim("Create a project in the web app first.\n"));
+      return;
+    }
+
+    const currentProject = getSelectedProject();
+
+    // Build choices
+    const choices = [
+      {
+        name: "clear",
+        message: chalk.dim("[Clear Selection]"),
+      },
+      ...projects.map((project) => {
+        const isSelected = currentProject?.id === project.id;
+        const prefix = isSelected ? "● " : "  ";
+        const displayName = `${project.name} (${project.clientName}) • $${project.hourlyRate}/hr`;
+        
+        return {
+          name: project.id,
+          message: prefix + displayName,
+          value: project,
+        };
+      }),
+    ];
+
+    const result = await enquirer.prompt({
+      type: "select",
+      name: "project",
+      message: "Select a project:",
+      choices,
+    });
+
+    const answer = (result as any).project;
+
+    if (answer === "clear") {
+      clearSelectedProject();
+      console.log(chalk.green("\n✓ Selection cleared\n"));
+    } else {
+      // Find the full project object by ID
+      const project = projects.find((p) => p.id === answer);
+      
+      if (!project) {
+        console.log(chalk.red("\n✗ Project not found\n"));
+        return;
+      }
+      
+      setSelectedProject({
+        id: project.id,
+        name: project.name,
+        clientName: project.clientName,
+        hourlyRate: project.hourlyRate,
+      });
+      console.log(
+        chalk.green(`\n✓ Selected: ${chalk.bold(project.name)} (${project.clientName}) • $${project.hourlyRate}/hr\n`)
+      );
+    }
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to load projects"));
+    
+    if (error instanceof ApiError) {
+      console.log(chalk.red(`\nError: ${error.message}\n`));
+    } else {
+      console.log(chalk.red(`\nUnexpected error: ${(error as Error).message}\n`));
+    }
+    
+    process.exit(1);
+  }
+}

package/src/commands/start.ts

@@ -0,0 +1,77 @@
+import chalk from "chalk";
+import ora from "ora";
+import { getSelectedProject, getActiveTimer, setActiveTimer } from "../config.js";
+import { apiRequest, ApiError, Project } from "../utils/api.js";
+import { formatDuration } from "../utils/timer.js";
+
+export async function startTimer(projectId?: string) {
+  // Check if timer is already running
+  const existingTimer = getActiveTimer();
+  if (existingTimer) {
+    const elapsed = formatDuration(existingTimer.startTime);
+    console.log(
+      chalk.yellow(
+        `\n⚠ Timer already running for ${chalk.bold(existingTimer.projectName)} (${elapsed})`
+      )
+    );
+    console.log(chalk.dim(`Stop it first with ${chalk.bold("meno stop")} or discard with ${chalk.bold("meno stop --discard")}\n`));
+    return;
+  }
+
+  let project: Project | undefined;
+
+  if (projectId) {
+    // Start with explicit project ID
+    const spinner = ora("Loading project...").start();
+    try {
+      const { projects } = await apiRequest<{ projects: Project[] }>("/api/external/projects");
+      project = projects.find((p) => p.id === projectId);
+      spinner.stop();
+
+      if (!project) {
+        console.log(chalk.red(`\n✗ Project not found: ${projectId}\n`));
+        return;
+      }
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to load project"));
+      if (error instanceof ApiError) {
+        console.log(chalk.red(`\nError: ${error.message}\n`));
+      }
+      return;
+    }
+  } else {
+    // Use selected project
+    const selected = getSelectedProject();
+    if (!selected) {
+      console.log(chalk.yellow(`\n⚠ No project selected.`));
+      console.log(chalk.dim(`Run ${chalk.bold("meno select")} first or provide a project ID: ${chalk.bold("meno start <project-id>")}\n`));
+      return;
+    }
+
+    project = {
+      id: selected.id,
+      name: selected.name,
+      clientName: selected.clientName,
+      clientCompany: "",
+      hourlyRate: selected.hourlyRate,
+      taxRate: 0,
+      weeklyHourLimit: 0,
+      hoursUsed: 0,
+    };
+  }
+
+  // Start the timer
+  const startTime = new Date().toISOString();
+  setActiveTimer({
+    projectId: project.id,
+    projectName: project.name,
+    startTime,
+  });
+
+  const timestamp = new Date().toLocaleTimeString();
+  console.log(
+    chalk.green(
+      `\n⏱️  Started: ${chalk.bold(project.name)} • $${project.hourlyRate}/hr • [${timestamp}]\n`
+    )
+  );
+}

package/src/commands/status.ts

@@ -0,0 +1,62 @@
+import chalk from "chalk";
+import ora from "ora";
+import { getSelectedProject, getActiveTimer } from "../config.js";
+import { apiRequest, ApiError, Stats } from "../utils/api.js";
+import { formatDuration, calculateTimerValue } from "../utils/timer.js";
+
+export async function showStatus() {
+  console.log(chalk.bold("\n📊 Meno Status\n"));
+
+  const selected = getSelectedProject();
+  const timer = getActiveTimer();
+
+  // Show selected project
+  if (selected) {
+    console.log(
+      chalk.cyan(
+        `📌 Selected: ${chalk.bold(selected.name)} (${selected.clientName}) • $${selected.hourlyRate}/hr`
+      )
+    );
+  }
+
+  // Show active timer
+  if (timer) {
+    const elapsed = formatDuration(timer.startTime);
+    const value = calculateTimerValue(timer.startTime, selected?.hourlyRate || 0);
+    console.log(
+      chalk.green(
+        `⏱️  Running: ${chalk.bold(timer.projectName)} • ${elapsed} • $${value.toFixed(2)}`
+      )
+    );
+  }
+
+  if (selected || timer) {
+    console.log(); // Add spacing
+  }
+
+  // Fetch unbilled stats
+  const spinner = ora("Loading stats...").start();
+
+  try {
+    const stats = await apiRequest<Stats>("/api/external/stats");
+    spinner.stop();
+
+    console.log(
+      chalk.green.bold(`💰 Unbilled Revenue: $${stats.totalRevenue.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`)
+    );
+    console.log(
+      chalk.dim(
+        `⏱️  Total Hours: ${stats.totalHours.toFixed(1)} hours across ${stats.entriesCount} ${stats.entriesCount === 1 ? "entry" : "entries"}`
+      )
+    );
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to load stats"));
+    
+    if (error instanceof ApiError) {
+      console.log(chalk.red(`\nError: ${error.message}\n`));
+    } else {
+      console.log(chalk.red(`\nUnexpected error: ${(error as Error).message}\n`));
+    }
+  }
+}

package/src/commands/stop.ts

@@ -0,0 +1,132 @@
+import enquirer from "enquirer";
+import chalk from "chalk";
+import ora from "ora";
+import { getActiveTimer, clearActiveTimer, getSelectedProject } from "../config.js";
+import { apiRequest, ApiError } from "../utils/api.js";
+import { formatDuration, calculateElapsedHours, parseDuration } from "../utils/timer.js";
+
+interface StopOptions {
+  discard?: boolean;
+  description?: string;
+  noConfirm?: boolean;
+  yes?: boolean;
+  adjust?: string;
+}
+
+export async function stopTimer(options: StopOptions) {
+  const timer = getActiveTimer();
+
+  if (!timer) {
+    console.log(chalk.yellow(`\n⚠ No active timer.`));
+    console.log(chalk.dim(`Start one with ${chalk.bold("meno start")}\n`));
+    return;
+  }
+
+  // If discard flag, just clear and exit
+  if (options.discard) {
+    clearActiveTimer();
+    console.log(chalk.yellow(`\n✗ Timer discarded\n`));
+    return;
+  }
+
+  // Calculate duration (or use adjusted duration)
+  let duration: number;
+  let formatted: string;
+  
+  if (options.adjust) {
+    // Parse adjusted duration
+    duration = parseDuration(options.adjust);
+    if (duration === 0) {
+      console.log(chalk.red(`\n✗ Invalid duration format: ${options.adjust}\n`));
+      console.log(chalk.dim(`Use format like: 1.5h, 90m, 45\n`));
+      return;
+    }
+    const hours = Math.floor(duration);
+    const minutes = Math.round((duration - hours) * 60);
+    formatted = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+    console.log(chalk.yellow(`\n⚠ Adjusted duration from timer\n`));
+  } else {
+    duration = calculateElapsedHours(timer.startTime);
+    formatted = formatDuration(timer.startTime);
+  }
+  
+  // Get project details for rate calculation
+  const project = getSelectedProject();
+  const hourlyRate = project?.hourlyRate || 0;
+  const amount = duration * hourlyRate;
+
+  console.log(chalk.bold(`\n⏱️  Duration: ${formatted} • $${amount.toFixed(2)}\n`));
+
+  let description: string;
+  let shouldLog = true;
+
+  try {
+    // Get description (from flag or prompt)
+    if (options.description) {
+      description = options.description;
+      console.log(chalk.dim(`Description: ${description}\n`));
+    } else {
+      const descResult = await enquirer.prompt({
+        type: "input",
+        name: "description",
+        message: "What were you working on?",
+        initial: timer.description || "",
+        validate: (value: string) => {
+          if (!value || value.trim().length === 0) {
+            return "Description is required";
+          }
+          return true;
+        },
+      });
+      description = (descResult as any).description;
+    }
+
+    // Confirm logging (unless --no-confirm or -y flag)
+    const skipConfirm = options.noConfirm || options.yes;
+    if (!skipConfirm) {
+      const confirmResult = await enquirer.prompt({
+        type: "confirm",
+        name: "shouldLog",
+        message: "Log this entry?",
+        initial: true,
+      });
+      shouldLog = (confirmResult as any).shouldLog;
+
+      if (!shouldLog) {
+        console.log(chalk.yellow("\n✗ Entry not logged\n"));
+        return;
+      }
+    }
+
+    // Log the entry
+    const spinner = ora("Logging entry...").start();
+
+    try {
+      const response = await apiRequest("/api/external/time-entries", {
+        method: "POST",
+        body: JSON.stringify({
+          projectId: timer.projectId,
+          description: description,
+          duration: Math.round(duration * 100) / 100, // Round to 2 decimals
+          date: new Date().toISOString().split("T")[0], // Today
+          billable: true,
+        }),
+      });
+
+      clearActiveTimer();
+      spinner.succeed(chalk.green(`✓ Logged ${duration.toFixed(2)} hours to ${timer.projectName}`));
+      console.log(chalk.dim(`\nEntry created successfully\n`));
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to log entry"));
+      
+      if (error instanceof ApiError) {
+        console.log(chalk.red(`\nError: ${error.message}\n`));
+      } else {
+        console.log(chalk.red(`\nUnexpected error: ${(error as Error).message}\n`));
+      }
+    }
+  } catch (error) {
+    // User cancelled
+    console.log(chalk.yellow("\n✗ Cancelled\n"));
+  }
+}

package/src/config.ts

@@ -0,0 +1,76 @@
+import Conf from "conf";
+
+interface Config {
+  apiKey?: string;
+  baseUrl?: string;
+  selectedProject?: {
+    id: string;
+    name: string;
+    clientName: string;
+    hourlyRate: number;
+  };
+  activeTimer?: {
+    projectId: string;
+    projectName: string;
+    startTime: string;
+    description?: string;
+  };
+}
+
+const config = new Conf<Config>({
+  projectName: "meno-cli",
+});
+
+export function getApiKey(): string | undefined {
+  return config.get("apiKey");
+}
+
+export function setApiKey(key: string): void {
+  config.set("apiKey", key);
+}
+
+export function getBaseUrl(): string {
+  return config.get("baseUrl") || process.env.MENO_BASE_URL || "http://localhost:3000";
+}
+
+export function setBaseUrl(url: string): void {
+  config.set("baseUrl", url);
+}
+
+export function getSelectedProject() {
+  return config.get("selectedProject");
+}
+
+export function setSelectedProject(project: {
+  id: string;
+  name: string;
+  clientName: string;
+  hourlyRate: number;
+}): void {
+  config.set("selectedProject", project);
+}
+
+export function clearSelectedProject(): void {
+  config.delete("selectedProject");
+}
+
+export function getActiveTimer() {
+  return config.get("activeTimer");
+}
+
+export function setActiveTimer(timer: {
+  projectId: string;
+  projectName: string;
+  startTime: string;
+  description?: string;
+}): void {
+  config.set("activeTimer", timer);
+}
+
+export function clearActiveTimer(): void {
+  config.delete("activeTimer");
+}
+
+export function clearConfig(): void {
+  config.clear();
+}

package/src/index.ts

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { Command } from "commander";
+import { login } from "./commands/login.js";
+import { selectProject } from "./commands/select.js";
+import { startTimer } from "./commands/start.js";
+import { stopTimer } from "./commands/stop.js";
+import { logTime } from "./commands/log.js";
+import { showStatus } from "./commands/status.js";
+
+const program = new Command();
+
+program
+  .name("meno")
+  .description("CLI for Meno time tracking")
+  .version("0.1.0");
+
+program
+  .command("login")
+  .description("Authenticate with your Meno API key")
+  .action(login);
+
+program
+  .command("select")
+  .description("Select a project to work on")
+  .action(selectProject);
+
+program
+  .command("start [project-id]")
+  .description("Start a timer on selected project or specific project ID")
+  .action(startTimer);
+
+program
+  .command("stop")
+  .description("Stop the running timer and log the entry")
+  .option("--discard", "Discard the timer without logging")
+  .option("-d, --description <text>", "Entry description (skip prompt)")
+  .option("-y, --yes", "Auto-confirm (skip confirmation prompt)")
+  .option("--no-confirm", "Skip confirmation prompt")
+  .option("--adjust <duration>", "Override calculated duration (e.g., 1.5h, 45m)")
+  .action(stopTimer);
+
+program
+  .command("log <description>")
+  .description("Log time manually")
+  .option("-d, --duration <duration>", "Duration (e.g., 45m, 1.5h, 90)")
+  .option("-p, --project <id>", "Project ID")
+  .action(logTime);
+
+program
+  .command("status")
+  .description("Show selected project, timer status, and unbilled stats")
+  .action(showStatus);
+
+program.parse();