@towles/tool 0.0.18 → 0.0.41

package/src/commands/journal/utils.ts

@@ -0,0 +1,399 @@
+import { exec } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+import consola from "consola";
+import { colors } from "consola/utils";
+import { DateTime } from "luxon";
+import { formatDate, getMondayOfWeek, getWeekInfo } from "../../utils/date-utils.js";
+import type { JournalSettings } from "../../config/settings.js";
+import { JOURNAL_TYPES } from "../../types/journal.js";
+import type { JournalType } from "../../types/journal.js";
+
+// Default template file names
+const TEMPLATE_FILES = {
+  dailyNotes: "daily-notes.md",
+  meeting: "meeting.md",
+  note: "note.md",
+} as const;
+
+const execAsync = promisify(exec);
+
+/**
+ * Create journal directory if it doesn't exist
+ */
+export function ensureDirectoryExists(folderPath: string): void {
+  if (!existsSync(folderPath)) {
+    consola.info(`Creating journal directory: ${colors.cyan(folderPath)}`);
+    mkdirSync(folderPath, { recursive: true });
+  }
+}
+
+/**
+ * Load template from external file or return null if not found
+ */
+export function loadTemplate(templateDir: string, templateFile: string): string | null {
+  const templatePath = path.join(templateDir, templateFile);
+  if (existsSync(templatePath)) {
+    return readFileSync(templatePath, "utf8");
+  }
+  return null;
+}
+
+/**
+ * Get default template content for initial setup
+ */
+function getDefaultDailyNotesTemplate(): string {
+  return `# Journal for Week {monday:yyyy-MM-dd}
+
+## {monday:yyyy-MM-dd} Monday
+
+## {tuesday:yyyy-MM-dd} Tuesday
+
+## {wednesday:yyyy-MM-dd} Wednesday
+
+## {thursday:yyyy-MM-dd} Thursday
+
+## {friday:yyyy-MM-dd} Friday
+`;
+}
+
+function getDefaultMeetingTemplate(): string {
+  return `# Meeting: {title}
+
+**Date:** {date}
+**Time:** {time}
+**Attendees:**
+
+## Agenda
+
+-
+
+## Notes
+
+## Action Items
+
+- [ ]
+
+## Follow-up
+`;
+}
+
+function getDefaultNoteTemplate(): string {
+  return `# {title}
+
+**Created:** {date} {time}
+
+## Summary
+
+## Details
+
+## References
+`;
+}
+
+/**
+ * Initialize template directory with default templates (first run)
+ */
+export function ensureTemplatesExist(templateDir: string): void {
+  ensureDirectoryExists(templateDir);
+
+  const templates = [
+    { file: TEMPLATE_FILES.dailyNotes, content: getDefaultDailyNotesTemplate() },
+    { file: TEMPLATE_FILES.meeting, content: getDefaultMeetingTemplate() },
+    { file: TEMPLATE_FILES.note, content: getDefaultNoteTemplate() },
+  ];
+
+  for (const { file, content } of templates) {
+    const templatePath = path.join(templateDir, file);
+    if (!existsSync(templatePath)) {
+      writeFileSync(templatePath, content, "utf8");
+      consola.info(`Created default template: ${colors.cyan(templatePath)}`);
+    }
+  }
+}
+
+/**
+ * Render template with variables
+ */
+function renderTemplate(template: string, vars: Record<string, string>): string {
+  return template.replace(/\{([^}]+)\}/g, (match, key) => {
+    return vars[key] ?? match;
+  });
+}
+
+/**
+ * Create initial journal content with date header
+ */
+export function createJournalContent({
+  mondayDate,
+  templateDir,
+}: {
+  mondayDate: Date;
+  templateDir?: string;
+}): string {
+  const weekInfo = getWeekInfo(mondayDate);
+
+  // Try external template first
+  if (templateDir) {
+    const externalTemplate = loadTemplate(templateDir, TEMPLATE_FILES.dailyNotes);
+    if (externalTemplate) {
+      return renderTemplate(externalTemplate, {
+        "monday:yyyy-MM-dd": formatDate(weekInfo.mondayDate),
+        "tuesday:yyyy-MM-dd": formatDate(weekInfo.tuesdayDate),
+        "wednesday:yyyy-MM-dd": formatDate(weekInfo.wednesdayDate),
+        "thursday:yyyy-MM-dd": formatDate(weekInfo.thursdayDate),
+        "friday:yyyy-MM-dd": formatDate(weekInfo.fridayDate),
+      });
+    }
+  }
+
+  // Fallback to hardcoded template
+  const content = [`# Journal for Week ${formatDate(mondayDate)}`];
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.mondayDate)} Monday`);
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.tuesdayDate)} Tuesday`);
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.wednesdayDate)} Wednesday`);
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.thursdayDate)} Thursday`);
+  content.push(``);
+  content.push(`## ${formatDate(weekInfo.fridayDate)} Friday`);
+  content.push(``);
+
+  return content.join("\n");
+}
+
+/**
+ * Create meeting template content
+ */
+export function createMeetingContent({
+  title,
+  date,
+  templateDir,
+}: {
+  title?: string;
+  date: Date;
+  templateDir?: string;
+}): string {
+  const dateStr = formatDate(date);
+  const timeStr = date.toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+  const meetingTitle = title || "Meeting";
+
+  // Try external template first
+  if (templateDir) {
+    const externalTemplate = loadTemplate(templateDir, TEMPLATE_FILES.meeting);
+    if (externalTemplate) {
+      return renderTemplate(externalTemplate, {
+        title: meetingTitle,
+        date: dateStr,
+        time: timeStr,
+      });
+    }
+  }
+
+  // Fallback to hardcoded template
+  const content = [`# Meeting: ${meetingTitle}`];
+  content.push(``);
+  content.push(`**Date:** ${dateStr}`);
+  content.push(`**Time:** ${timeStr}`);
+  content.push(`**Attendees:** `);
+  content.push(``);
+  content.push(`## Agenda`);
+  content.push(``);
+  content.push(`- `);
+  content.push(``);
+  content.push(`## Notes`);
+  content.push(``);
+  content.push(`## Action Items`);
+  content.push(``);
+  content.push(`- [ ] `);
+  content.push(``);
+  content.push(`## Follow-up`);
+  content.push(``);
+
+  return content.join("\n");
+}
+
+/**
+ * Create note template content
+ */
+export function createNoteContent({
+  title,
+  date,
+  templateDir,
+}: {
+  title?: string;
+  date: Date;
+  templateDir?: string;
+}): string {
+  const dateStr = formatDate(date);
+  const timeStr = date.toLocaleTimeString("en-US", {
+    hour12: false,
+    hour: "2-digit",
+    minute: "2-digit",
+  });
+  const noteTitle = title || "Note";
+
+  // Try external template first
+  if (templateDir) {
+    const externalTemplate = loadTemplate(templateDir, TEMPLATE_FILES.note);
+    if (externalTemplate) {
+      return renderTemplate(externalTemplate, {
+        title: noteTitle,
+        date: dateStr,
+        time: timeStr,
+      });
+    }
+  }
+
+  // Fallback to hardcoded template
+  const content = [`# ${noteTitle}`];
+  content.push(``);
+  content.push(`**Created:** ${dateStr} ${timeStr}`);
+  content.push(``);
+  content.push(`## Summary`);
+  content.push(``);
+  content.push(`## Details`);
+  content.push(``);
+  content.push(`## References`);
+  content.push(``);
+
+  return content.join("\n");
+}
+
+/**
+ * Open file in default editor with folder context
+ */
+export async function openInEditor({
+  editor,
+  filePath,
+  folderPath,
+}: {
+  editor: string;
+  filePath: string;
+  folderPath?: string;
+}): Promise<void> {
+  try {
+    if (folderPath) {
+      // Open both folder and file - this works with VS Code and similar editors
+      // the purpose is to open the folder context for better navigation
+      await execAsync(`"${editor}" "${folderPath}" "${filePath}"`);
+    } else {
+      await execAsync(`"${editor}" "${filePath}"`);
+    }
+  } catch (ex) {
+    consola.warn(
+      `Could not open in editor : '${editor}'. Modify your editor in the config: examples include 'code', 'code-insiders',  etc...`,
+      ex,
+    );
+  }
+}
+
+export function resolvePathTemplate(
+  template: string,
+  title: string,
+  date: Date,
+  mondayDate: Date,
+): string {
+  const dateTime = DateTime.fromJSDate(date, { zone: "utc" });
+
+  // Replace Luxon format tokens wrapped in curly braces
+  return template.replace(/\{([^}]+)\}/g, (match, token) => {
+    try {
+      if (token === "title") {
+        return title.toLowerCase().replace(/\s+/g, "-");
+      }
+
+      if (token.startsWith("monday:")) {
+        const mondayToken = token.substring(7); // Remove 'monday:' prefix
+        const mondayDateTime = DateTime.fromJSDate(mondayDate, { zone: "utc" });
+        return mondayDateTime.toFormat(mondayToken);
+      }
+
+      const result = dateTime.toFormat(token);
+      // Check if the result contains suspicious patterns that indicate invalid tokens
+      // This is a heuristic to detect when Luxon produces garbage output for invalid tokens
+      const isLikelyInvalid =
+        token.includes("invalid") ||
+        result.length > 20 || // Very long results are likely garbage
+        (result.length > token.length * 2 && /\d{10,}/.test(result)) || // Contains very long numbers
+        result.includes("UTC");
+
+      if (isLikelyInvalid) {
+        consola.warn(`Invalid date format token: ${token}`);
+        return match;
+      }
+      return result;
+    } catch (error) {
+      consola.warn(`Invalid date format token: ${token}`);
+      return match; // Return original token if format is invalid
+    }
+  });
+}
+
+interface GenerateJournalFileResult {
+  fullPath: string;
+  mondayDate: Date;
+  currentDate: Date;
+}
+
+interface GenerateJournalFileParams {
+  date: Date;
+  type: JournalType;
+  title: string;
+  journalSettings: JournalSettings;
+}
+
+/**
+ * Generate journal file info for different types using individual path templates
+ */
+export function generateJournalFileInfoByType({
+  journalSettings,
+  date = new Date(),
+  type,
+  title,
+}: GenerateJournalFileParams): GenerateJournalFileResult {
+  const currentDate = new Date(date);
+
+  let templatePath: string = "";
+  let mondayDate: Date = getMondayOfWeek(currentDate);
+
+  switch (type) {
+    case JOURNAL_TYPES.DAILY_NOTES: {
+      const monday = getMondayOfWeek(currentDate);
+      templatePath = journalSettings.dailyPathTemplate;
+      mondayDate = monday;
+      break;
+    }
+    case JOURNAL_TYPES.MEETING: {
+      templatePath = journalSettings.meetingPathTemplate;
+      mondayDate = currentDate;
+      break;
+    }
+    case JOURNAL_TYPES.NOTE: {
+      templatePath = journalSettings.notePathTemplate;
+      mondayDate = currentDate;
+      break;
+    }
+    default:
+      throw new Error(`Unknown JournalType: ${type}`);
+  }
+
+  // Resolve the path template and extract directory structure
+  const resolvedPath = resolvePathTemplate(templatePath, title, currentDate, mondayDate);
+
+  // Join baseFolder with the resolved path
+  const fullPath = path.join(journalSettings.baseFolder, resolvedPath);
+
+  return {
+    currentDate: currentDate,
+    fullPath: fullPath,
+    mondayDate,
+  } satisfies GenerateJournalFileResult;
+}

package/src/commands/observe/graph.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Tests for observe graph command --days filtering
+ */
+import { describe, it, expect } from "vitest";
+import { calculateCutoffMs, filterByDays } from "./graph.js";
+
+describe("observe graph --days filtering", () => {
+  describe("calculateCutoffMs", () => {
+    it("returns 0 when days <= 0", () => {
+      expect(calculateCutoffMs(0)).toBe(0);
+      expect(calculateCutoffMs(-1)).toBe(0);
+    });
+
+    it("returns cutoff timestamp for positive days", () => {
+      const now = Date.now();
+      const cutoff = calculateCutoffMs(7);
+      // Should be roughly 7 days ago (within 100ms tolerance for test execution time)
+      const expected = now - 7 * 24 * 60 * 60 * 1000;
+      expect(Math.abs(cutoff - expected)).toBeLessThan(100);
+    });
+  });
+
+  describe("filterByDays", () => {
+    it("filters sessions older than N days when days > 0", () => {
+      const now = Date.now();
+      const sessions = [
+        { mtime: now - 1 * 24 * 60 * 60 * 1000 }, // 1 day ago - included
+        { mtime: now - 2 * 24 * 60 * 60 * 1000 }, // 2 days ago - included
+        { mtime: now - 5 * 24 * 60 * 60 * 1000 }, // 5 days ago - excluded
+        { mtime: now - 10 * 24 * 60 * 60 * 1000 }, // 10 days ago - excluded
+      ];
+
+      const filtered = filterByDays(sessions, 3);
+      expect(filtered).toHaveLength(2);
+    });
+
+    it("returns all sessions when days=0", () => {
+      const now = Date.now();
+      const sessions = [
+        { mtime: now - 1 * 24 * 60 * 60 * 1000 },
+        { mtime: now - 100 * 24 * 60 * 60 * 1000 },
+        { mtime: now - 365 * 24 * 60 * 60 * 1000 },
+      ];
+
+      const filtered = filterByDays(sessions, 0);
+      expect(filtered).toHaveLength(3);
+    });
+
+    it("default 7 days filters correctly", () => {
+      const now = Date.now();
+      const sessions = [
+        { mtime: now - 1 * 24 * 60 * 60 * 1000 }, // 1 day ago - included
+        { mtime: now - 6 * 24 * 60 * 60 * 1000 }, // 6 days ago - included
+        { mtime: now - 8 * 24 * 60 * 60 * 1000 }, // 8 days ago - excluded
+        { mtime: now - 30 * 24 * 60 * 60 * 1000 }, // 30 days ago - excluded
+      ];
+
+      const filtered = filterByDays(sessions, 7);
+      expect(filtered).toHaveLength(2);
+      // Verify the right sessions were kept
+      expect(filtered[0].mtime).toBeGreaterThan(now - 7 * 24 * 60 * 60 * 1000);
+      expect(filtered[1].mtime).toBeGreaterThan(now - 7 * 24 * 60 * 60 * 1000);
+    });
+
+    it("--days 1 filters to today only", () => {
+      const now = Date.now();
+      const sessions = [
+        { mtime: now - 12 * 60 * 60 * 1000 }, // 12 hours ago - included
+        { mtime: now - 25 * 60 * 60 * 1000 }, // 25 hours ago - excluded
+      ];
+
+      const filtered = filterByDays(sessions, 1);
+      expect(filtered).toHaveLength(1);
+    });
+
+    it("preserves additional properties on items", () => {
+      const now = Date.now();
+      const sessions = [
+        { mtime: now, sessionId: "abc", tokens: 100 },
+        { mtime: now - 10 * 24 * 60 * 60 * 1000, sessionId: "old", tokens: 50 },
+      ];
+
+      const filtered = filterByDays(sessions, 7);
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0].sessionId).toBe("abc");
+      expect(filtered[0].tokens).toBe(100);
+    });
+  });
+});