@towles/tool 0.0.109 → 0.0.111

package/src/commands/journal/list.test.ts

@@ -0,0 +1,174 @@
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import {
+  collectJournalEntries,
+  filterAndSortEntries,
+  formatSize,
+  formatDate,
+  renderTable,
+} from "./list.js";
+import type { JournalEntry } from "./list.js";
+import { JOURNAL_TYPES } from "../../types/journal.js";
+
+describe("journal list", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = path.join(tmpdir(), `journal-list-test-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe("collectJournalEntries", () => {
+    it("collects entries with metadata", () => {
+      const dailyDir = path.join(tmpDir, "daily-notes");
+      mkdirSync(dailyDir, { recursive: true });
+      writeFileSync(path.join(dailyDir, "2026-03-15-saturday.md"), "hello world");
+
+      const files = [path.join(dailyDir, "2026-03-15-saturday.md")];
+      const entries = collectJournalEntries(files, tmpDir);
+
+      expect(entries).toHaveLength(1);
+      expect(entries[0].relativePath).toBe(path.join("daily-notes", "2026-03-15-saturday.md"));
+      expect(entries[0].type).toBe(JOURNAL_TYPES.DAILY_NOTES);
+      expect(entries[0].date).not.toBeNull();
+      expect(entries[0].date!.getFullYear()).toBe(2026);
+      expect(entries[0].size).toBeGreaterThan(0);
+    });
+
+    it("skips files that cannot be stat'd", () => {
+      const entries = collectJournalEntries(["/nonexistent/file.md"], tmpDir);
+      expect(entries).toHaveLength(0);
+    });
+  });
+
+  describe("filterAndSortEntries", () => {
+    const makeEntry = (overrides: Partial<JournalEntry>): JournalEntry => ({
+      filePath: "/tmp/file.md",
+      relativePath: "file.md",
+      type: null,
+      date: null,
+      size: 100,
+      ...overrides,
+    });
+
+    it("filters by type", () => {
+      const entries = [
+        makeEntry({ type: JOURNAL_TYPES.DAILY_NOTES, relativePath: "a.md" }),
+        makeEntry({ type: JOURNAL_TYPES.MEETING, relativePath: "b.md" }),
+        makeEntry({ type: JOURNAL_TYPES.NOTE, relativePath: "c.md" }),
+      ];
+
+      const result = filterAndSortEntries(entries, {
+        type: JOURNAL_TYPES.MEETING,
+        limit: 20,
+        sort: "date",
+      });
+      expect(result).toHaveLength(1);
+      expect(result[0].type).toBe(JOURNAL_TYPES.MEETING);
+    });
+
+    it("sorts by date descending", () => {
+      const entries = [
+        makeEntry({ date: new Date(2026, 0, 1), relativePath: "jan.md" }),
+        makeEntry({ date: new Date(2026, 2, 15), relativePath: "mar.md" }),
+        makeEntry({ date: new Date(2026, 1, 10), relativePath: "feb.md" }),
+      ];
+
+      const result = filterAndSortEntries(entries, { limit: 20, sort: "date" });
+      expect(result[0].relativePath).toBe("mar.md");
+      expect(result[1].relativePath).toBe("feb.md");
+      expect(result[2].relativePath).toBe("jan.md");
+    });
+
+    it("sorts by name alphabetically", () => {
+      const entries = [
+        makeEntry({ relativePath: "c.md" }),
+        makeEntry({ relativePath: "a.md" }),
+        makeEntry({ relativePath: "b.md" }),
+      ];
+
+      const result = filterAndSortEntries(entries, { limit: 20, sort: "name" });
+      expect(result[0].relativePath).toBe("a.md");
+      expect(result[1].relativePath).toBe("b.md");
+      expect(result[2].relativePath).toBe("c.md");
+    });
+
+    it("respects limit", () => {
+      const entries = [
+        makeEntry({ relativePath: "a.md" }),
+        makeEntry({ relativePath: "b.md" }),
+        makeEntry({ relativePath: "c.md" }),
+      ];
+
+      const result = filterAndSortEntries(entries, { limit: 2, sort: "name" });
+      expect(result).toHaveLength(2);
+    });
+
+    it("puts entries without dates last when sorting by date", () => {
+      const entries = [
+        makeEntry({ date: null, relativePath: "no-date.md" }),
+        makeEntry({ date: new Date(2026, 5, 1), relativePath: "with-date.md" }),
+      ];
+
+      const result = filterAndSortEntries(entries, { limit: 20, sort: "date" });
+      expect(result[0].relativePath).toBe("with-date.md");
+      expect(result[1].relativePath).toBe("no-date.md");
+    });
+  });
+
+  describe("formatSize", () => {
+    it("formats bytes", () => {
+      expect(formatSize(500)).toBe("500B");
+    });
+
+    it("formats kilobytes", () => {
+      expect(formatSize(2048)).toBe("2.0KB");
+    });
+
+    it("formats megabytes", () => {
+      expect(formatSize(1048576)).toBe("1.0MB");
+    });
+  });
+
+  describe("formatDate", () => {
+    it("formats a valid date", () => {
+      expect(formatDate(new Date(2026, 2, 15))).toBe("2026-03-15");
+    });
+
+    it("returns dash for null", () => {
+      expect(formatDate(null)).toBe("-");
+    });
+  });
+
+  describe("renderTable", () => {
+    it("renders a formatted table with header and rows", () => {
+      const entries: JournalEntry[] = [
+        {
+          filePath: "/tmp/daily-notes/2026-03-15.md",
+          relativePath: "daily-notes/2026-03-15.md",
+          type: JOURNAL_TYPES.DAILY_NOTES,
+          date: new Date(2026, 2, 15),
+          size: 1234,
+        },
+      ];
+
+      const table = renderTable(entries);
+      const lines = table.split("\n");
+      expect(lines).toHaveLength(2); // header + 1 row
+      expect(lines[0]).toContain("FILE");
+      expect(lines[0]).toContain("TYPE");
+      expect(lines[0]).toContain("DATE");
+      expect(lines[0]).toContain("SIZE");
+      expect(lines[1]).toContain("daily-notes/2026-03-15.md");
+      expect(lines[1]).toContain("daily-notes");
+      expect(lines[1]).toContain("2026-03-15");
+      expect(lines[1]).toContain("1.2KB");
+    });
+  });
+});

package/src/commands/journal/list.ts

@@ -0,0 +1,213 @@
+import { statSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { defineCommand } from "citty";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { withSettings, debugArg } from "../shared.js";
+import type { JournalType } from "../../types/journal.js";
+import { JOURNAL_TYPES } from "../../types/journal.js";
+import { collectMarkdownFiles, inferTypeFromPath, extractDateFromFilename } from "./search.js";
+
+export interface JournalEntry {
+  filePath: string;
+  relativePath: string;
+  type: JournalType | null;
+  date: Date | null;
+  size: number;
+}
+
+export interface ListOptions {
+  type?: JournalType;
+  limit: number;
+  sort: "date" | "name";
+}
+
+/**
+ * Collect journal entries with metadata from a list of file paths.
+ */
+export function collectJournalEntries(files: string[], baseDir: string): JournalEntry[] {
+  const entries: JournalEntry[] = [];
+  for (const filePath of files) {
+    let size = 0;
+    try {
+      size = statSync(filePath).size;
+    } catch {
+      continue;
+    }
+    entries.push({
+      filePath,
+      relativePath: path.relative(baseDir, filePath),
+      type: inferTypeFromPath(filePath),
+      date: extractDateFromFilename(filePath),
+      size,
+    });
+  }
+  return entries;
+}
+
+/**
+ * Filter and sort journal entries based on options.
+ */
+export function filterAndSortEntries(
+  entries: JournalEntry[],
+  options: ListOptions,
+): JournalEntry[] {
+  let filtered = entries;
+
+  if (options.type) {
+    filtered = filtered.filter((e) => e.type === options.type);
+  }
+
+  filtered.sort((a, b) => {
+    if (options.sort === "date") {
+      const dateA = a.date?.getTime() ?? 0;
+      const dateB = b.date?.getTime() ?? 0;
+      return dateB - dateA; // newest first
+    }
+    return a.relativePath.localeCompare(b.relativePath);
+  });
+
+  return filtered.slice(0, options.limit);
+}
+
+/**
+ * Format a file size in bytes to a human-readable string.
+ */
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes}B`;
+  const kb = bytes / 1024;
+  if (kb < 1024) return `${kb.toFixed(1)}KB`;
+  const mb = kb / 1024;
+  return `${mb.toFixed(1)}MB`;
+}
+
+/**
+ * Format a date as YYYY-MM-DD or return "-" if null.
+ */
+export function formatDate(date: Date | null): string {
+  if (!date) return "-";
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+
+/**
+ * Render journal entries as a formatted table.
+ */
+export function renderTable(entries: JournalEntry[]): string {
+  const header = { file: "FILE", type: "TYPE", date: "DATE", size: "SIZE" };
+  const rows = entries.map((e) => ({
+    file: e.relativePath,
+    type: e.type ?? "unknown",
+    date: formatDate(e.date),
+    size: formatSize(e.size),
+  }));
+
+  const allRows = [header, ...rows];
+  const colWidths = {
+    file: Math.max(...allRows.map((r) => r.file.length)),
+    type: Math.max(...allRows.map((r) => r.type.length)),
+    date: Math.max(...allRows.map((r) => r.date.length)),
+    size: Math.max(...allRows.map((r) => r.size.length)),
+  };
+
+  const lines: string[] = [];
+  for (const row of allRows) {
+    const line = [
+      row.file.padEnd(colWidths.file),
+      row.type.padEnd(colWidths.type),
+      row.date.padEnd(colWidths.date),
+      row.size.padStart(colWidths.size),
+    ].join("  ");
+    lines.push(line);
+  }
+
+  return lines.join("\n");
+}
+
+const VALID_TYPES = new Set<string>([
+  JOURNAL_TYPES.DAILY_NOTES,
+  JOURNAL_TYPES.MEETING,
+  JOURNAL_TYPES.NOTE,
+]);
+
+export default defineCommand({
+  meta: {
+    name: "list",
+    description: "List recent journal entries",
+  },
+  args: {
+    debug: debugArg,
+    type: {
+      type: "string",
+      alias: "t",
+      description: "Filter by entry type: daily-notes, meeting, note",
+    },
+    limit: {
+      type: "string",
+      alias: "l",
+      description: "Maximum number of entries to show (default: 20)",
+    },
+    sort: {
+      type: "string",
+      alias: "s",
+      description: "Sort by: date, name (default: date)",
+    },
+  },
+  async run({ args }) {
+    const { settings } = await withSettings(args.debug);
+
+    try {
+      const baseFolder = settings.journalSettings.baseFolder;
+      const journalDir = path.join(baseFolder, "journal");
+
+      // Validate --type
+      let typeFilter: JournalType | undefined;
+      if (args.type) {
+        if (!VALID_TYPES.has(args.type)) {
+          consola.error(
+            `Invalid type "${args.type}". Must be one of: ${[...VALID_TYPES].join(", ")}`,
+          );
+          process.exit(1);
+        }
+        typeFilter = args.type as JournalType;
+      }
+
+      // Parse --limit
+      const limit = args.limit ? Number.parseInt(args.limit, 10) : 20;
+      if (Number.isNaN(limit) || limit < 1) {
+        consola.error(`Invalid limit "${args.limit}". Must be a positive integer.`);
+        process.exit(1);
+      }
+
+      // Validate --sort
+      const sort = (args.sort ?? "date") as "date" | "name";
+      if (sort !== "date" && sort !== "name") {
+        consola.error(`Invalid sort "${args.sort}". Must be one of: date, name`);
+        process.exit(1);
+      }
+
+      const files = collectMarkdownFiles(journalDir);
+      if (files.length === 0) {
+        consola.info(`No journal files found in ${colors.cyan(journalDir)}`);
+        return;
+      }
+
+      const entries = collectJournalEntries(files, baseFolder);
+      const result = filterAndSortEntries(entries, { type: typeFilter, limit, sort });
+
+      if (result.length === 0) {
+        consola.info("No matching journal entries found.");
+        return;
+      }
+
+      consola.info(`Showing ${colors.green(String(result.length))} journal entries:\n`);
+      console.log(renderTable(result));
+    } catch (error) {
+      consola.error("Failed to list journal entries:", error);
+      process.exit(1);
+    }
+  },
+});

package/src/commands/journal/meeting.ts

@@ -6,13 +6,10 @@ import consola from "consola";
 import { colors } from "consola/utils";
 import { withSettings, debugArg } from "../shared.js";
 import { JOURNAL_TYPES } from "../../types/journal.js";
-import {
-  createMeetingContent,
-  ensureDirectoryExists,
-  ensureTemplatesExist,
-  generateJournalFileInfoByType,
-  openInEditor,
-} from "../../lib/journal/index.js";
+import { ensureDirectoryExists } from "./fs.js";
+import { openInEditor } from "./editor.js";
+import { createMeetingContent, ensureTemplatesExist } from "./templates.js";
+import { generateJournalFileInfoByType } from "./paths.js";
 
 export default defineCommand({
   meta: { name: "meeting", description: "Structured meeting notes with agenda and action items" },

package/src/commands/journal/note.ts

@@ -6,13 +6,10 @@ import consola from "consola";
 import { colors } from "consola/utils";
 import { withSettings, debugArg } from "../shared.js";
 import { JOURNAL_TYPES } from "../../types/journal.js";
-import {
-  createNoteContent,
-  ensureDirectoryExists,
-  ensureTemplatesExist,
-  generateJournalFileInfoByType,
-  openInEditor,
-} from "../../lib/journal/index.js";
+import { ensureDirectoryExists } from "./fs.js";
+import { openInEditor } from "./editor.js";
+import { createNoteContent, ensureTemplatesExist } from "./templates.js";
+import { generateJournalFileInfoByType } from "./paths.js";
 
 export default defineCommand({
   meta: { name: "note", description: "General-purpose notes with structured sections" },

package/src/{lib → commands}/journal/paths.ts

@@ -1,7 +1,7 @@
 import path from "node:path";
 import consola from "consola";
 import { DateTime } from "luxon";
-import { getMondayOfWeek } from "../../utils/date-utils.js";
+import { getMondayOfWeek } from "@towles/shared";
 import type { JournalSettings } from "../../config/settings.js";
 import { JOURNAL_TYPES } from "../../types/journal.js";
 import type { JournalType } from "../../types/journal.js";

package/src/commands/journal/search.test.ts

@@ -0,0 +1,156 @@
+import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import {
+  collectMarkdownFiles,
+  inferTypeFromPath,
+  extractDateFromFilename,
+  searchJournalFiles,
+  parseDateRange,
+} from "./search.js";
+import { JOURNAL_TYPES } from "../../types/journal.js";
+
+describe("journal search", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = path.join(tmpdir(), `journal-search-test-${Date.now()}`);
+    mkdirSync(tmpDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  describe("collectMarkdownFiles", () => {
+    it("collects .md files recursively", () => {
+      mkdirSync(path.join(tmpDir, "sub"), { recursive: true });
+      writeFileSync(path.join(tmpDir, "a.md"), "hello");
+      writeFileSync(path.join(tmpDir, "b.txt"), "ignored");
+      writeFileSync(path.join(tmpDir, "sub", "c.md"), "nested");
+
+      const files = collectMarkdownFiles(tmpDir);
+      expect(files).toHaveLength(2);
+      expect(files.some((f) => f.endsWith("a.md"))).toBe(true);
+      expect(files.some((f) => f.endsWith("c.md"))).toBe(true);
+    });
+
+    it("returns empty for nonexistent directory", () => {
+      expect(collectMarkdownFiles("/nonexistent-dir-12345")).toEqual([]);
+    });
+  });
+
+  describe("inferTypeFromPath", () => {
+    it("detects daily-notes", () => {
+      expect(inferTypeFromPath("/journal/2026/01/daily-notes/file.md")).toBe(
+        JOURNAL_TYPES.DAILY_NOTES,
+      );
+    });
+
+    it("detects meeting", () => {
+      expect(inferTypeFromPath("/journal/2026/01/meetings/standup.md")).toBe(JOURNAL_TYPES.MEETING);
+    });
+
+    it("detects note", () => {
+      expect(inferTypeFromPath("/journal/2026/01/notes/idea.md")).toBe(JOURNAL_TYPES.NOTE);
+    });
+
+    it("returns null for unknown", () => {
+      expect(inferTypeFromPath("/journal/2026/01/other/file.md")).toBeNull();
+    });
+  });
+
+  describe("extractDateFromFilename", () => {
+    it("extracts date from standard filename", () => {
+      const date = extractDateFromFilename("/path/2026-03-15-standup.md");
+      expect(date).not.toBeNull();
+      expect(date!.getFullYear()).toBe(2026);
+      expect(date!.getMonth()).toBe(2); // 0-indexed
+      expect(date!.getDate()).toBe(15);
+    });
+
+    it("returns null when no date pattern", () => {
+      expect(extractDateFromFilename("/path/readme.md")).toBeNull();
+    });
+  });
+
+  describe("searchJournalFiles", () => {
+    it("finds matching lines with context", () => {
+      const file = path.join(tmpDir, "2026-01-10-test.md");
+      writeFileSync(file, "line one\nline two\nfind me here\nline four\nline five");
+
+      const matches = searchJournalFiles([file], { query: "find me" });
+      expect(matches).toHaveLength(1);
+      expect(matches[0].lineNumber).toBe(3);
+      expect(matches[0].line).toBe("find me here");
+      expect(matches[0].context).toHaveLength(5); // 2 before + match + 2 after
+    });
+
+    it("is case-insensitive", () => {
+      const file = path.join(tmpDir, "2026-01-10-test.md");
+      writeFileSync(file, "Hello World\nfoo bar");
+
+      const matches = searchJournalFiles([file], { query: "hello" });
+      expect(matches).toHaveLength(1);
+    });
+
+    it("filters by type", () => {
+      const dailyDir = path.join(tmpDir, "daily-notes");
+      const notesDir = path.join(tmpDir, "notes");
+      mkdirSync(dailyDir, { recursive: true });
+      mkdirSync(notesDir, { recursive: true });
+
+      const dailyFile = path.join(dailyDir, "2026-01-10-daily.md");
+      const noteFile = path.join(notesDir, "2026-01-10-idea.md");
+      writeFileSync(dailyFile, "keyword here");
+      writeFileSync(noteFile, "keyword here too");
+
+      const matches = searchJournalFiles([dailyFile, noteFile], {
+        query: "keyword",
+        type: JOURNAL_TYPES.DAILY_NOTES,
+      });
+      expect(matches).toHaveLength(1);
+      expect(matches[0].filePath).toBe(dailyFile);
+    });
+
+    it("filters by date range", () => {
+      const oldFile = path.join(tmpDir, "2025-06-01-old.md");
+      const newFile = path.join(tmpDir, "2026-02-15-new.md");
+      writeFileSync(oldFile, "keyword");
+      writeFileSync(newFile, "keyword");
+
+      const matches = searchJournalFiles([oldFile, newFile], {
+        query: "keyword",
+        startDate: new Date(2026, 0, 1),
+        endDate: new Date(2026, 11, 31),
+      });
+      expect(matches).toHaveLength(1);
+      expect(matches[0].filePath).toBe(newFile);
+    });
+
+    it("returns empty when no matches", () => {
+      const file = path.join(tmpDir, "2026-01-10-test.md");
+      writeFileSync(file, "nothing relevant");
+
+      const matches = searchJournalFiles([file], { query: "xyznotfound" });
+      expect(matches).toHaveLength(0);
+    });
+  });
+
+  describe("parseDateRange", () => {
+    it("parses valid range", () => {
+      const { startDate, endDate } = parseDateRange("2026-01-01..2026-03-01");
+      expect(startDate.getFullYear()).toBe(2026);
+      expect(endDate.getMonth()).toBe(2); // March = 2 (0-indexed)
+    });
+
+    it("throws on invalid format", () => {
+      expect(() => parseDateRange("invalid")).toThrow("Invalid date range format");
+    });
+
+    it("throws TypeError on invalid dates", () => {
+      expect(() => parseDateRange("notadate..alsonot")).toThrow(TypeError);
+    });
+  });
+});