@vanshbhardwaj/worklog 1.0.0

package/dist/index.js

@@ -0,0 +1,1873 @@
+#!/usr/bin/env node
+
+// node_modules/.pnpm/tsup@8.3.5_postcss@8.5.23_supports-color@7.2.0_typescript@5.7.2/node_modules/tsup/assets/esm_shims.js
+import { fileURLToPath } from "url";
+var getFilename = () => fileURLToPath(import.meta.url);
+var __filename = /* @__PURE__ */ getFilename();
+
+// src/cli/index.ts
+import { Command } from "commander";
+import pc8 from "picocolors";
+
+// src/core/discovery.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/errors/index.ts
+var WorkLogDomainError = class extends Error {
+  constructor(message, code, actionRequired) {
+    super(message);
+    this.code = code;
+    this.actionRequired = actionRequired;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var NotInitializedError = class extends WorkLogDomainError {
+  constructor() {
+    super(
+      "Not a WorkLog repository (or any of the parent directories): .worklog",
+      "NOT_INITIALIZED",
+      "Run 'worklog init' or 'worklog a' to initialize a new repository."
+    );
+  }
+};
+var DatabaseError = class extends WorkLogDomainError {
+  constructor(message, details) {
+    super(
+      `Database error: ${message}${details ? ` (${details})` : ""}`,
+      "DATABASE_ERROR",
+      "Please check your database integrity or log files."
+    );
+  }
+};
+var ValidationError = class extends WorkLogDomainError {
+  constructor(message) {
+    super(
+      `Validation error: ${message}`,
+      "VALIDATION_ERROR",
+      "Please provide valid inputs conforming to the schema."
+    );
+  }
+};
+var ConfigError = class extends WorkLogDomainError {
+  constructor(message) {
+    super(
+      `Configuration error: ${message}`,
+      "CONFIG_ERROR",
+      "Please check if .worklog/config.json is well-formed."
+    );
+  }
+};
+
+// src/core/discovery.ts
+function findWorkspaceRoot(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+  const rootPath = path.parse(current).root;
+  while (true) {
+    const candidate = path.join(current, ".worklog");
+    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
+      return current;
+    }
+    if (current === rootPath) {
+      break;
+    }
+    current = path.dirname(current);
+  }
+  return null;
+}
+function getWorkspaceRoot(startDir = process.cwd()) {
+  const root = findWorkspaceRoot(startDir);
+  if (!root) {
+    throw new NotInitializedError();
+  }
+  return root;
+}
+
+// src/core/logger.ts
+import pino from "pino";
+import * as path2 from "path";
+import * as fs2 from "fs";
+var loggerInstance = null;
+function getLogger() {
+  if (loggerInstance) {
+    return loggerInstance;
+  }
+  loggerInstance = pino({
+    level: "silent"
+  });
+  return loggerInstance;
+}
+function initLogger(workspaceRoot) {
+  const logDir = path2.join(workspaceRoot, ".worklog");
+  if (!fs2.existsSync(logDir)) {
+    fs2.mkdirSync(logDir, { recursive: true });
+  }
+  const logFile = path2.join(logDir, "worklog.log");
+  loggerInstance = pino(
+    {
+      level: process.env.WORKLOG_LOG_LEVEL || "info",
+      base: void 0,
+      // remove pid/hostname for clean local logs
+      timestamp: () => `,"time":"${(/* @__PURE__ */ new Date()).toISOString()}"`
+    },
+    pino.destination({
+      dest: logFile,
+      sync: true
+      // synchronous write to guarantee flush before CLI exit
+    })
+  );
+  return loggerInstance;
+}
+var logger = {
+  info: (obj, msg, ...args) => getLogger().info(obj, msg, ...args),
+  error: (obj, msg, ...args) => getLogger().error(obj, msg, ...args),
+  debug: (obj, msg, ...args) => getLogger().debug(obj, msg, ...args),
+  warn: (obj, msg, ...args) => getLogger().warn(obj, msg, ...args)
+};
+
+// src/database/connection.ts
+import { createRequire } from "module";
+import * as path3 from "path";
+import * as fs3 from "fs";
+var DatabaseConstructor;
+try {
+  const contextPath = typeof import.meta !== "undefined" && import.meta.url ? import.meta.url : typeof __filename !== "undefined" ? __filename : process.cwd() + "/package.json";
+  const requireFromDisk = createRequire(contextPath);
+  DatabaseConstructor = requireFromDisk("better-sqlite3");
+} catch {
+  try {
+    const requireFromDisk = createRequire(process.cwd() + "/package.json");
+    DatabaseConstructor = requireFromDisk("better-sqlite3");
+  } catch {
+    const execDir = path3.dirname(process.execPath);
+    const requireFromDisk = createRequire(execDir + "/package.json");
+    DatabaseConstructor = requireFromDisk("better-sqlite3");
+  }
+}
+var dbInstance = null;
+function connectDatabase(workspaceRoot) {
+  if (dbInstance) {
+    return dbInstance;
+  }
+  const dbDir = path3.join(workspaceRoot, ".worklog");
+  if (!fs3.existsSync(dbDir)) {
+    fs3.mkdirSync(dbDir, { recursive: true });
+  }
+  const dbPath = path3.join(dbDir, "worklog.db");
+  try {
+    const db = new DatabaseConstructor(dbPath);
+    db.pragma("foreign_keys = ON");
+    db.pragma("journal_mode = WAL");
+    db.pragma("synchronous = NORMAL");
+    db.pragma("temp_store = MEMORY");
+    dbInstance = db;
+    logger.debug({ dbPath }, "Connected to SQLite database successfully");
+    return db;
+  } catch (error) {
+    logger.error({ error, dbPath }, "Failed to connect to SQLite database");
+    throw new DatabaseError("Failed to connect to database", error.message);
+  }
+}
+function closeDatabase() {
+  if (dbInstance) {
+    try {
+      dbInstance.close();
+      logger.debug("Database connection closed");
+    } catch (error) {
+      logger.error({ error }, "Error closing database connection");
+    } finally {
+      dbInstance = null;
+    }
+  }
+}
+
+// src/database/migration-data.ts
+var MIGRATIONS = {
+  "001_initial.sql": `
+CREATE TABLE IF NOT EXISTS work_units (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  title TEXT NOT NULL,
+  type TEXT NOT NULL,
+  status TEXT NOT NULL,
+  priority TEXT,
+  module TEXT,
+  description TEXT,
+  next_step TEXT,
+  decision TEXT,
+  blocker TEXT,
+  notes TEXT,
+  created_at TEXT NOT NULL,
+  updated_at TEXT NOT NULL
+);
+
+-- Full Text Search Index Table
+CREATE VIRTUAL TABLE IF NOT EXISTS work_units_fts USING fts5(
+  title,
+  description,
+  decision,
+  blocker,
+  notes,
+  content=work_units,
+  content_rowid=id
+);
+
+-- Auto-sync Insert Trigger
+CREATE TRIGGER IF NOT EXISTS work_units_ai AFTER INSERT ON work_units BEGIN
+  INSERT INTO work_units_fts(rowid, title, description, decision, blocker, notes)
+  VALUES (new.id, new.title, new.description, new.decision, new.blocker, new.notes);
+END;
+
+-- Auto-sync Delete Trigger
+CREATE TRIGGER IF NOT EXISTS work_units_ad AFTER DELETE ON work_units BEGIN
+  INSERT INTO work_units_fts(work_units_fts, rowid, title, description, decision, blocker, notes)
+  VALUES('delete', old.id, old.title, old.description, old.decision, old.blocker, old.notes);
+END;
+
+-- Auto-sync Update Trigger
+CREATE TRIGGER IF NOT EXISTS work_units_au AFTER UPDATE ON work_units BEGIN
+  INSERT INTO work_units_fts(work_units_fts, rowid, title, description, decision, blocker, notes)
+  VALUES('delete', old.id, old.title, old.description, old.decision, old.blocker, old.notes);
+  INSERT INTO work_units_fts(rowid, title, description, decision, blocker, notes)
+  VALUES (new.id, new.title, new.description, new.decision, new.blocker, new.notes);
+END;
+  `,
+  "002_relational_tables.sql": `
+-- Junction table for tags
+CREATE TABLE IF NOT EXISTS work_unit_tags (
+  work_unit_id INTEGER NOT NULL,
+  tag TEXT NOT NULL,
+  PRIMARY KEY (work_unit_id, tag),
+  FOREIGN KEY (work_unit_id) REFERENCES work_units(id) ON DELETE CASCADE
+);
+
+-- Index for tag filtering performance
+CREATE INDEX IF NOT EXISTS idx_work_unit_tags_tag ON work_unit_tags(tag);
+
+-- Junction table for bidirectional relation mapping
+CREATE TABLE IF NOT EXISTS work_unit_relations (
+  work_unit_id INTEGER NOT NULL,
+  related_work_unit_id INTEGER NOT NULL,
+  PRIMARY KEY (work_unit_id, related_work_unit_id),
+  FOREIGN KEY (work_unit_id) REFERENCES work_units(id) ON DELETE CASCADE,
+  FOREIGN KEY (related_work_unit_id) REFERENCES work_units(id) ON DELETE CASCADE
+);
+  `
+};
+
+// src/database/migrations.ts
+function runMigrations(db) {
+  logger.debug("Starting database migrations run");
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS schema_migrations (
+        version TEXT PRIMARY KEY,
+        applied_at TEXT NOT NULL
+    );
+  `);
+  const files = Object.keys(MIGRATIONS).sort();
+  if (files.length === 0) {
+    logger.debug("No migration definitions found");
+    return;
+  }
+  const stmt = db.prepare("SELECT version FROM schema_migrations");
+  const applied = stmt.all().map((row) => row.version);
+  for (const file of files) {
+    if (applied.includes(file)) {
+      logger.debug({ migration: file }, "Migration already applied, skipping");
+      continue;
+    }
+    logger.info({ migration: file }, `Applying database migration: ${file}`);
+    const sql = MIGRATIONS[file];
+    const runMigrationTx = db.transaction(() => {
+      db.exec(sql);
+      const insertStmt = db.prepare(
+        "INSERT INTO schema_migrations (version, applied_at) VALUES (?, ?)"
+      );
+      insertStmt.run(file, (/* @__PURE__ */ new Date()).toISOString());
+    });
+    try {
+      runMigrationTx();
+      logger.info({ migration: file }, `Migration ${file} applied successfully`);
+    } catch (error) {
+      logger.error({ error, migration: file }, `Failed to apply migration: ${file}`);
+      throw new DatabaseError(`Failed to apply migration ${file}`, error.message);
+    }
+  }
+  logger.debug("Database migrations completed");
+}
+
+// src/repositories/work-unit.ts
+var WorkUnitRepository = class {
+  constructor(db) {
+    this.db = db;
+  }
+  /**
+   * Creates a new WorkUnit in the database.
+   * Inserts relations into work_unit_tags and work_unit_relations under a transaction.
+   */
+  create(workUnitData) {
+    const createTx = this.db.transaction(() => {
+      const insertUnit = this.db.prepare(`
+        INSERT INTO work_units (
+          title, type, status, priority, module, description, next_step, decision, blocker, notes, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      const result = insertUnit.run(
+        workUnitData.title,
+        workUnitData.type,
+        workUnitData.status,
+        workUnitData.priority,
+        workUnitData.module,
+        workUnitData.description,
+        workUnitData.nextStep,
+        workUnitData.decision,
+        workUnitData.blocker,
+        workUnitData.notes,
+        workUnitData.createdAt,
+        workUnitData.updatedAt
+      );
+      const workUnitId = Number(result.lastInsertRowid);
+      if (workUnitData.tags && workUnitData.tags.length > 0) {
+        const insertTag = this.db.prepare(`
+          INSERT INTO work_unit_tags (work_unit_id, tag) VALUES (?, ?)
+        `);
+        for (const tag of workUnitData.tags) {
+          insertTag.run(workUnitId, tag);
+        }
+      }
+      if (workUnitData.relatedWorkUnits && workUnitData.relatedWorkUnits.length > 0) {
+        const insertRelation = this.db.prepare(`
+          INSERT INTO work_unit_relations (work_unit_id, related_work_unit_id) VALUES (?, ?)
+        `);
+        const checkStmt = this.db.prepare("SELECT 1 FROM work_units WHERE id = ?");
+        for (const relId of workUnitData.relatedWorkUnits) {
+          if (!checkStmt.get(relId)) {
+            throw new DatabaseError(`Related work unit with ID ${relId} does not exist.`);
+          }
+          insertRelation.run(workUnitId, relId);
+        }
+      }
+      return workUnitId;
+    });
+    try {
+      const id = createTx();
+      return this.findById(id);
+    } catch (error) {
+      if (error instanceof DatabaseError) throw error;
+      throw new DatabaseError("Failed to create work unit", error.message);
+    }
+  }
+  /**
+   * Fetches a WorkUnit by ID and joins related tags and relations.
+   */
+  findById(id) {
+    try {
+      const selectUnit = this.db.prepare(`
+        SELECT * FROM work_units WHERE id = ?
+      `);
+      const row = selectUnit.get(id);
+      if (!row) {
+        return null;
+      }
+      const selectTags = this.db.prepare(`
+        SELECT tag FROM work_unit_tags WHERE work_unit_id = ? ORDER BY tag ASC
+      `);
+      const tags = selectTags.all(id).map((r) => r.tag);
+      const selectRelations = this.db.prepare(`
+        SELECT related_work_unit_id FROM work_unit_relations WHERE work_unit_id = ? ORDER BY related_work_unit_id ASC
+      `);
+      const related = selectRelations.all(id).map((r) => Number(r.related_work_unit_id));
+      return {
+        id: Number(row.id),
+        title: row.title,
+        type: row.type,
+        status: row.status,
+        priority: row.priority,
+        module: row.module,
+        description: row.description,
+        nextStep: row.next_step,
+        decision: row.decision,
+        blocker: row.blocker,
+        tags,
+        relatedWorkUnits: related,
+        notes: row.notes,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+      };
+    } catch (error) {
+      throw new DatabaseError(`Failed to find work unit by ID ${id}`, error.message);
+    }
+  }
+  /**
+   * Updates an existing WorkUnit.
+   * Handles differential updates for fields, tags, and relations.
+   */
+  update(id, workUnitData) {
+    const updateTx = this.db.transaction(() => {
+      const existing = this.findById(id);
+      if (!existing) {
+        throw new DatabaseError(`Work unit with ID ${id} not found.`);
+      }
+      const updates = [];
+      const values = [];
+      const fieldsMap = {
+        title: "title",
+        type: "type",
+        status: "status",
+        priority: "priority",
+        module: "module",
+        description: "description",
+        nextStep: "next_step",
+        decision: "decision",
+        blocker: "blocker",
+        notes: "notes",
+        updatedAt: "updated_at"
+      };
+      for (const [key, dbCol] of Object.entries(fieldsMap)) {
+        if (key in workUnitData) {
+          updates.push(`${dbCol} = ?`);
+          values.push(workUnitData[key]);
+        }
+      }
+      if (updates.length > 0) {
+        values.push(id);
+        const updateStmt = this.db.prepare(`
+          UPDATE work_units SET ${updates.join(", ")} WHERE id = ?
+        `);
+        updateStmt.run(...values);
+      }
+      if (workUnitData.tags !== void 0) {
+        const deleteTags = this.db.prepare("DELETE FROM work_unit_tags WHERE work_unit_id = ?");
+        deleteTags.run(id);
+        if (workUnitData.tags.length > 0) {
+          const insertTag = this.db.prepare(
+            "INSERT INTO work_unit_tags (work_unit_id, tag) VALUES (?, ?)"
+          );
+          for (const tag of workUnitData.tags) {
+            insertTag.run(id, tag);
+          }
+        }
+      }
+      if (workUnitData.relatedWorkUnits !== void 0) {
+        const deleteRelations = this.db.prepare(
+          "DELETE FROM work_unit_relations WHERE work_unit_id = ?"
+        );
+        deleteRelations.run(id);
+        if (workUnitData.relatedWorkUnits.length > 0) {
+          const insertRelation = this.db.prepare(
+            "INSERT INTO work_unit_relations (work_unit_id, related_work_unit_id) VALUES (?, ?)"
+          );
+          const checkStmt = this.db.prepare("SELECT 1 FROM work_units WHERE id = ?");
+          for (const relId of workUnitData.relatedWorkUnits) {
+            if (!checkStmt.get(relId)) {
+              throw new DatabaseError(`Related work unit with ID ${relId} does not exist.`);
+            }
+            insertRelation.run(id, relId);
+          }
+        }
+      }
+    });
+    try {
+      updateTx();
+      return this.findById(id);
+    } catch (error) {
+      if (error instanceof DatabaseError) throw error;
+      throw new DatabaseError(`Failed to update work unit by ID ${id}`, error.message);
+    }
+  }
+  /**
+   * Deletes a WorkUnit. Returns true if changes were made.
+   */
+  delete(id) {
+    try {
+      const deleteStmt = this.db.prepare("DELETE FROM work_units WHERE id = ?");
+      const info = deleteStmt.run(id);
+      return info.changes > 0;
+    } catch (error) {
+      throw new DatabaseError(`Failed to delete work unit by ID ${id}`, error.message);
+    }
+  }
+  /**
+   * Finds the most recent work units, ordered by creation date descending.
+   */
+  findRecent(limit = 10) {
+    try {
+      const selectIds = this.db.prepare(`
+        SELECT id FROM work_units ORDER BY created_at DESC LIMIT ?
+      `);
+      const rows = selectIds.all(limit);
+      return rows.map((row) => this.findById(row.id));
+    } catch (error) {
+      throw new DatabaseError("Failed to fetch recent work units", error.message);
+    }
+  }
+  /**
+   * Finds work units matching a specific status.
+   */
+  findByStatus(status) {
+    try {
+      const selectIds = this.db.prepare(`
+        SELECT id FROM work_units WHERE status = ? ORDER BY created_at DESC
+      `);
+      const rows = selectIds.all(status);
+      return rows.map((row) => this.findById(row.id));
+    } catch (error) {
+      throw new DatabaseError(`Failed to fetch work units by status: ${status}`, error.message);
+    }
+  }
+  /**
+   * Finds work units matching a specific type.
+   */
+  findByType(type) {
+    try {
+      const selectIds = this.db.prepare(`
+        SELECT id FROM work_units WHERE type = ? ORDER BY created_at DESC
+      `);
+      const rows = selectIds.all(type);
+      return rows.map((row) => this.findById(row.id));
+    } catch (error) {
+      throw new DatabaseError(`Failed to fetch work units by type: ${type}`, error.message);
+    }
+  }
+  /**
+   * Finds all unfinished work units (Planned, In Progress, Blocked) ordered by updatedAt descending.
+   */
+  findUnfinished() {
+    try {
+      const selectIds = this.db.prepare(`
+        SELECT id FROM work_units
+        WHERE status IN ('Planned', 'In Progress', 'Blocked')
+        ORDER BY updated_at DESC
+      `);
+      const rows = selectIds.all();
+      return rows.map((row) => this.findById(row.id));
+    } catch (error) {
+      throw new DatabaseError("Failed to fetch unfinished work units", error.message);
+    }
+  }
+  /**
+   * Finds work units created or updated since an ISO timestamp.
+   */
+  findCreatedOrUpdatedAfter(isoString) {
+    try {
+      const selectIds = this.db.prepare(`
+        SELECT id FROM work_units
+        WHERE created_at >= ? OR updated_at >= ?
+        ORDER BY created_at DESC
+      `);
+      const rows = selectIds.all(isoString, isoString);
+      return rows.map((row) => this.findById(row.id));
+    } catch (error) {
+      throw new DatabaseError(
+        `Failed to fetch work units updated after ${isoString}`,
+        error.message
+      );
+    }
+  }
+  /**
+   * Runs analytical SQL queries to fetch count aggregates.
+   */
+  getStats(sinceIsoString) {
+    try {
+      const totalCount = this.db.prepare("SELECT COUNT(*) as count FROM work_units").get().count;
+      const typeRows = this.db.prepare(
+        "SELECT type, COUNT(*) as count FROM work_units GROUP BY type ORDER BY count DESC"
+      ).all();
+      const typeDistribution = typeRows.map((r) => ({ type: r.type, count: r.count }));
+      const statusRows = this.db.prepare(
+        "SELECT status, COUNT(*) as count FROM work_units GROUP BY status ORDER BY count DESC"
+      ).all();
+      const statusDistribution = statusRows.map((r) => ({ status: r.status, count: r.count }));
+      const moduleRows = this.db.prepare(`
+          SELECT module, COUNT(*) as count FROM work_units
+          WHERE module IS NOT NULL AND module != ''
+          GROUP BY module ORDER BY count DESC
+        `).all();
+      const moduleDistribution = moduleRows.map((r) => ({ module: r.module, count: r.count }));
+      const dailyRows = this.db.prepare(`
+          SELECT date(created_at) as day, COUNT(*) as count FROM work_units
+          WHERE created_at >= ?
+          GROUP BY day ORDER BY day ASC
+        `).all(sinceIsoString);
+      const dailyActivity = dailyRows.map((r) => ({ day: r.day, count: r.count }));
+      return {
+        totalCount,
+        typeDistribution,
+        statusDistribution,
+        moduleDistribution,
+        dailyActivity
+      };
+    } catch (error) {
+      throw new DatabaseError("Failed to fetch aggregate statistics", error.message);
+    }
+  }
+  /**
+   * Case-insensitive, structured multi-criteria search combining FTS5 and standard filters.
+   */
+  search(query, filters = {}) {
+    try {
+      let ids = [];
+      const hasQuery = query.trim().length > 0;
+      if (hasQuery) {
+        const trimmed = query.trim();
+        const ftsQuery = `"${trimmed}" OR ${trimmed}*`;
+        try {
+          const stmt = this.db.prepare(`
+            SELECT rowid as id FROM work_units_fts WHERE work_units_fts MATCH ?
+          `);
+          ids = stmt.all(ftsQuery).map((r) => Number(r.id));
+        } catch (ftsError) {
+          logger.warn({ ftsError, query }, "FTS MATCH failed; using fallback LIKE list");
+          const fallbackStmt = this.db.prepare(`
+            SELECT id FROM work_units
+            WHERE title LIKE ? OR description LIKE ? OR notes LIKE ? OR decision LIKE ? OR blocker LIKE ?
+          `);
+          const likeParam = `%${trimmed}%`;
+          ids = fallbackStmt.all(likeParam, likeParam, likeParam, likeParam, likeParam).map((r) => Number(r.id));
+        }
+        if (ids.length === 0) {
+          return [];
+        }
+      }
+      const clauses = [];
+      const params = [];
+      if (hasQuery) {
+        clauses.push(`id IN (${ids.map(() => "?").join(",")})`);
+        params.push(...ids);
+      }
+      if (filters.module) {
+        clauses.push("LOWER(module) = LOWER(?)");
+        params.push(filters.module);
+      }
+      if (filters.status) {
+        clauses.push("LOWER(status) = LOWER(?)");
+        params.push(filters.status);
+      }
+      if (filters.type) {
+        clauses.push("LOWER(type) = LOWER(?)");
+        params.push(filters.type);
+      }
+      if (filters.tag) {
+        clauses.push(`id IN (
+          SELECT work_unit_id FROM work_unit_tags WHERE LOWER(tag) = LOWER(?)
+        )`);
+        params.push(filters.tag);
+      }
+      const whereClause = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+      const sql = `
+        SELECT id FROM work_units
+        ${whereClause}
+        ORDER BY created_at DESC
+      `;
+      const rows = this.db.prepare(sql).all(...params);
+      return rows.map((row) => this.findById(row.id));
+    } catch (error) {
+      throw new DatabaseError(`Search operation failed: ${error.message}`);
+    }
+  }
+};
+
+// src/validators/work-unit.ts
+import { z } from "zod";
+var WorkUnitTypeSchema = z.enum([
+  "Feature",
+  "Bug",
+  "Spike",
+  "Refactor",
+  "Improvement",
+  "Research",
+  "Decision",
+  "Blocker",
+  "Review",
+  "Idea"
+]);
+var WorkUnitStatusSchema = z.enum([
+  "Planned",
+  "In Progress",
+  "Blocked",
+  "Completed",
+  "Cancelled"
+]);
+var WorkUnitPrioritySchema = z.enum(["Low", "Medium", "High"]);
+var CreateWorkUnitSchema = z.object({
+  title: z.string().trim().min(1, "Title cannot be empty").max(200, "Title cannot exceed 200 characters"),
+  type: WorkUnitTypeSchema,
+  status: WorkUnitStatusSchema.default("Planned"),
+  priority: WorkUnitPrioritySchema.nullable().optional().default(null),
+  module: z.string().trim().max(100, "Module cannot exceed 100 characters").nullable().optional().default(null),
+  description: z.string().trim().nullable().optional().default(null),
+  nextStep: z.string().trim().nullable().optional().default(null),
+  decision: z.string().trim().nullable().optional().default(null),
+  blocker: z.string().trim().nullable().optional().default(null),
+  tags: z.array(
+    z.string().trim().min(1, "Tag cannot be empty").max(50, "Tag cannot exceed 50 characters")
+  ).optional().default([]),
+  relatedWorkUnits: z.array(z.number().int().positive()).optional().default([]),
+  notes: z.string().trim().nullable().optional().default(null)
+});
+var UpdateWorkUnitSchema = CreateWorkUnitSchema.partial();
+
+// src/services/work-unit.ts
+var WorkUnitService = class {
+  constructor(repo) {
+    this.repo = repo;
+  }
+  /**
+   * Validates creation input at the service boundary, assigns initial timestamps, and persists to database.
+   */
+  createWorkUnit(input) {
+    const result = CreateWorkUnitSchema.safeParse(input);
+    if (!result.success) {
+      const errorMsg = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new ValidationError(errorMsg);
+    }
+    const validated = result.data;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const workUnitData = {
+      ...validated,
+      createdAt: now,
+      updatedAt: now
+    };
+    return this.repo.create(workUnitData);
+  }
+  /**
+   * Validates update input, updates timestamp, and runs repository update statement.
+   */
+  updateWorkUnit(id, input) {
+    if (!id || id <= 0 || !Number.isInteger(id)) {
+      throw new ValidationError("A valid positive integer ID is required.");
+    }
+    const result = UpdateWorkUnitSchema.safeParse(input);
+    if (!result.success) {
+      const errorMsg = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join(", ");
+      throw new ValidationError(errorMsg);
+    }
+    const validated = result.data;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const workUnitData = {
+      ...validated,
+      updatedAt: now
+    };
+    return this.repo.update(id, workUnitData);
+  }
+  /**
+   * Fetches a WorkUnit by its ID. Throws on negative/decimal values.
+   */
+  getWorkUnit(id) {
+    if (!id || id <= 0 || !Number.isInteger(id)) {
+      throw new ValidationError("A valid positive integer ID is required.");
+    }
+    return this.repo.findById(id);
+  }
+  /**
+   * Deletes a WorkUnit by ID. Returns true if deleted.
+   */
+  deleteWorkUnit(id) {
+    if (!id || id <= 0 || !Number.isInteger(id)) {
+      throw new ValidationError("A valid positive integer ID is required.");
+    }
+    return this.repo.delete(id);
+  }
+  /**
+   * Retrieves recent WorkUnits.
+   */
+  getRecentWorkUnits(limit) {
+    return this.repo.findRecent(limit);
+  }
+  /**
+   * Retrieves WorkUnits filtered by Status.
+   */
+  getWorkUnitsByStatus(status) {
+    return this.repo.findByStatus(status);
+  }
+  /**
+   * Retrieves WorkUnits filtered by Type.
+   */
+  getWorkUnitsByType(type) {
+    return this.repo.findByType(type);
+  }
+  /**
+   * Retrieves all unfinished Work Units (Planned, In Progress, Blocked) sorted by updatedAt descending.
+   */
+  getUnfinishedWorkUnits() {
+    return this.repo.findUnfinished();
+  }
+  /**
+   * Retrieves Work Units created or updated since an ISO timestamp.
+   */
+  getCreatedOrUpdatedAfter(isoString) {
+    return this.repo.findCreatedOrUpdatedAfter(isoString);
+  }
+  /**
+   * Retrieves SQLite aggregated statistics.
+   */
+  getStats(sinceIsoString) {
+    return this.repo.getStats(sinceIsoString);
+  }
+  /**
+   * Searches WorkUnits by text query and structured filters.
+   */
+  searchWorkUnits(query, filters = {}) {
+    return this.repo.search(query, filters);
+  }
+};
+
+// src/cli/commands/init.ts
+import * as fs5 from "fs";
+import * as path5 from "path";
+import pc from "picocolors";
+
+// src/core/config.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+import { z as z2 } from "zod";
+var ConfigSchema = z2.object({
+  projectName: z2.string(),
+  createdAt: z2.string(),
+  schemaVersion: z2.number().default(1)
+});
+var DEFAULT_CONFIG_FILENAME = "config.json";
+function saveConfig(workspaceRoot, config) {
+  const dotWorklog = path4.join(workspaceRoot, ".worklog");
+  if (!fs4.existsSync(dotWorklog)) {
+    fs4.mkdirSync(dotWorklog, { recursive: true });
+  }
+  const configPath = path4.join(dotWorklog, DEFAULT_CONFIG_FILENAME);
+  try {
+    const validated = ConfigSchema.parse(config);
+    fs4.writeFileSync(configPath, JSON.stringify(validated, null, 2), "utf8");
+  } catch (error) {
+    throw new ConfigError(`Failed to save config: ${error.message}`);
+  }
+}
+function initConfig(workspaceRoot, projectName) {
+  const pName = projectName || path4.basename(path4.resolve(workspaceRoot));
+  const newConfig = {
+    projectName: pName,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    schemaVersion: 1
+  };
+  saveConfig(workspaceRoot, newConfig);
+  return newConfig;
+}
+
+// src/cli/commands/init.ts
+function initCommand(options) {
+  const targetDir = process.cwd();
+  const dotWorklog = path5.join(targetDir, ".worklog");
+  const exists = fs5.existsSync(dotWorklog) && fs5.statSync(dotWorklog).isDirectory();
+  if (!fs5.existsSync(dotWorklog)) {
+    fs5.mkdirSync(dotWorklog, { recursive: true });
+  }
+  const config = initConfig(targetDir, options.name);
+  initLogger(targetDir);
+  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}/`));
+  }
+}
+
+// src/cli/commands/add.ts
+import prompts from "prompts";
+import pc2 from "picocolors";
+function capitalize(val) {
+  if (!val) return val;
+  return val.charAt(0).toUpperCase() + val.slice(1).toLowerCase();
+}
+function parseStatus(val) {
+  if (!val) return val;
+  const lower = val.toLowerCase();
+  if (lower === "in-progress" || lower === "inprogress" || lower === "in_progress") {
+    return "In Progress";
+  }
+  return capitalize(val);
+}
+async function addCommand(service, options) {
+  let inputData;
+  if (!options.title) {
+    if (!process.stdin.isTTY) {
+      if (options.json) {
+        console.error(
+          JSON.stringify({
+            success: false,
+            error: "Title is required in non-interactive mode."
+          })
+        );
+      } else {
+        console.error(pc2.red("Error: Title is required in non-interactive mode."));
+      }
+      process.exit(1);
+    }
+    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(pc2.yellow("\nCancelled."));
+          }
+          process.exit(1);
+        }
+      }
+    );
+    const parsedTags = responses.tags ? responses.tags.split(",").map((t) => 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 {
+    const parsedTags = options.tags ? options.tags.split(",").map((t) => 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(pc2.green(`Created work unit #${created.id}: ${created.title}`));
+  }
+}
+
+// src/cli/ui.ts
+import pc3 from "picocolors";
+import Table from "cli-table3";
+function getTerminalWidth() {
+  return process.stdout.columns || 80;
+}
+function truncateText(text, maxLength) {
+  if (!text) return "";
+  const clean = text.replace(/\r?\n|\r/g, " ").trim();
+  if (clean.length <= maxLength) return clean;
+  return clean.substring(0, maxLength - 3) + "...";
+}
+function colorStatus(status) {
+  switch (status) {
+    case "Planned":
+      return pc3.gray("Planned");
+    case "In Progress":
+      return pc3.blue("In Progress");
+    case "Blocked":
+      return pc3.red("Blocked");
+    case "Completed":
+      return pc3.green("Completed");
+    case "Cancelled":
+      return pc3.strikethrough(pc3.gray("Cancelled"));
+    default:
+      return status;
+  }
+}
+function colorType(type) {
+  switch (type) {
+    case "Feature":
+      return pc3.cyan("Feature");
+    case "Bug":
+      return pc3.red("Bug");
+    case "Spike":
+      return pc3.magenta("Spike");
+    case "Refactor":
+      return pc3.yellow("Refactor");
+    case "Improvement":
+      return pc3.green("Improvement");
+    case "Research":
+      return pc3.blue("Research");
+    case "Decision":
+      return pc3.cyan(pc3.bold("Decision"));
+    case "Blocker":
+      return pc3.bgRed(pc3.white("Blocker"));
+    case "Review":
+      return pc3.yellow("Review");
+    case "Idea":
+      return pc3.gray("Idea");
+    default:
+      return type;
+  }
+}
+function colorPriority(priority) {
+  if (!priority) return pc3.gray("-");
+  switch (priority) {
+    case "High":
+      return pc3.red("High");
+    case "Medium":
+      return pc3.yellow("Medium");
+    case "Low":
+      return pc3.green("Low");
+    default:
+      return priority;
+  }
+}
+function formatTable(workUnits) {
+  if (workUnits.length === 0) {
+    return "No work units found.";
+  }
+  const table = new Table({
+    head: [
+      pc3.bold("ID"),
+      pc3.bold("Title"),
+      pc3.bold("Type"),
+      pc3.bold("Status"),
+      pc3.bold("Module"),
+      pc3.bold("Priority"),
+      pc3.bold("Created At")
+    ],
+    chars: {
+      top: "",
+      "top-mid": "",
+      "top-left": "",
+      "top-right": "",
+      bottom: "",
+      "bottom-mid": "",
+      "bottom-left": "",
+      "bottom-right": "",
+      left: "",
+      "left-mid": "",
+      mid: "",
+      "mid-mid": "",
+      right: "",
+      "right-mid": "",
+      middle: " "
+    },
+    style: { "padding-left": 0, "padding-right": 2, head: [] }
+  });
+  const width = getTerminalWidth();
+  const titleMaxWidth = Math.max(20, width - 75);
+  for (const unit of workUnits) {
+    const formattedDate = new Date(unit.createdAt).toLocaleDateString(void 0, {
+      month: "short",
+      day: "numeric"
+    });
+    table.push([
+      pc3.gray(`#${unit.id}`),
+      truncateText(unit.title, titleMaxWidth),
+      colorType(unit.type),
+      colorStatus(unit.status),
+      unit.module ? pc3.yellow(unit.module) : pc3.gray("-"),
+      colorPriority(unit.priority),
+      pc3.gray(formattedDate)
+    ]);
+  }
+  return table.toString();
+}
+function formatWorkUnitDetail(unit) {
+  const lines = [];
+  lines.push(`${pc3.bold(pc3.cyan(`[#${unit.id}] ${unit.title}`))}`);
+  lines.push(`${pc3.gray("--------------------------------------------------")}`);
+  lines.push(`${pc3.bold("Type:")}      ${colorType(unit.type)}`);
+  lines.push(`${pc3.bold("Status:")}    ${colorStatus(unit.status)}`);
+  if (unit.priority) {
+    lines.push(`${pc3.bold("Priority:")}  ${colorPriority(unit.priority)}`);
+  }
+  if (unit.module) {
+    lines.push(`${pc3.bold("Module:")}    ${pc3.yellow(unit.module)}`);
+  }
+  if (unit.tags && unit.tags.length > 0) {
+    lines.push(`${pc3.bold("Tags:")}      ${unit.tags.map((t) => pc3.blue(t)).join(", ")}`);
+  }
+  if (unit.relatedWorkUnits && unit.relatedWorkUnits.length > 0) {
+    lines.push(
+      `${pc3.bold("Related:")}   ${unit.relatedWorkUnits.map((id) => pc3.gray(`#${id}`)).join(", ")}`
+    );
+  }
+  lines.push(`${pc3.bold("Created:")}   ${new Date(unit.createdAt).toLocaleString()}`);
+  lines.push(`${pc3.bold("Updated:")}   ${new Date(unit.updatedAt).toLocaleString()}`);
+  if (unit.description) {
+    lines.push("");
+    lines.push(`${pc3.bold("Description:")}`);
+    lines.push(unit.description);
+  }
+  if (unit.nextStep) {
+    lines.push("");
+    lines.push(`${pc3.bold("Next Step:")}`);
+    lines.push(pc3.blue(`-> ${unit.nextStep}`));
+  }
+  if (unit.decision) {
+    lines.push("");
+    lines.push(`${pc3.bold("Decision:")}`);
+    lines.push(pc3.green(`\u2714 ${unit.decision}`));
+  }
+  if (unit.blocker) {
+    lines.push("");
+    lines.push(`${pc3.bold("Blocker:")}`);
+    lines.push(pc3.red(`\u2716 ${unit.blocker}`));
+  }
+  if (unit.notes) {
+    lines.push("");
+    lines.push(`${pc3.bold("Notes:")}`);
+    lines.push(unit.notes);
+  }
+  return lines.join("\n");
+}
+function formatDashboard(inProgress, recentlyUpdated, needsAttention) {
+  const lines = [];
+  lines.push(pc3.bold(pc3.cyan("=== WORKLOG DASHBOARD ===\n")));
+  lines.push(pc3.bold("CURRENTLY IN PROGRESS:"));
+  if (inProgress.length === 0) {
+    lines.push(pc3.gray("  (No tasks currently in progress)"));
+  } else {
+    for (const u of inProgress) {
+      lines.push(
+        `  ${pc3.gray(`#${u.id}`)} ${pc3.bold(u.title)}${u.module ? ` [${u.module}]` : ""}`
+      );
+      if (u.nextStep) {
+        lines.push(`    ${pc3.blue("->")} ${pc3.gray(u.nextStep)}`);
+      }
+    }
+  }
+  lines.push("");
+  lines.push(pc3.bold("NEEDS ATTENTION:"));
+  if (needsAttention.length === 0) {
+    lines.push(pc3.gray("  (No blocked or planned tasks requiring attention)"));
+  } else {
+    for (const u of needsAttention) {
+      const reason = u.status === "Blocked" ? pc3.red(`[Blocked: ${u.blocker || "Unknown"}]`) : pc3.yellow("[Planned]");
+      lines.push(`  ${pc3.gray(`#${u.id}`)} ${reason} ${u.title}`);
+    }
+  }
+  lines.push("");
+  lines.push(pc3.bold("RECENTLY UPDATED:"));
+  if (recentlyUpdated.length === 0) {
+    lines.push(pc3.gray("  (No recent updates)"));
+  } else {
+    for (const u of recentlyUpdated) {
+      const date = new Date(u.updatedAt).toLocaleDateString(void 0, {
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit"
+      });
+      lines.push(
+        `  ${pc3.gray(`#${u.id}`)} ${pc3.gray(`[${date}]`)} ${u.title} (${colorStatus(u.status)})`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function formatStats(stats) {
+  const lines = [];
+  lines.push(pc3.bold(pc3.cyan("=== ENGINEERING INSIGHTS ===\n")));
+  lines.push(`${pc3.bold("Total Work Units:")} ${stats.totalCount}
+`);
+  lines.push(pc3.bold("STATUS DISTRIBUTION:"));
+  for (const item of stats.statusDistribution) {
+    lines.push(`  ${item.status.padEnd(15)} : ${item.count}`);
+  }
+  lines.push("");
+  lines.push(pc3.bold("TYPE DISTRIBUTION:"));
+  for (const item of stats.typeDistribution) {
+    lines.push(`  ${item.type.padEnd(15)} : ${item.count}`);
+  }
+  lines.push("");
+  lines.push(pc3.bold("MODULE DISTRIBUTION:"));
+  if (stats.moduleDistribution.length === 0) {
+    lines.push("  No modules tracked.");
+  } else {
+    for (const item of stats.moduleDistribution) {
+      lines.push(`  ${item.module.padEnd(15)} : ${item.count}`);
+    }
+  }
+  lines.push("");
+  lines.push(pc3.bold("ACTIVITY IN THE PAST 7 DAYS:"));
+  if (stats.dailyActivity.length === 0) {
+    lines.push("  No work logged in the past 7 days.");
+  } else {
+    for (const item of stats.dailyActivity) {
+      const bar = "*".repeat(item.count);
+      lines.push(`  ${item.day} : ${bar} (${item.count})`);
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/list.ts
+function listCommand(service, options) {
+  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));
+  }
+}
+
+// src/cli/commands/show.ts
+import pc4 from "picocolors";
+function showCommand(service, idStr, options) {
+  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(pc4.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(pc4.red(`Error: Work unit #${id} not found.`));
+    }
+    process.exit(1);
+  }
+  if (options.json) {
+    console.log(JSON.stringify(unit));
+  } else {
+    console.log(formatWorkUnitDetail(unit));
+  }
+}
+
+// src/cli/commands/search.ts
+function searchCommand(service, query, options) {
+  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));
+  }
+}
+
+// src/cli/commands/today.ts
+function todayCommand(service, options) {
+  const startOfToday = /* @__PURE__ */ 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));
+  }
+}
+
+// src/cli/commands/week.ts
+import pc5 from "picocolors";
+function weekCommand(service, options) {
+  const sevenDaysAgo = /* @__PURE__ */ 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;
+  }
+  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(pc5.bold(pc5.cyan("=== WEEKLY ENGINEERING SUMMARY ===\n")));
+  console.log(pc5.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(pc5.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(pc5.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(`    \u2714 ${pc5.green(u.decision)}`);
+  }
+  console.log("");
+  console.log(pc5.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(`    \u2716 ${pc5.red(u.blocker)}`);
+  }
+  console.log("");
+  console.log(pc5.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("");
+  const typeCounts = {};
+  const statusCounts = {};
+  for (const u of units) {
+    typeCounts[u.type] = (typeCounts[u.type] || 0) + 1;
+    statusCounts[u.status] = (statusCounts[u.status] || 0) + 1;
+  }
+  console.log(pc5.bold("WORK UNITS BY STATUS:"));
+  for (const [status, count] of Object.entries(statusCounts)) {
+    console.log(`  - ${status.padEnd(15)}: ${count}`);
+  }
+  console.log("");
+  console.log(pc5.bold("WORK UNITS BY TYPE:"));
+  for (const [type, count] of Object.entries(typeCounts)) {
+    console.log(`  - ${type.padEnd(15)}: ${count}`);
+  }
+}
+
+// src/cli/commands/dashboard.ts
+function dashboardCommand(service, options) {
+  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);
+  if (options.json) {
+    console.log(
+      JSON.stringify({
+        inProgress,
+        recentlyUpdated,
+        needsAttention
+      })
+    );
+  } else {
+    console.log(formatDashboard(inProgress, recentlyUpdated, needsAttention));
+  }
+}
+
+// src/cli/commands/continue.ts
+import prompts2 from "prompts";
+import pc6 from "picocolors";
+async function continueCommand(service, options) {
+  const unfinished = service.getUnfinishedWorkUnits();
+  if (unfinished.length === 0) {
+    if (options.json) {
+      console.log(JSON.stringify({ success: false, error: "No unfinished work units found." }));
+    } else {
+      console.log(pc6.yellow("No unfinished work units found."));
+    }
+    return;
+  }
+  let selectedUnit = unfinished[0];
+  if (unfinished.length > 1) {
+    if (!process.stdin.isTTY) {
+      selectedUnit = unfinished[0];
+    } else {
+      const choices = unfinished.map((u) => ({
+        title: `#${u.id} - ${u.title} (${u.status})`,
+        value: u
+      }));
+      const response = await prompts2(
+        {
+          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(pc6.yellow("\nCancelled."));
+            }
+            process.exit(1);
+          }
+        }
+      );
+      if (!response.unit) {
+        process.exit(1);
+      }
+      selectedUnit = response.unit;
+    }
+  }
+  const updated = service.updateWorkUnit(selectedUnit.id, {
+    status: "In Progress"
+  });
+  if (options.json) {
+    console.log(JSON.stringify(updated));
+  } else {
+    console.log(
+      pc6.green(
+        `Resumed work unit #${updated.id}: ${updated.title} (Status updated to 'In Progress')`
+      )
+    );
+  }
+}
+
+// src/cli/commands/stats.ts
+function statsCommand(service, options) {
+  const sevenDaysAgo = /* @__PURE__ */ 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));
+  }
+}
+
+// src/cli/commands/export.ts
+import * as fs6 from "fs";
+import pc7 from "picocolors";
+
+// src/exporters/markdown.ts
+function formatSingleMarkdown(u) {
+  const lines = [];
+  lines.push(`# [#${u.id}] ${u.title}
+`);
+  lines.push(`- **Type:** ${u.type}`);
+  lines.push(`- **Status:** ${u.status}`);
+  if (u.priority) lines.push(`- **Priority:** ${u.priority}`);
+  if (u.module) lines.push(`- **Module:** ${u.module}`);
+  if (u.tags && u.tags.length > 0) lines.push(`- **Tags:** ${u.tags.join(", ")}`);
+  lines.push(`- **Created:** ${u.createdAt}`);
+  lines.push(`- **Updated:** ${u.updatedAt}`);
+  lines.push("");
+  if (u.description) {
+    lines.push("## Description");
+    lines.push(u.description);
+    lines.push("");
+  }
+  if (u.nextStep) {
+    lines.push(`## Next Step
+-> ${u.nextStep}
+`);
+  }
+  if (u.decision) {
+    lines.push(`## Decision
+\u2714 ${u.decision}
+`);
+  }
+  if (u.blocker) {
+    lines.push(`## Blocker
+\u2716 ${u.blocker}
+`);
+  }
+  if (u.notes) {
+    lines.push("## Notes");
+    lines.push(u.notes);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function exportToMarkdown(units) {
+  if (!units) return "No work units found.\n";
+  if (!Array.isArray(units)) {
+    return formatSingleMarkdown(units);
+  }
+  if (units.length === 0) {
+    return "No work units found.\n";
+  }
+  const lines = [];
+  lines.push("# WorkLog Export\n");
+  const statuses = ["In Progress", "Blocked", "Planned", "Completed", "Cancelled"];
+  for (const status of statuses) {
+    const filtered = units.filter((u) => u.status === status);
+    if (filtered.length === 0) continue;
+    lines.push(`## ${status}`);
+    for (const u of filtered) {
+      const moduleStr = u.module ? ` [${u.module}]` : "";
+      lines.push(`- **#${u.id}**: ${u.title}${moduleStr} (${u.type})`);
+      if (u.nextStep) {
+        lines.push(`  - *Next step:* ${u.nextStep}`);
+      }
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/exporters/csv.ts
+function escapeCSV(val) {
+  if (val === null || val === void 0) return "";
+  const str = String(val);
+  if (str.includes(",") || str.includes('"') || str.includes("\n") || str.includes("\r")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function exportToCSV(units) {
+  const list = Array.isArray(units) ? units : [units];
+  const headers = [
+    "ID",
+    "Title",
+    "Type",
+    "Status",
+    "Priority",
+    "Module",
+    "Description",
+    "Next Step",
+    "Decision",
+    "Blocker",
+    "Tags",
+    "Related Work Units",
+    "Notes",
+    "Created At",
+    "Updated At"
+  ];
+  const lines = [headers.join(",")];
+  for (const u of list) {
+    const row = [
+      u.id,
+      escapeCSV(u.title),
+      escapeCSV(u.type),
+      escapeCSV(u.status),
+      escapeCSV(u.priority),
+      escapeCSV(u.module),
+      escapeCSV(u.description),
+      escapeCSV(u.nextStep),
+      escapeCSV(u.decision),
+      escapeCSV(u.blocker),
+      escapeCSV(u.tags.join(";")),
+      escapeCSV(u.relatedWorkUnits.join(";")),
+      escapeCSV(u.notes),
+      escapeCSV(u.createdAt),
+      escapeCSV(u.updatedAt)
+    ];
+    lines.push(row.join(","));
+  }
+  return lines.join("\n") + "\n";
+}
+
+// src/exporters/json.ts
+function exportToJSON(units) {
+  return JSON.stringify(units, null, 2) + "\n";
+}
+
+// src/cli/commands/export.ts
+function exportCommand(service, options) {
+  let data;
+  if (options.id) {
+    const id = Number(options.id);
+    if (isNaN(id) || !Number.isInteger(id) || id <= 0) {
+      console.error(pc7.red("Error: A valid positive integer ID is required."));
+      process.exit(1);
+    }
+    const unit = service.getWorkUnit(id);
+    if (!unit) {
+      console.error(pc7.red(`Error: Work unit #${id} not found.`));
+      process.exit(1);
+    }
+    data = unit;
+  } else {
+    data = service.getRecentWorkUnits(1e6);
+  }
+  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(
+        pc7.red(
+          `Error: Unsupported format '${options.format}'. Supported: markdown (md), csv, json.`
+        )
+      );
+      process.exit(1);
+  }
+  if (options.output) {
+    try {
+      fs6.writeFileSync(options.output, formatted, "utf8");
+      console.log(pc7.green(`Exported successfully to ${options.output}`));
+    } catch (error) {
+      console.error(pc7.red(`Error: Failed to write to file '${options.output}': ${error.message}`));
+      process.exit(1);
+    }
+  } else {
+    process.stdout.write(formatted);
+  }
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("worklog").description("WorkLog - Engineering Context Manager").version("0.1.0").option("--verbose", "enable verbose debug logging").option("--json", "output in machine-readable JSON format");
+function bootstrap() {
+  const root = getWorkspaceRoot();
+  initLogger(root);
+  const db = connectDatabase(root);
+  runMigrations(db);
+  const repo = new WorkUnitRepository(db);
+  return new WorkUnitService(repo);
+}
+function handleError(error) {
+  const isVerbose = program.opts().verbose;
+  const isJson = program.opts().json;
+  const isUserError = error instanceof WorkLogDomainError && error.code !== "DATABASE_ERROR";
+  if (isUserError) {
+    logger.error({ error, code: error.code }, "Domain error occurred");
+    if (isJson) {
+      console.error(JSON.stringify({ success: false, code: error.code, error: error.message }));
+    } else {
+      console.error(pc8.red(`Error: ${error.message}`));
+      if (error.actionRequired) {
+        console.error(pc8.yellow(`Action required: ${error.actionRequired}`));
+      }
+    }
+    process.exit(1);
+  } else {
+    logger.error({ error }, "Unexpected system error");
+    if (isJson) {
+      console.error(
+        JSON.stringify({ success: false, code: "INTERNAL_ERROR", error: error.message })
+      );
+    } else {
+      console.error(pc8.red(`Unexpected Error: ${error.message}`));
+      if (isVerbose) {
+        console.error(pc8.gray(error.stack || ""));
+      } else {
+        console.error(pc8.yellow("Run with --verbose to view stack traces."));
+      }
+    }
+    process.exit(2);
+  }
+}
+program.command("init").alias("i").description("Initialize a new WorkLog repository").option("--name <name>", "override default project name").action((options) => {
+  try {
+    const json = program.opts().json || options.json;
+    initCommand({ ...options, json });
+  } catch (error) {
+    handleError(error);
+  }
+});
+program.command("add").alias("a").description("Create a new Work Unit").option("-t, --title <title>", "title of the work unit").option(
+  "--type <type>",
+  "type of the work unit (Feature, Bug, Spike, Refactor, Improvement, Research, Decision, Blocker, Review, Idea)"
+).option(
+  "--status <status>",
+  "status of the work unit (Planned, In Progress, Blocked, Completed, Cancelled)"
+).option("--priority <priority>", "priority of the work unit (Low, Medium, High)").option("--module <module>", "associated component or code module").option("--tags <tags>", "comma-separated tags list").option("-d, --description <desc>", "detailed description").option("-n, --next <next>", "next step/action").option("--notes <notes>", "implementation notes").action(async (options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    await addCommand(service, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("list").alias("ls").description("List recent Work Units").option("-l, --limit <limit>", "limit output count", "20").option("-s, --status <status>", "filter by status").option("-t, --type <type>", "filter by type").action((options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    listCommand(service, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("show <id>").alias("sh").description("Show details for a specific Work Unit").action((id, options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    showCommand(service, id, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("search [query]").alias("s").description("Search Work Units by keyword and category filters").option("--tag <tag>", "filter search results by tag").option("--module <module>", "filter search results by module").option("--status <status>", "filter search results by status").option("--type <type>", "filter search results by type").action((query, options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    searchCommand(service, query, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("today").alias("t").description("Show work units updated today").action((options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    todayCommand(service, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("week").alias("w").description("Show weekly engineering summary").action((options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    weekCommand(service, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("dashboard").alias("db").description("Show clean project dashboard overview").action((options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    dashboardCommand(service, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("continue").alias("co").description("Resume work on the most recent unfinished task").action(async (options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    await continueCommand(service, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("stats").alias("st").description("Show total stats and category distributions").action((options) => {
+  try {
+    const service = bootstrap();
+    const json = program.opts().json || options.json;
+    statsCommand(service, { ...options, json });
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.command("export").alias("ex").description("Export Work Units to Markdown, CSV, or JSON").option("-f, --format <format>", "export format (markdown, csv, json)", "markdown").option("-o, --output <file>", "write output directly to a file").option("--id <id>", "export a single work unit by its ID").action((options) => {
+  try {
+    const service = bootstrap();
+    exportCommand(service, options);
+  } catch (error) {
+    handleError(error);
+  } finally {
+    closeDatabase();
+  }
+});
+program.on("command:*", () => {
+  const isJson = program.opts().json;
+  const command = program.args.join(" ");
+  if (isJson) {
+    console.error(
+      JSON.stringify({ success: false, code: "UNKNOWN_COMMAND", error: `Unknown command: ${command}` })
+    );
+  } else {
+    console.error(pc8.red(`Error: Unknown command: ${command}`));
+    console.error(`Run 'worklog --help' for a list of available commands.`);
+  }
+  process.exit(1);
+});
+program.parse(process.argv);
+//# sourceMappingURL=index.js.map