@usemeno/meno-cli 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usemeno/meno-cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Command-line interface for Meno time tracking",
   "main": "dist/index.js",
   "bin": {
@@ -12,7 +12,12 @@
     "dev": "tsup src/index.ts --format esm --watch",
     "prepublishOnly": "npm run build"
   },
-  "keywords": ["meno", "time-tracking", "cli", "productivity"],
+  "keywords": [
+    "meno",
+    "time-tracking",
+    "cli",
+    "productivity"
+  ],
   "author": "",
   "license": "MIT",
   "dependencies": {

package/src/commands/select.ts

@@ -1,79 +1,104 @@
 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";
+import { setSelectedTask, clearSelectedTask, getSelectedTask } from "../config.js";
+import { getTasks, ApiError, Task } from "../utils/api.js";
+
+function getStatusColor(status: string): (text: string) => string {
+  switch (status) {
+    case "Backlog": return chalk.gray;
+    case "Todo": return chalk.yellow;
+    case "InProgress": return chalk.cyan;
+    case "Review": return chalk.magenta;
+    case "Done": return chalk.green;
+    default: return chalk.white;
+  }
+}
+
+function formatTaskDisplay(task: Task, isSelected: boolean): string {
+  const prefix = isSelected ? "● " : "  ";
+  const statusColor = getStatusColor(task.status);
+  const estimateText = task.estimatedHours ? ` • ${task.estimatedHours}h` : "";
+  
+  return `${prefix}${chalk.bold(task.title)} ${chalk.dim("→")} ${task.project.name} ${statusColor(`[${task.status}]`)}${estimateText}`;
+}
 
 export async function selectProject() {
-  console.log(chalk.bold("\n📂 Select Project\n"));
+  console.log(chalk.bold("\n📋 Select Task\n"));
 
-  const spinner = ora("Loading projects...").start();
+  const spinner = ora("Loading tasks...").start();
 
   try {
-    const { projects } = await apiRequest<{ projects: ApiProject[] }>("/api/external/projects");
+    const tasks = await getTasks();
 
     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"));
+    if (tasks.length === 0) {
+      console.log(chalk.yellow("No tasks found."));
+      console.log(chalk.dim("Create tasks in the Meno dashboard first.\n"));
       return;
     }
 
-    const currentProject = getSelectedProject();
+    const currentTask = getSelectedTask();
 
-    // Build choices
+    // Build choices - group by status or show all
     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`;
+      ...tasks.map((task) => {
+        const isSelected = currentTask?.id === task.id;
         
         return {
-          name: project.id,
-          message: prefix + displayName,
-          value: project,
+          name: task.id,
+          message: formatTaskDisplay(task, isSelected),
+          value: task,
         };
       }),
     ];
 
     const result = await enquirer.prompt({
       type: "select",
-      name: "project",
-      message: "Select a project:",
+      name: "task",
+      message: "Select a task:",
       choices,
     });
 
-    const answer = (result as any).project;
+    const answer = (result as any).task;
 
     if (answer === "clear") {
-      clearSelectedProject();
+      clearSelectedTask();
       console.log(chalk.green("\n✓ Selection cleared\n"));
     } else {
-      // Find the full project object by ID
-      const project = projects.find((p) => p.id === answer);
+      // Find the full task object by ID
+      const task = tasks.find((t) => t.id === answer);
       
-      if (!project) {
-        console.log(chalk.red("\n✗ Project not found\n"));
+      if (!task) {
+        console.log(chalk.red("\n✗ Task not found\n"));
         return;
       }
       
-      setSelectedProject({
-        id: project.id,
-        name: project.name,
-        clientName: project.clientName,
-        hourlyRate: project.hourlyRate,
+      setSelectedTask({
+        id: task.id,
+        title: task.title,
+        projectId: task.projectId,
+        projectName: task.project.name,
+        status: task.status,
+        estimatedHours: task.estimatedHours,
+        hourlyRate: task.project.hourlyRate,
       });
+      
+      const statusColor = getStatusColor(task.status);
       console.log(
-        chalk.green(`\n✓ Selected: ${chalk.bold(project.name)} (${project.clientName}) • $${project.hourlyRate}/hr\n`)
+        chalk.green(`\n✓ Selected: ${chalk.bold(task.title)}\n`) +
+        chalk.dim(`  Project: ${task.project.name} • $${task.project.hourlyRate}/hr\n`) +
+        chalk.dim(`  Status: `) + statusColor(task.status) +
+        (task.estimatedHours ? chalk.dim(` • Estimated: ${task.estimatedHours}h\n`) : "\n")
       );
     }
   } catch (error) {
-    spinner.fail(chalk.red("Failed to load projects"));
+    spinner.fail(chalk.red("Failed to load tasks"));
     
     if (error instanceof ApiError) {
       console.log(chalk.red(`\nError: ${error.message}\n`));

package/src/commands/start.ts

@@ -1,77 +1,112 @@
 import chalk from "chalk";
 import ora from "ora";
-import { getSelectedProject, getActiveTimer, setActiveTimer } from "../config.js";
-import { apiRequest, ApiError, Project } from "../utils/api.js";
+import { getSelectedTask, getActiveTimer, setActiveTimer } from "../config.js";
+import { getTasks, cliAction, ApiError, Task, CliStartResponse } from "../utils/api.js";
 import { formatDuration } from "../utils/timer.js";
 
-export async function startTimer(projectId?: string) {
+export async function startTimer(taskId?: string) {
   // Check if timer is already running
   const existingTimer = getActiveTimer();
   if (existingTimer) {
     const elapsed = formatDuration(existingTimer.startTime);
+    const taskInfo = existingTimer.taskTitle || existingTimer.projectName;
     console.log(
       chalk.yellow(
-        `\n⚠ Timer already running for ${chalk.bold(existingTimer.projectName)} (${elapsed})`
+        `\n⚠ Timer already running for ${chalk.bold(taskInfo)} (${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;
+  let task: Task | undefined;
 
-  if (projectId) {
-    // Start with explicit project ID
-    const spinner = ora("Loading project...").start();
+  if (taskId) {
+    // Start with explicit task ID
+    const spinner = ora("Loading task...").start();
     try {
-      const { projects } = await apiRequest<{ projects: Project[] }>("/api/external/projects");
-      project = projects.find((p) => p.id === projectId);
+      const tasks = await getTasks();
+      task = tasks.find((t) => t.id === taskId);
       spinner.stop();
 
-      if (!project) {
-        console.log(chalk.red(`\n✗ Project not found: ${projectId}\n`));
+      if (!task) {
+        console.log(chalk.red(`\n✗ Task not found: ${taskId}\n`));
         return;
       }
     } catch (error) {
-      spinner.fail(chalk.red("Failed to load project"));
+      spinner.fail(chalk.red("Failed to load task"));
       if (error instanceof ApiError) {
         console.log(chalk.red(`\nError: ${error.message}\n`));
       }
       return;
     }
   } else {
-    // Use selected project
-    const selected = getSelectedProject();
+    // Use selected task
+    const selected = getSelectedTask();
     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`));
+      console.log(chalk.yellow(`\n⚠ No task selected.`));
+      console.log(chalk.dim(`Run ${chalk.bold("meno select")} first or provide a task ID: ${chalk.bold("meno start <task-id>")}\n`));
       return;
     }
 
-    project = {
-      id: selected.id,
-      name: selected.name,
-      clientName: selected.clientName,
-      clientCompany: "",
-      hourlyRate: selected.hourlyRate,
-      taxRate: 0,
-      weeklyHourLimit: 0,
-      hoursUsed: 0,
-    };
+    // Fetch full task details to ensure we have latest status
+    const spinner = ora("Starting timer...").start();
+    try {
+      const tasks = await getTasks();
+      task = tasks.find((t) => t.id === selected.id);
+      spinner.stop();
+      
+      if (!task) {
+        console.log(chalk.red(`\n✗ Selected task not found. It may have been deleted.\n`));
+        return;
+      }
+    } catch (error) {
+      spinner.fail(chalk.red("Failed to load task"));
+      if (error instanceof ApiError) {
+        console.log(chalk.red(`\nError: ${error.message}\n`));
+      }
+      return;
+    }
   }
 
-  // Start the timer
-  const startTime = new Date().toISOString();
-  setActiveTimer({
-    projectId: project.id,
-    projectName: project.name,
-    startTime,
-  });
+  // Call API to start timer (API will auto-stop any running timer)
+  const spinner = ora("Starting timer...").start();
+  
+  try {
+    const response = await cliAction("start", { taskId: task.id }) as CliStartResponse;
+    
+    spinner.succeed(chalk.green("Timer started"));
+
+    // Store timer info locally for offline reference
+    const startTime = response.timer?.startTime || new Date().toISOString();
+    setActiveTimer({
+      projectId: task.projectId,
+      projectName: task.project.name,
+      startTime,
+      taskId: task.id,
+      taskTitle: task.title,
+    });
 
-  const timestamp = new Date().toLocaleTimeString();
-  console.log(
-    chalk.green(
-      `\n⏱️  Started: ${chalk.bold(project.name)} • $${project.hourlyRate}/hr • [${timestamp}]\n`
-    )
-  );
+    const timestamp = new Date(startTime).toLocaleTimeString();
+    console.log(
+      chalk.green(
+        `\n⏱️  ${chalk.bold(task.title)}\n` +
+        chalk.dim(`   ${task.project.name} • $${task.project.hourlyRate}/hr • [${timestamp}]`)
+      )
+    );
+    
+    if (task.estimatedHours) {
+      console.log(chalk.dim(`   Estimated: ${task.estimatedHours}h\n`));
+    } else {
+      console.log();
+    }
+  } catch (error) {
+    spinner.fail(chalk.red("Failed to start timer"));
+    
+    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/status.ts

@@ -1,36 +1,58 @@
 import chalk from "chalk";
 import ora from "ora";
-import { getSelectedProject, getActiveTimer } from "../config.js";
+import { getSelectedTask, getActiveTimer } from "../config.js";
 import { apiRequest, ApiError, Stats } from "../utils/api.js";
 import { formatDuration, calculateTimerValue } from "../utils/timer.js";
 
+function getStatusColor(status: string): (text: string) => string {
+  switch (status) {
+    case "Backlog": return chalk.gray;
+    case "Todo": return chalk.yellow;
+    case "InProgress": return chalk.cyan;
+    case "Review": return chalk.magenta;
+    case "Done": return chalk.green;
+    default: return chalk.white;
+  }
+}
+
 export async function showStatus() {
   console.log(chalk.bold("\n📊 Meno Status\n"));
 
-  const selected = getSelectedProject();
+  const selectedTask = getSelectedTask();
   const timer = getActiveTimer();
 
-  // Show selected project
-  if (selected) {
+  // Show selected task
+  if (selectedTask) {
+    const statusColor = getStatusColor(selectedTask.status);
     console.log(
       chalk.cyan(
-        `📌 Selected: ${chalk.bold(selected.name)} (${selected.clientName}) • $${selected.hourlyRate}/hr`
+        `📌 Selected: ${chalk.bold(selectedTask.title)}`
       )
     );
+    console.log(
+      chalk.dim(
+        `   ${selectedTask.projectName} • $${selectedTask.hourlyRate}/hr • ` 
+      ) + statusColor(selectedTask.status)
+    );
+    if (selectedTask.estimatedHours) {
+      console.log(chalk.dim(`   Estimated: ${selectedTask.estimatedHours}h`));
+    }
   }
 
   // Show active timer
   if (timer) {
     const elapsed = formatDuration(timer.startTime);
-    const value = calculateTimerValue(timer.startTime, selected?.hourlyRate || 0);
+    const taskInfo = timer.taskTitle || timer.projectName;
+    const rate = selectedTask?.hourlyRate || 0;
+    const value = calculateTimerValue(timer.startTime, rate);
     console.log(
       chalk.green(
-        `⏱️  Running: ${chalk.bold(timer.projectName)} • ${elapsed} • $${value.toFixed(2)}`
+        `⏱️  Running: ${chalk.bold(taskInfo)} • ${elapsed} • $${value.toFixed(2)}`
       )
     );
   }
 
-  if (selected || timer) {
+  if (selectedTask || timer) {
     console.log(); // Add spacing
   }
 

package/src/commands/stop.ts

@@ -1,16 +1,18 @@
 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";
+import { getActiveTimer, clearActiveTimer } from "../config.js";
+import { cliAction, ApiError, CliStopResponse } from "../utils/api.js";
+import { formatDuration } from "../utils/timer.js";
+import { getGitInfo, isGitRepository } from "../utils/git.js";
 
 interface StopOptions {
   discard?: boolean;
   description?: string;
   noConfirm?: boolean;
   yes?: boolean;
-  adjust?: string;
+  commit?: string;
+  repo?: string;
 }
 
 export async function stopTimer(options: StopOptions) {
@@ -29,42 +31,22 @@ export async function stopTimer(options: StopOptions) {
     return;
   }
 
-  // Calculate duration (or use adjusted duration)
-  let duration: number;
-  let formatted: string;
+  const taskInfo = timer.taskTitle || timer.projectName;
+  const elapsed = formatDuration(timer.startTime);
   
-  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`));
+  console.log(chalk.bold(`\n⏱️  Stopping: ${taskInfo}`));
+  console.log(chalk.dim(`Duration: ${elapsed}\n`));
 
   let description: string;
   let shouldLog = true;
+  let commitHash: string | undefined;
+  let repoUrl: string | undefined;
 
   try {
     // Get description (from flag or prompt)
     if (options.description) {
       description = options.description;
-      console.log(chalk.dim(`Description: ${description}\n`));
+      console.log(chalk.dim(`Description: ${description}`));
     } else {
       const descResult = await enquirer.prompt({
         type: "input",
@@ -81,6 +63,40 @@ export async function stopTimer(options: StopOptions) {
       description = (descResult as any).description;
     }
 
+    // Handle git integration
+    if (options.commit && options.repo) {
+      // Manual git info provided
+      commitHash = options.commit;
+      repoUrl = options.repo;
+      console.log(chalk.dim(`\n🔗 Evidence: ${commitHash.substring(0, 7)} @ ${repoUrl}`));
+    } else if (isGitRepository()) {
+      // Auto-detect git info and prompt
+      const gitInfo = getGitInfo();
+      
+      if (gitInfo) {
+        const skipConfirm = options.noConfirm || options.yes;
+        
+        if (skipConfirm) {
+          // Auto-include if -y flag
+          commitHash = gitInfo.commitHash;
+          repoUrl = gitInfo.repoUrl;
+          console.log(chalk.dim(`\n🔗 Evidence: ${commitHash.substring(0, 7)} @ ${repoUrl}`));
+        } else {
+          const gitResult = await enquirer.prompt({
+            type: "confirm",
+            name: "includeGit",
+            message: `Include latest commit (${gitInfo.commitHash.substring(0, 7)}) as evidence?`,
+            initial: true,
+          });
+          
+          if ((gitResult as any).includeGit) {
+            commitHash = gitInfo.commitHash;
+            repoUrl = gitInfo.repoUrl;
+          }
+        }
+      }
+    }
+
     // Confirm logging (unless --no-confirm or -y flag)
     const skipConfirm = options.noConfirm || options.yes;
     if (!skipConfirm) {
@@ -94,36 +110,50 @@ export async function stopTimer(options: StopOptions) {
 
       if (!shouldLog) {
         console.log(chalk.yellow("\n✗ Entry not logged\n"));
+        clearActiveTimer();
         return;
       }
     }
 
-    // Log the entry
+    // Call API to stop timer
     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,
-        }),
-      });
+      const response = await cliAction("stop", {
+        description,
+        commitHash,
+        repoUrl,
+      }) as CliStopResponse;
 
       clearActiveTimer();
-      spinner.succeed(chalk.green(`✓ Logged ${duration.toFixed(2)} hours to ${timer.projectName}`));
-      console.log(chalk.dim(`\nEntry created successfully\n`));
+      
+      if (response.entry) {
+        const hours = response.entry.duration.toFixed(2);
+        const amount = response.entry.amount.toFixed(2);
+        
+        spinner.succeed(chalk.green(`✓ Logged ${hours} hours ($${amount})`));
+        
+        if (response.evidence) {
+          console.log(chalk.dim(`📎 Evidence: ${response.evidence.commitHash.substring(0, 7)}`));
+        }
+        
+        console.log();
+      } else {
+        spinner.succeed(chalk.green("✓ Timer stopped"));
+        console.log();
+      }
     } catch (error) {
-      spinner.fail(chalk.red("Failed to log entry"));
+      spinner.fail(chalk.red("Failed to stop timer"));
       
       if (error instanceof ApiError) {
         console.log(chalk.red(`\nError: ${error.message}\n`));
+        console.log(chalk.yellow(`Timer cleared locally. You may need to check the dashboard.\n`));
       } else {
         console.log(chalk.red(`\nUnexpected error: ${(error as Error).message}\n`));
       }
+      
+      // Clear local timer even on error to avoid stuck state
+      clearActiveTimer();
     }
   } catch (error) {
     // User cancelled

package/src/config.ts

@@ -9,11 +9,22 @@ interface Config {
     clientName: string;
     hourlyRate: number;
   };
+  selectedTask?: {
+    id: string;
+    title: string;
+    projectId: string;
+    projectName: string;
+    status: string;
+    estimatedHours?: number;
+    hourlyRate: number;
+  };
   activeTimer?: {
     projectId: string;
     projectName: string;
     startTime: string;
     description?: string;
+    taskId?: string;
+    taskTitle?: string;
   };
 }
 
@@ -30,7 +41,7 @@ export function setApiKey(key: string): void {
 }
 
 export function getBaseUrl(): string {
-  return config.get("baseUrl") || process.env.MENO_BASE_URL || "http://localhost:3000";
+  return config.get("baseUrl") || process.env.MENO_BASE_URL || "https://menohq.app";
 }
 
 export function setBaseUrl(url: string): void {
@@ -71,6 +82,26 @@ export function clearActiveTimer(): void {
   config.delete("activeTimer");
 }
 
+export function getSelectedTask() {
+  return config.get("selectedTask");
+}
+
+export function setSelectedTask(task: {
+  id: string;
+  title: string;
+  projectId: string;
+  projectName: string;
+  status: string;
+  estimatedHours?: number;
+  hourlyRate: number;
+}): void {
+  config.set("selectedTask", task);
+}
+
+export function clearSelectedTask(): void {
+  config.delete("selectedTask");
+}
+
 export function clearConfig(): void {
   config.clear();
 }

package/src/index.ts

@@ -7,6 +7,7 @@ import { startTimer } from "./commands/start.js";
 import { stopTimer } from "./commands/stop.js";
 import { logTime } from "./commands/log.js";
 import { showStatus } from "./commands/status.js";
+import { printLogoAscii } from "./logo-ascii.js";
 
 const program = new Command();
 
@@ -15,6 +16,9 @@ program
   .description("CLI for Meno time tracking")
   .version("0.1.0");
 
+// Print ASCII logo at CLI startup (sharp used if installed, otherwise a fallback)
+printLogoAscii().catch(() => {});
+
 program
   .command("login")
   .description("Authenticate with your Meno API key")
@@ -22,12 +26,12 @@ program
 
 program
   .command("select")
-  .description("Select a project to work on")
+  .description("Select a task to work on")
   .action(selectProject);
 
 program
-  .command("start [project-id]")
-  .description("Start a timer on selected project or specific project ID")
+  .command("start [task-id]")
+  .description("Start a timer on selected task or specific task ID")
   .action(startTimer);
 
 program
@@ -37,7 +41,8 @@ program
   .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)")
+  .option("--commit <hash>", "Git commit hash for evidence")
+  .option("--repo <url>", "Git repository URL for evidence")
   .action(stopTimer);
 
 program
@@ -49,7 +54,7 @@ program
 
 program
   .command("status")
-  .description("Show selected project, timer status, and unbilled stats")
+  .description("Show selected task, timer status, and unbilled stats")
   .action(showStatus);
 
 program.parse();