@vanshbhardwaj/worklog 1.0.0

package/src/cli/commands/add.ts

@@ -0,0 +1,176 @@
+import prompts from 'prompts';
+import pc from 'picocolors';
+import { WorkUnitService } from '../../services/work-unit.js';
+
+interface AddOptions {
+  title?: string;
+  type?: string;
+  status?: string;
+  priority?: string;
+  module?: string;
+  tags?: string;
+  description?: string;
+  next?: string;
+  notes?: string;
+  json?: boolean;
+}
+
+function capitalize(val: string): string {
+  if (!val) return val;
+  return val.charAt(0).toUpperCase() + val.slice(1).toLowerCase();
+}
+
+function parseStatus(val: string): string {
+  if (!val) return val;
+  const lower = val.toLowerCase();
+  if (lower === 'in-progress' || lower === 'inprogress' || lower === 'in_progress') {
+    return 'In Progress';
+  }
+  return capitalize(val);
+}
+
+/**
+ * Creates a new Work Unit. If the title is omitted, starts interactive prompting.
+ */
+export async function addCommand(service: WorkUnitService, options: AddOptions): Promise<void> {
+  let inputData: any;
+
+  if (!options.title) {
+    // Check if stdin is a TTY before starting prompts
+    if (!process.stdin.isTTY) {
+      if (options.json) {
+        console.error(
+          JSON.stringify({
+            success: false,
+            error: 'Title is required in non-interactive mode.',
+          }),
+        );
+      } else {
+        console.error(pc.red('Error: Title is required in non-interactive mode.'));
+      }
+      process.exit(1);
+    }
+
+    // Interactive Mode
+    const responses = await prompts(
+      [
+        {
+          type: 'text',
+          name: 'title',
+          message: 'Title:',
+          validate: (val) => (val.trim().length > 0 ? true : 'Title is required'),
+        },
+        {
+          type: 'select',
+          name: 'type',
+          message: 'Type:',
+          choices: [
+            { title: 'Feature', value: 'Feature' },
+            { title: 'Bug', value: 'Bug' },
+            { title: 'Spike', value: 'Spike' },
+            { title: 'Refactor', value: 'Refactor' },
+            { title: 'Improvement', value: 'Improvement' },
+            { title: 'Research', value: 'Research' },
+            { title: 'Decision', value: 'Decision' },
+            { title: 'Blocker', value: 'Blocker' },
+            { title: 'Review', value: 'Review' },
+            { title: 'Idea', value: 'Idea' },
+          ],
+          initial: 0,
+        },
+        {
+          type: 'select',
+          name: 'status',
+          message: 'Status:',
+          choices: [
+            { title: 'Planned', value: 'Planned' },
+            { title: 'In Progress', value: 'In Progress' },
+            { title: 'Blocked', value: 'Blocked' },
+            { title: 'Completed', value: 'Completed' },
+            { title: 'Cancelled', value: 'Cancelled' },
+          ],
+          initial: 0,
+        },
+        {
+          type: 'text',
+          name: 'description',
+          message: 'Description (optional):',
+          format: (val) => val.trim() || null,
+        },
+        {
+          type: 'text',
+          name: 'module',
+          message: 'Module (optional):',
+          format: (val) => val.trim() || null,
+        },
+        {
+          type: 'text',
+          name: 'tags',
+          message: 'Tags (comma-separated, optional):',
+          format: (val) => val.trim() || null,
+        },
+        {
+          type: 'text',
+          name: 'nextStep',
+          message: 'Next Step (optional):',
+          format: (val) => val.trim() || null,
+        },
+      ],
+      {
+        onCancel: () => {
+          if (options.json) {
+            console.log(JSON.stringify({ success: false, error: 'Cancelled by user' }));
+          } else {
+            console.log(pc.yellow('\nCancelled.'));
+          }
+          process.exit(1);
+        },
+      },
+    );
+
+    const parsedTags = responses.tags
+      ? responses.tags
+          .split(',')
+          .map((t: string) => t.trim())
+          .filter(Boolean)
+      : [];
+
+    inputData = {
+      title: responses.title,
+      type: responses.type,
+      status: responses.status,
+      description: responses.description,
+      module: responses.module,
+      tags: parsedTags,
+      nextStep: responses.nextStep,
+    };
+  } else {
+    // Non-Interactive Mode
+    const parsedTags = options.tags
+      ? options.tags
+          .split(',')
+          .map((t: string) => t.trim())
+          .filter(Boolean)
+      : [];
+
+    inputData = {
+      title: options.title,
+      type: options.type ? capitalize(options.type) : 'Feature',
+      status: options.status ? parseStatus(options.status) : 'Planned',
+      priority: options.priority ? capitalize(options.priority) : null,
+      module: options.module || null,
+      tags: parsedTags,
+      description: options.description || null,
+      nextStep: options.next || null,
+      notes: options.notes || null,
+    };
+  }
+
+  const created = service.createWorkUnit(inputData);
+
+  if (options.json) {
+    console.log(JSON.stringify(created));
+  } else {
+    console.log(pc.green(`Created work unit #${created.id}: ${created.title}`));
+  }
+}

package/src/cli/commands/continue.ts

@@ -0,0 +1,80 @@
+import prompts from 'prompts';
+import pc from 'picocolors';
+import { WorkUnitService } from '../../services/work-unit.js';
+
+interface ContinueOptions {
+  json?: boolean;
+}
+
+/**
+ * Resumes work on the most recent unfinished Work Unit.
+ */
+export async function continueCommand(
+  service: WorkUnitService,
+  options: ContinueOptions,
+): Promise<void> {
+  const unfinished = service.getUnfinishedWorkUnits(); // sorted by updated_at desc
+
+  if (unfinished.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: 'No unfinished work units found.' }));
+    } else {
+      console.log(pc.yellow('No unfinished work units found.'));
+    }
+    return;
+  }
+
+  let selectedUnit = unfinished[0];
+
+  if (unfinished.length > 1) {
+    if (!process.stdin.isTTY) {
+      // Non-interactive: auto-resume the most recently touched unit
+      selectedUnit = unfinished[0];
+    } else {
+      const choices = unfinished.map((u) => ({
+        title: `#${u.id} - ${u.title} (${u.status})`,
+        value: u,
+      }));
+
+      const response = await prompts(
+        {
+          type: 'select',
+          name: 'unit',
+          message: 'Select an unfinished work unit to resume:',
+          choices,
+          initial: 0,
+        },
+        {
+          onCancel: () => {
+            if (options.json) {
+              console.log(JSON.stringify({ success: false, error: 'Cancelled by user' }));
+            } else {
+              console.log(pc.yellow('\nCancelled.'));
+            }
+            process.exit(1);
+          },
+        },
+      );
+
+      if (!response.unit) {
+        process.exit(1);
+      }
+      selectedUnit = response.unit;
+    }
+  }
+
+  // Update status to In Progress
+  const updated = service.updateWorkUnit(selectedUnit.id, {
+    status: 'In Progress',
+  });
+
+  if (options.json) {
+    console.log(JSON.stringify(updated));
+  } else {
+    console.log(
+      pc.green(
+        `Resumed work unit #${updated.id}: ${updated.title} (Status updated to 'In Progress')`,
+      ),
+    );
+  }
+}

package/src/cli/commands/dashboard.ts

@@ -0,0 +1,30 @@
+import { WorkUnitService } from '../../services/work-unit.js';
+import { formatDashboard } from '../ui.js';
+
+interface DashboardOptions {
+  json?: boolean;
+}
+
+/**
+ * Renders the WorkLog project overview dashboard.
+ */
+export function dashboardCommand(service: WorkUnitService, options: DashboardOptions): void {
+  const inProgress = service.getWorkUnitsByStatus('In Progress');
+  const recentlyUpdated = service.getRecentWorkUnits(5);
+
+  const blocked = service.getWorkUnitsByStatus('Blocked');
+  const planned = service.getWorkUnitsByStatus('Planned');
+  const needsAttention = [...blocked, ...planned].slice(0, 5); // limit to 5 to keep dashboard concise
+
+  if (options.json) {
+    console.log(
+      JSON.stringify({
+        inProgress,
+        recentlyUpdated,
+        needsAttention,
+      }),
+    );
+  } else {
+    console.log(formatDashboard(inProgress, recentlyUpdated, needsAttention));
+  }
+}

package/src/cli/commands/export.ts

@@ -0,0 +1,72 @@
+import * as fs from 'fs';
+import pc from 'picocolors';
+import { WorkUnitService } from '../../services/work-unit.js';
+import { exportToMarkdown } from '../../exporters/markdown.js';
+import { exportToCSV } from '../../exporters/csv.js';
+import { exportToJSON } from '../../exporters/json.js';
+import { WorkUnit } from '../../models/work-unit.js';
+
+interface ExportOptions {
+  format?: string;
+  output?: string;
+  id?: string;
+}
+
+/**
+ * Handles exporting all work units or a single work unit into Markdown, CSV, or JSON formats.
+ */
+export function exportCommand(service: WorkUnitService, options: ExportOptions): void {
+  let data: WorkUnit | WorkUnit[];
+
+  if (options.id) {
+    const id = Number(options.id);
+    if (isNaN(id) || !Number.isInteger(id) || id <= 0) {
+      console.error(pc.red('Error: A valid positive integer ID is required.'));
+      process.exit(1);
+    }
+    const unit = service.getWorkUnit(id);
+    if (!unit) {
+      console.error(pc.red(`Error: Work unit #${id} not found.`));
+      process.exit(1);
+    }
+    data = unit;
+  } else {
+    // Retrieve all units (up to 1,000,000 limit)
+    data = service.getRecentWorkUnits(1000000);
+  }
+
+  let formatted = '';
+  const format = (options.format || 'markdown').toLowerCase();
+
+  switch (format) {
+    case 'markdown':
+    case 'md':
+      formatted = exportToMarkdown(data);
+      break;
+    case 'csv':
+      formatted = exportToCSV(data);
+      break;
+    case 'json':
+      formatted = exportToJSON(data);
+      break;
+    default:
+      console.error(
+        pc.red(
+          `Error: Unsupported format '${options.format}'. Supported: markdown (md), csv, json.`,
+        ),
+      );
+      process.exit(1);
+  }
+
+  if (options.output) {
+    try {
+      fs.writeFileSync(options.output, formatted, 'utf8');
+      console.log(pc.green(`Exported successfully to ${options.output}`));
+    } catch (error: any) {
+      console.error(pc.red(`Error: Failed to write to file '${options.output}': ${error.message}`));
+      process.exit(1);
+    }
+  } else {
+    process.stdout.write(formatted);
+  }
+}

package/src/cli/commands/init.ts

@@ -0,0 +1,52 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import pc from 'picocolors';
+import { initConfig } from '../../core/config.js';
+import { connectDatabase } from '../../database/connection.js';
+import { runMigrations } from '../../database/migrations.js';
+import { initLogger } from '../../core/logger.js';
+
+interface InitOptions {
+  name?: string;
+  json?: boolean;
+}
+
+/**
+ * Initializes a new WorkLog repository in the current working directory.
+ */
+export function initCommand(options: InitOptions): void {
+  const targetDir = process.cwd();
+  const dotWorklog = path.join(targetDir, '.worklog');
+
+  const exists = fs.existsSync(dotWorklog) && fs.statSync(dotWorklog).isDirectory();
+
+  if (!fs.existsSync(dotWorklog)) {
+    fs.mkdirSync(dotWorklog, { recursive: true });
+  }
+
+  // 1. Initialize configuration
+  const config = initConfig(targetDir, options.name);
+
+  // 2. Initialize logger
+  initLogger(targetDir);
+
+  // 3. Connect database & run migrations
+  const db = connectDatabase(targetDir);
+  runMigrations(db);
+
+  if (options.json) {
+    console.log(
+      JSON.stringify({
+        success: true,
+        message: exists
+          ? 'Reinitialized existing WorkLog repository'
+          : 'Initialized empty WorkLog repository',
+        projectName: config.projectName,
+        path: dotWorklog,
+      }),
+    );
+  } else {
+    const verb = exists ? 'Reinitialized existing' : 'Initialized empty';
+    console.log(pc.green(`${verb} WorkLog repository in ${dotWorklog}/`));
+  }
+}

package/src/cli/commands/list.ts

@@ -0,0 +1,33 @@
+import { WorkUnitService } from '../../services/work-unit.js';
+import { formatTable } from '../ui.js';
+
+interface ListOptions {
+  limit?: string;
+  status?: string;
+  type?: string;
+  json?: boolean;
+}
+
+/**
+ * Lists recent Work Units with optional filters.
+ */
+export function listCommand(service: WorkUnitService, options: ListOptions): void {
+  const limitVal = options.limit ? Number(options.limit) : 20;
+  let units = service.getRecentWorkUnits(limitVal);
+
+  if (options.status) {
+    const filterStatus = options.status.toLowerCase();
+    units = units.filter((u) => u.status.toLowerCase() === filterStatus);
+  }
+
+  if (options.type) {
+    const filterType = options.type.toLowerCase();
+    units = units.filter((u) => u.type.toLowerCase() === filterType);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(units));
+  } else {
+    console.log(formatTable(units));
+  }
+}

package/src/cli/commands/search.ts

@@ -0,0 +1,33 @@
+import { WorkUnitService } from '../../services/work-unit.js';
+import { formatTable } from '../ui.js';
+
+interface SearchOptions {
+  tag?: string;
+  module?: string;
+  status?: string;
+  type?: string;
+  json?: boolean;
+}
+
+/**
+ * Searches Work Units by text queries and/or structured category filters.
+ */
+export function searchCommand(
+  service: WorkUnitService,
+  query: string | undefined,
+  options: SearchOptions,
+): void {
+  const textQuery = query || '';
+  const results = service.searchWorkUnits(textQuery, {
+    tag: options.tag,
+    module: options.module,
+    status: options.status,
+    type: options.type,
+  });
+
+  if (options.json) {
+    console.log(JSON.stringify(results));
+  } else {
+    console.log(formatTable(results));
+  }
+}

package/src/cli/commands/show.ts

@@ -0,0 +1,42 @@
+import pc from 'picocolors';
+import { WorkUnitService } from '../../services/work-unit.js';
+import { formatWorkUnitDetail } from '../ui.js';
+
+interface ShowOptions {
+  json?: boolean;
+}
+
+/**
+ * Displays detailed information about a single Work Unit.
+ */
+export function showCommand(
+  service: WorkUnitService,
+  idStr: string,
+  options: ShowOptions,
+): void {
+  const id = Number(idStr);
+  if (isNaN(id) || !Number.isInteger(id) || id <= 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: 'A valid positive integer ID is required.' }));
+    } else {
+      console.error(pc.red('Error: A valid positive integer ID is required.'));
+    }
+    process.exit(1);
+  }
+
+  const unit = service.getWorkUnit(id);
+  if (!unit) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: `Work unit #${id} not found.` }));
+    } else {
+      console.error(pc.red(`Error: Work unit #${id} not found.`));
+    }
+    process.exit(1);
+  }
+
+  if (options.json) {
+    console.log(JSON.stringify(unit));
+  } else {
+    console.log(formatWorkUnitDetail(unit));
+  }
+}

package/src/cli/commands/stats.ts

@@ -0,0 +1,23 @@
+import { WorkUnitService } from '../../services/work-unit.js';
+import { formatStats } from '../ui.js';
+
+interface StatsOptions {
+  json?: boolean;
+}
+
+/**
+ * Renders analytical distributions and activity stats.
+ */
+export function statsCommand(service: WorkUnitService, options: StatsOptions): void {
+  const sevenDaysAgo = new Date();
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+  sevenDaysAgo.setHours(0, 0, 0, 0);
+
+  const stats = service.getStats(sevenDaysAgo.toISOString());
+
+  if (options.json) {
+    console.log(JSON.stringify(stats));
+  } else {
+    console.log(formatStats(stats));
+  }
+}

package/src/cli/commands/today.ts

@@ -0,0 +1,27 @@
+import { WorkUnitService } from '../../services/work-unit.js';
+import { formatTable } from '../ui.js';
+
+interface TodayOptions {
+  json?: boolean;
+}
+
+/**
+ * Displays work units updated or created today.
+ */
+export function todayCommand(service: WorkUnitService, options: TodayOptions): void {
+  const startOfToday = new Date();
+  startOfToday.setHours(0, 0, 0, 0);
+  const isoString = startOfToday.toISOString();
+
+  const units = service.getCreatedOrUpdatedAfter(isoString);
+
+  if (options.json) {
+    console.log(JSON.stringify(units));
+  } else {
+    if (units.length === 0) {
+      console.log('No work units logged today.');
+      return;
+    }
+    console.log(formatTable(units));
+  }
+}

package/src/cli/commands/week.ts

@@ -0,0 +1,93 @@
+import pc from 'picocolors';
+import { WorkUnitService } from '../../services/work-unit.js';
+
+interface WeekOptions {
+  json?: boolean;
+}
+
+/**
+ * Displays a weekly engineering summary of work logged over the past 7 days.
+ */
+export function weekCommand(service: WorkUnitService, options: WeekOptions): void {
+  const sevenDaysAgo = new Date();
+  sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
+  sevenDaysAgo.setHours(0, 0, 0, 0);
+  const isoString = sevenDaysAgo.toISOString();
+
+  const units = service.getCreatedOrUpdatedAfter(isoString);
+
+  if (options.json) {
+    console.log(JSON.stringify(units));
+    return;
+  }
+
+  if (units.length === 0) {
+    console.log('No work units logged in the past 7 days.');
+    return;
+  }
+
+  // Filter categories
+  const completedFeatures = units.filter((u) => u.type === 'Feature' && u.status === 'Completed');
+  const fixedBugs = units.filter((u) => u.type === 'Bug' && u.status === 'Completed');
+  const decisions = units.filter((u) => u.type === 'Decision' || u.decision !== null);
+  const blockers = units.filter((u) => u.type === 'Blocker' || u.status === 'Blocked');
+  const research = units.filter((u) => u.type === 'Research' || u.type === 'Spike');
+
+  console.log(pc.bold(pc.cyan('=== WEEKLY ENGINEERING SUMMARY ===\n')));
+
+  console.log(pc.bold(`Features Completed (${completedFeatures.length}):`));
+  if (completedFeatures.length === 0) console.log('  None');
+  for (const u of completedFeatures) {
+    console.log(`  - #${u.id}: ${u.title}`);
+  }
+  console.log('');
+
+  console.log(pc.bold(`Bugs Fixed (${fixedBugs.length}):`));
+  if (fixedBugs.length === 0) console.log('  None');
+  for (const u of fixedBugs) {
+    console.log(`  - #${u.id}: ${u.title}`);
+  }
+  console.log('');
+
+  console.log(pc.bold(`Decisions Made (${decisions.length}):`));
+  if (decisions.length === 0) console.log('  None');
+  for (const u of decisions) {
+    console.log(`  - #${u.id}: ${u.title}`);
+    if (u.decision) console.log(`    ✔ ${pc.green(u.decision)}`);
+  }
+  console.log('');
+
+  console.log(pc.bold(`Blockers Encountered (${blockers.length}):`));
+  if (blockers.length === 0) console.log('  None');
+  for (const u of blockers) {
+    console.log(`  - #${u.id}: ${u.title}`);
+    if (u.blocker) console.log(`    ✖ ${pc.red(u.blocker)}`);
+  }
+  console.log('');
+
+  console.log(pc.bold(`Research & Spikes (${research.length}):`));
+  if (research.length === 0) console.log('  None');
+  for (const u of research) {
+    console.log(`  - #${u.id}: ${u.title} (${u.type})`);
+  }
+  console.log('');
+
+  // Status & Type counts
+  const typeCounts: Record<string, number> = {};
+  const statusCounts: Record<string, number> = {};
+  for (const u of units) {
+    typeCounts[u.type] = (typeCounts[u.type] || 0) + 1;
+    statusCounts[u.status] = (statusCounts[u.status] || 0) + 1;
+  }
+
+  console.log(pc.bold('WORK UNITS BY STATUS:'));
+  for (const [status, count] of Object.entries(statusCounts)) {
+    console.log(`  - ${status.padEnd(15)}: ${count}`);
+  }
+  console.log('');
+
+  console.log(pc.bold('WORK UNITS BY TYPE:'));
+  for (const [type, count] of Object.entries(typeCounts)) {
+    console.log(`  - ${type.padEnd(15)}: ${count}`);
+  }
+}