@usemeno/meno-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,626 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/login.ts
+import enquirer from "enquirer";
+import ora from "ora";
+import chalk from "chalk";
+
+// src/config.ts
+import Conf from "conf";
+var config = new Conf({
+  projectName: "meno-cli"
+});
+function getApiKey() {
+  return config.get("apiKey");
+}
+function setApiKey(key) {
+  config.set("apiKey", key);
+}
+function getBaseUrl() {
+  return config.get("baseUrl") || process.env.MENO_BASE_URL || "http://localhost:3000";
+}
+function setBaseUrl(url) {
+  config.set("baseUrl", url);
+}
+function getSelectedProject() {
+  return config.get("selectedProject");
+}
+function setSelectedProject(project) {
+  config.set("selectedProject", project);
+}
+function clearSelectedProject() {
+  config.delete("selectedProject");
+}
+function getActiveTimer() {
+  return config.get("activeTimer");
+}
+function setActiveTimer(timer) {
+  config.set("activeTimer", timer);
+}
+function clearActiveTimer() {
+  config.delete("activeTimer");
+}
+
+// src/utils/api.ts
+import fetch from "node-fetch";
+var ApiError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "ApiError";
+  }
+};
+async function apiRequest(endpoint, options = {}) {
+  const apiKey = getApiKey();
+  const baseUrl = getBaseUrl();
+  if (!apiKey) {
+    throw new ApiError(
+      "Not logged in. Run 'meno login' to authenticate.",
+      401
+    );
+  }
+  const url = `${baseUrl}${endpoint}`;
+  const headers = {
+    "Authorization": `Bearer ${apiKey}`,
+    "Content-Type": "application/json",
+    ...options.headers
+  };
+  try {
+    const response = await fetch(url, {
+      ...options,
+      headers
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      if (response.status === 401) {
+        throw new ApiError(
+          "Invalid API key. Run 'meno login' to re-authenticate.",
+          401
+        );
+      }
+      if (response.status === 429) {
+        throw new ApiError(
+          `Rate limit exceeded. ${data.error || "Try again later."}`,
+          429
+        );
+      }
+      throw new ApiError(
+        data.error || `Request failed with status ${response.status}`,
+        response.status
+      );
+    }
+    return data;
+  } catch (error) {
+    if (error instanceof ApiError) {
+      throw error;
+    }
+    if (error.code === "ENOTFOUND" || error.code === "ECONNREFUSED") {
+      throw new ApiError(
+        `Cannot connect to ${baseUrl}. Check your internet connection or base URL.`,
+        0
+      );
+    }
+    throw new ApiError(
+      error.message || "An unexpected error occurred",
+      500
+    );
+  }
+}
+
+// src/commands/login.ts
+async function login() {
+  console.log(chalk.bold("\n\u{1F511} Meno CLI Login\n"));
+  try {
+    const apiKeyPrompt = await enquirer.prompt({
+      type: "password",
+      name: "apiKey",
+      message: "Enter your API key:",
+      validate: (value) => {
+        if (!value || !value.startsWith("meno_sk_")) {
+          return "Invalid API key format. Expected: meno_sk_...";
+        }
+        return true;
+      }
+    });
+    const apiKey = apiKeyPrompt.apiKey;
+    const baseUrlPrompt = await enquirer.prompt({
+      type: "input",
+      name: "baseUrl",
+      message: "Base URL (press Enter for default):",
+      initial: "http://localhost:3000"
+    });
+    const baseUrl = baseUrlPrompt.baseUrl;
+    const spinner = ora("Validating API key...").start();
+    try {
+      setApiKey(apiKey);
+      if (baseUrl) {
+        setBaseUrl(baseUrl);
+      }
+      await apiRequest("/api/external/projects");
+      spinner.succeed(chalk.green("\u2713 Logged in successfully!"));
+      console.log(chalk.dim(`
+API key stored securely.`));
+      console.log(chalk.dim(`Run ${chalk.bold("meno select")} to choose a project.
+`));
+    } catch (error) {
+      spinner.fail(chalk.red("\u2717 Authentication failed"));
+      if (error instanceof ApiError) {
+        console.log(chalk.red(`
+Error: ${error.message}
+`));
+      } else {
+        console.log(chalk.red(`
+Unexpected error: ${error.message}
+`));
+      }
+      process.exit(1);
+    }
+  } catch (error) {
+    console.log(chalk.yellow("\n\u2717 Login cancelled\n"));
+    process.exit(0);
+  }
+}
+
+// src/commands/select.ts
+import enquirer2 from "enquirer";
+import ora2 from "ora";
+import chalk2 from "chalk";
+async function selectProject() {
+  console.log(chalk2.bold("\n\u{1F4C2} Select Project\n"));
+  const spinner = ora2("Loading projects...").start();
+  try {
+    const { projects } = await apiRequest("/api/external/projects");
+    spinner.stop();
+    if (projects.length === 0) {
+      console.log(chalk2.yellow("No active projects found."));
+      console.log(chalk2.dim("Create a project in the web app first.\n"));
+      return;
+    }
+    const currentProject = getSelectedProject();
+    const choices = [
+      {
+        name: "clear",
+        message: chalk2.dim("[Clear Selection]")
+      },
+      ...projects.map((project) => {
+        const isSelected = currentProject?.id === project.id;
+        const prefix = isSelected ? "\u25CF " : "  ";
+        const displayName = `${project.name} (${project.clientName}) \u2022 $${project.hourlyRate}/hr`;
+        return {
+          name: project.id,
+          message: prefix + displayName,
+          value: project
+        };
+      })
+    ];
+    const result = await enquirer2.prompt({
+      type: "select",
+      name: "project",
+      message: "Select a project:",
+      choices
+    });
+    const answer = result.project;
+    if (answer === "clear") {
+      clearSelectedProject();
+      console.log(chalk2.green("\n\u2713 Selection cleared\n"));
+    } else {
+      const project = projects.find((p) => p.id === answer);
+      if (!project) {
+        console.log(chalk2.red("\n\u2717 Project not found\n"));
+        return;
+      }
+      setSelectedProject({
+        id: project.id,
+        name: project.name,
+        clientName: project.clientName,
+        hourlyRate: project.hourlyRate
+      });
+      console.log(
+        chalk2.green(`
+\u2713 Selected: ${chalk2.bold(project.name)} (${project.clientName}) \u2022 $${project.hourlyRate}/hr
+`)
+      );
+    }
+  } catch (error) {
+    spinner.fail(chalk2.red("Failed to load projects"));
+    if (error instanceof ApiError) {
+      console.log(chalk2.red(`
+Error: ${error.message}
+`));
+    } else {
+      console.log(chalk2.red(`
+Unexpected error: ${error.message}
+`));
+    }
+    process.exit(1);
+  }
+}
+
+// src/commands/start.ts
+import chalk3 from "chalk";
+import ora3 from "ora";
+
+// src/utils/timer.ts
+function formatDuration(startTime) {
+  const elapsed = Date.now() - new Date(startTime).getTime();
+  const hours = Math.floor(elapsed / (1e3 * 60 * 60));
+  const minutes = Math.floor(elapsed % (1e3 * 60 * 60) / (1e3 * 60));
+  if (hours > 0) {
+    return `${hours} ${hours === 1 ? "hour" : "hours"} ${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+  }
+  return `${minutes} ${minutes === 1 ? "minute" : "minutes"}`;
+}
+function calculateElapsedHours(startTime) {
+  const elapsed = Date.now() - new Date(startTime).getTime();
+  return elapsed / (1e3 * 60 * 60);
+}
+function calculateTimerValue(startTime, hourlyRate) {
+  const hours = calculateElapsedHours(startTime);
+  return hours * hourlyRate;
+}
+function parseDuration(input) {
+  const trimmed = input.trim().toLowerCase();
+  const minutesMatch = trimmed.match(/^(\d+(?:\.\d+)?)m?$/);
+  const hoursMatch = trimmed.match(/^(\d+(?:\.\d+)?)h$/);
+  if (hoursMatch) {
+    return parseFloat(hoursMatch[1]);
+  }
+  if (minutesMatch) {
+    const minutes = parseFloat(minutesMatch[1]);
+    return minutes / 60;
+  }
+  return null;
+}
+
+// src/commands/start.ts
+async function startTimer(projectId) {
+  const existingTimer = getActiveTimer();
+  if (existingTimer) {
+    const elapsed = formatDuration(existingTimer.startTime);
+    console.log(
+      chalk3.yellow(
+        `
+\u26A0 Timer already running for ${chalk3.bold(existingTimer.projectName)} (${elapsed})`
+      )
+    );
+    console.log(chalk3.dim(`Stop it first with ${chalk3.bold("meno stop")} or discard with ${chalk3.bold("meno stop --discard")}
+`));
+    return;
+  }
+  let project;
+  if (projectId) {
+    const spinner = ora3("Loading project...").start();
+    try {
+      const { projects } = await apiRequest("/api/external/projects");
+      project = projects.find((p) => p.id === projectId);
+      spinner.stop();
+      if (!project) {
+        console.log(chalk3.red(`
+\u2717 Project not found: ${projectId}
+`));
+        return;
+      }
+    } catch (error) {
+      spinner.fail(chalk3.red("Failed to load project"));
+      if (error instanceof ApiError) {
+        console.log(chalk3.red(`
+Error: ${error.message}
+`));
+      }
+      return;
+    }
+  } else {
+    const selected = getSelectedProject();
+    if (!selected) {
+      console.log(chalk3.yellow(`
+\u26A0 No project selected.`));
+      console.log(chalk3.dim(`Run ${chalk3.bold("meno select")} first or provide a project ID: ${chalk3.bold("meno start <project-id>")}
+`));
+      return;
+    }
+    project = {
+      id: selected.id,
+      name: selected.name,
+      clientName: selected.clientName,
+      clientCompany: "",
+      hourlyRate: selected.hourlyRate,
+      taxRate: 0,
+      weeklyHourLimit: 0,
+      hoursUsed: 0
+    };
+  }
+  const startTime = (/* @__PURE__ */ new Date()).toISOString();
+  setActiveTimer({
+    projectId: project.id,
+    projectName: project.name,
+    startTime
+  });
+  const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+  console.log(
+    chalk3.green(
+      `
+\u23F1\uFE0F  Started: ${chalk3.bold(project.name)} \u2022 $${project.hourlyRate}/hr \u2022 [${timestamp}]
+`
+    )
+  );
+}
+
+// src/commands/stop.ts
+import enquirer3 from "enquirer";
+import chalk4 from "chalk";
+import ora4 from "ora";
+async function stopTimer(options) {
+  const timer = getActiveTimer();
+  if (!timer) {
+    console.log(chalk4.yellow(`
+\u26A0 No active timer.`));
+    console.log(chalk4.dim(`Start one with ${chalk4.bold("meno start")}
+`));
+    return;
+  }
+  if (options.discard) {
+    clearActiveTimer();
+    console.log(chalk4.yellow(`
+\u2717 Timer discarded
+`));
+    return;
+  }
+  let duration;
+  let formatted;
+  if (options.adjust) {
+    duration = parseDuration(options.adjust);
+    if (duration === 0) {
+      console.log(chalk4.red(`
+\u2717 Invalid duration format: ${options.adjust}
+`));
+      console.log(chalk4.dim(`Use format like: 1.5h, 90m, 45
+`));
+      return;
+    }
+    const hours = Math.floor(duration);
+    const minutes = Math.round((duration - hours) * 60);
+    formatted = hours > 0 ? `${hours}h ${minutes}m` : `${minutes}m`;
+    console.log(chalk4.yellow(`
+\u26A0 Adjusted duration from timer
+`));
+  } else {
+    duration = calculateElapsedHours(timer.startTime);
+    formatted = formatDuration(timer.startTime);
+  }
+  const project = getSelectedProject();
+  const hourlyRate = project?.hourlyRate || 0;
+  const amount = duration * hourlyRate;
+  console.log(chalk4.bold(`
+\u23F1\uFE0F  Duration: ${formatted} \u2022 $${amount.toFixed(2)}
+`));
+  let description;
+  let shouldLog = true;
+  try {
+    if (options.description) {
+      description = options.description;
+      console.log(chalk4.dim(`Description: ${description}
+`));
+    } else {
+      const descResult = await enquirer3.prompt({
+        type: "input",
+        name: "description",
+        message: "What were you working on?",
+        initial: timer.description || "",
+        validate: (value) => {
+          if (!value || value.trim().length === 0) {
+            return "Description is required";
+          }
+          return true;
+        }
+      });
+      description = descResult.description;
+    }
+    const skipConfirm = options.noConfirm || options.yes;
+    if (!skipConfirm) {
+      const confirmResult = await enquirer3.prompt({
+        type: "confirm",
+        name: "shouldLog",
+        message: "Log this entry?",
+        initial: true
+      });
+      shouldLog = confirmResult.shouldLog;
+      if (!shouldLog) {
+        console.log(chalk4.yellow("\n\u2717 Entry not logged\n"));
+        return;
+      }
+    }
+    const spinner = ora4("Logging entry...").start();
+    try {
+      const response = await apiRequest("/api/external/time-entries", {
+        method: "POST",
+        body: JSON.stringify({
+          projectId: timer.projectId,
+          description,
+          duration: Math.round(duration * 100) / 100,
+          // Round to 2 decimals
+          date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+          // Today
+          billable: true
+        })
+      });
+      clearActiveTimer();
+      spinner.succeed(chalk4.green(`\u2713 Logged ${duration.toFixed(2)} hours to ${timer.projectName}`));
+      console.log(chalk4.dim(`
+Entry created successfully
+`));
+    } catch (error) {
+      spinner.fail(chalk4.red("Failed to log entry"));
+      if (error instanceof ApiError) {
+        console.log(chalk4.red(`
+Error: ${error.message}
+`));
+      } else {
+        console.log(chalk4.red(`
+Unexpected error: ${error.message}
+`));
+      }
+    }
+  } catch (error) {
+    console.log(chalk4.yellow("\n\u2717 Cancelled\n"));
+  }
+}
+
+// src/commands/log.ts
+import enquirer4 from "enquirer";
+import chalk5 from "chalk";
+import ora5 from "ora";
+async function logTime(description, options) {
+  console.log(chalk5.bold("\n\u{1F4DD} Log Time Entry\n"));
+  let projectId = options.project;
+  let duration = options.duration ? parseDuration(options.duration) : null;
+  let projectName = "";
+  let hourlyRate = 0;
+  if (!projectId) {
+    const selected = getSelectedProject();
+    if (selected) {
+      projectId = selected.id;
+      projectName = selected.name;
+      hourlyRate = selected.hourlyRate;
+    } else {
+      const spinner2 = ora5("Loading projects...").start();
+      try {
+        const { projects } = await apiRequest("/api/external/projects");
+        spinner2.stop();
+        if (projects.length === 0) {
+          console.log(chalk5.yellow("No active projects found.\n"));
+          return;
+        }
+        const result = await enquirer4.prompt({
+          type: "select",
+          name: "project",
+          message: "Select a project:",
+          choices: projects.map((p) => ({
+            name: p.id,
+            message: `${p.name} (${p.clientName}) \u2022 $${p.hourlyRate}/hr`,
+            value: p
+          }))
+        });
+        const answer = result.project;
+        const project = projects.find((p) => p.id === answer);
+        if (!project) {
+          console.log(chalk5.red("Error: Selected project not found\n"));
+          return;
+        }
+        projectId = project.id;
+        projectName = project.name;
+        hourlyRate = project.hourlyRate;
+      } catch (error) {
+        spinner2.fail(chalk5.red("Failed to load projects"));
+        if (error instanceof ApiError) {
+          console.log(chalk5.red(`
+Error: ${error.message}
+`));
+        }
+        return;
+      }
+    }
+  }
+  if (!duration) {
+    console.log(chalk5.yellow("\n\u26A0 Duration is required. Use --duration flag (e.g., 45m, 1.5h)\n"));
+    return;
+  }
+  if (duration <= 0) {
+    console.log(chalk5.red("\n\u2717 Invalid duration\n"));
+    return;
+  }
+  const spinner = ora5("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(
+      chalk5.green(`\u2713 Logged ${duration.toFixed(2)} hours to ${projectName || response.entry.projectName} ($${amount.toFixed(2)})`)
+    );
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk5.red("Failed to log entry"));
+    if (error instanceof ApiError) {
+      console.log(chalk5.red(`
+Error: ${error.message}
+`));
+    } else {
+      console.log(chalk5.red(`
+Unexpected error: ${error.message}
+`));
+    }
+  }
+}
+
+// src/commands/status.ts
+import chalk6 from "chalk";
+import ora6 from "ora";
+async function showStatus() {
+  console.log(chalk6.bold("\n\u{1F4CA} Meno Status\n"));
+  const selected = getSelectedProject();
+  const timer = getActiveTimer();
+  if (selected) {
+    console.log(
+      chalk6.cyan(
+        `\u{1F4CC} Selected: ${chalk6.bold(selected.name)} (${selected.clientName}) \u2022 $${selected.hourlyRate}/hr`
+      )
+    );
+  }
+  if (timer) {
+    const elapsed = formatDuration(timer.startTime);
+    const value = calculateTimerValue(timer.startTime, selected?.hourlyRate || 0);
+    console.log(
+      chalk6.green(
+        `\u23F1\uFE0F  Running: ${chalk6.bold(timer.projectName)} \u2022 ${elapsed} \u2022 $${value.toFixed(2)}`
+      )
+    );
+  }
+  if (selected || timer) {
+    console.log();
+  }
+  const spinner = ora6("Loading stats...").start();
+  try {
+    const stats = await apiRequest("/api/external/stats");
+    spinner.stop();
+    console.log(
+      chalk6.green.bold(`\u{1F4B0} Unbilled Revenue: $${stats.totalRevenue.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`)
+    );
+    console.log(
+      chalk6.dim(
+        `\u23F1\uFE0F  Total Hours: ${stats.totalHours.toFixed(1)} hours across ${stats.entriesCount} ${stats.entriesCount === 1 ? "entry" : "entries"}`
+      )
+    );
+    console.log();
+  } catch (error) {
+    spinner.fail(chalk6.red("Failed to load stats"));
+    if (error instanceof ApiError) {
+      console.log(chalk6.red(`
+Error: ${error.message}
+`));
+    } else {
+      console.log(chalk6.red(`
+Unexpected error: ${error.message}
+`));
+    }
+  }
+}
+
+// src/index.ts
+var 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();

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@usemeno/meno-cli",
+  "version": "0.1.0",
+  "description": "Command-line interface for Meno time tracking",
+  "main": "dist/index.js",
+  "bin": {
+    "meno": "./dist/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --shims",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["meno", "time-tracking", "cli", "productivity"],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^12.0.0",
+    "conf": "^13.0.1",
+    "ora": "^8.0.1",
+    "enquirer": "^2.4.1",
+    "chalk": "^5.3.0",
+    "node-fetch": "^3.3.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.0",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}