@forwardimpact/basecamp 1.0.0 → 2.2.0

package/template/.claude/skills/organize-files/scripts/summarize.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Summarize the contents of ~/Desktop/ and ~/Downloads/.
+ *
+ * Counts top-level files in both directories by type (Screenshots, PDFs,
+ * Images, Documents, Archives, Installers, Other) and prints a human-readable
+ * table for each. Used by the organize-files skill to preview directory
+ * contents before organizing.
+ */
+
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { extname, join } from "node:path";
+import { homedir } from "node:os";
+
+const HELP = `summarize — count files by type in ~/Desktop/ and ~/Downloads/
+
+Usage: node scripts/summarize.mjs [-h|--help]
+
+Prints a summary of file types found at the top level of each directory.`;
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  console.log(HELP);
+  process.exit(0);
+}
+
+const HOME = homedir();
+
+function countFiles(dir) {
+  if (!existsSync(dir)) return null;
+
+  const counts = {
+    Screenshots: 0,
+    PDFs: 0,
+    Images: 0,
+    Documents: 0,
+    Archives: 0,
+    Installers: 0,
+    Other: 0,
+  };
+
+  for (const name of readdirSync(dir)) {
+    const fullPath = join(dir, name);
+    const stat = statSync(fullPath, { throwIfNoEntry: false });
+    if (!stat || !stat.isFile()) continue;
+    if (name.startsWith(".")) continue;
+
+    const ext = extname(name).toLowerCase();
+    if (name.startsWith("Screenshot") || name.startsWith("Screen Shot")) {
+      counts.Screenshots++;
+    } else if (ext === ".pdf") {
+      counts.PDFs++;
+    } else if ([".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(ext)) {
+      counts.Images++;
+    } else if (
+      [".doc", ".docx", ".txt", ".md", ".rtf", ".csv", ".xlsx"].includes(ext)
+    ) {
+      counts.Documents++;
+    } else if ([".zip", ".rar"].includes(ext) || name.endsWith(".tar.gz")) {
+      counts.Archives++;
+    } else if (ext === ".dmg") {
+      counts.Installers++;
+    } else {
+      counts.Other++;
+    }
+  }
+
+  return counts;
+}
+
+function main() {
+  for (const dirName of ["Desktop", "Downloads"]) {
+    const dir = join(HOME, dirName);
+    const counts = countFiles(dir);
+    if (!counts) continue;
+
+    console.log(`=== ${dirName} ===`);
+    for (const [label, count] of Object.entries(counts)) {
+      console.log(`${label.padEnd(12)} ${count}`);
+    }
+    console.log("");
+  }
+}
+
+main();

package/template/.claude/skills/process-hyprnote/SKILL.md

@@ -308,11 +308,11 @@ absolute paths: `[[People/Name]]`, `[[Organizations/Name]]`,
 After processing each session, mark its files as processed:
 
 ```bash
-python3 .claude/skills/extract-entities/scripts/state.py update \
+node .claude/skills/extract-entities/scripts/state.mjs update \
   "$HOME/Library/Application Support/hyprnote/sessions/{uuid}/_memo.md"
 
 # Also mark _summary.md if it exists
-python3 .claude/skills/extract-entities/scripts/state.py update \
+node .claude/skills/extract-entities/scripts/state.mjs update \
   "$HOME/Library/Application Support/hyprnote/sessions/{uuid}/_summary.md"
 ```
 

package/template/.claude/skills/send-chat/SKILL.md

@@ -0,0 +1,170 @@
+---
+name: send-chat
+description: Send messages to people via chat platforms (e.g. Microsoft Teams, Slack) using browser automation. Resolves people by name using the knowledge graph, drafts messages for approval, and sends via the web app. Use when the user asks to message, ping, or chat with someone.
+compatibility:
+  requires:
+    - browser-automation
+---
+
+# Send Chat
+
+Send chat messages to people using browser automation against a web-based chat
+platform (Microsoft Teams, Slack, or similar). Resolves recipients by name from
+the knowledge graph so the user can say "message Sarah about the standup"
+without needing exact display names.
+
+## Trigger
+
+Run when the user asks to:
+
+- Send a message on Teams / Slack / chat
+- Ping / chat / DM someone
+- Follow up with someone via chat
+- Send a message about a topic
+
+## Prerequisites
+
+- Chat platform web app open and authenticated in the browser
+- Browser automation available (e.g. Chrome MCP, Playwright)
+- Knowledge base populated with people notes
+
+## Critical: Always Look Up Context First
+
+**BEFORE messaging anyone, you MUST look up the person in the knowledge base.**
+
+When the user mentions ANY person:
+
+1. **STOP** — Do not open the chat platform yet
+2. **SEARCH** — Look them up: `rg -l "{name}" knowledge/People/`
+3. **READ** — Read their note to understand context, role, recent interactions
+4. **UNDERSTAND** — Know who they are, what you've been working on together
+5. **THEN PROCEED** — Only now compose the message and use browser automation
+
+This context is essential for:
+
+- Finding the right person if the name is ambiguous
+- Drafting an appropriate message if the user gave a loose prompt
+- Knowing the person's role and relationship for tone
+
+## Resolving People
+
+The user will refer to people by first name, last name, or nickname. Resolve to
+a full name using the knowledge graph:
+
+```bash
+# Find person by partial name
+rg -l -i "{name}" knowledge/People/
+
+# If ambiguous, read candidates to disambiguate
+cat "knowledge/People/{Candidate}.md"
+```
+
+**If ambiguous** (multiple matches), ask the user which person they mean — list
+the matches with roles/orgs to help them pick.
+
+**If no match**, tell the user you don't have this person in the knowledge base
+and ask for their full name as it appears in the chat platform.
+
+## Composing the Message
+
+**Every message MUST be drafted as a text file first.** This ensures the user
+can review and edit the exact message before it's sent.
+
+### Draft Workflow
+
+1. **Compose the message** based on context and user intent.
+2. **Write it to a draft file** at `drafts/chat-{recipient-slug}-{date}.md`
+   - `{recipient-slug}` = lowercase, hyphenated full name (e.g. `sarah-chen`)
+   - `{date}` = ISO date (e.g. `2026-02-19`)
+3. **Show the user the draft** — display the file path and contents.
+4. **Wait for approval** — the user may edit the file or ask for changes.
+5. **Only after approval**, proceed to send.
+
+**Draft file format:**
+
+```markdown
+To: {Full Name}
+Via: {Platform name}
+Date: {YYYY-MM-DD}
+
+---
+
+{message body}
+```
+
+The message body (everything below the `---` separator) is what gets pasted into
+the chat.
+
+**Message guidelines:**
+
+- Match the user's usual tone — casual for peers, professional for leadership
+- Keep it concise — chat is informal, not email
+- Reference specific context naturally (project names, recent decisions)
+- If the user provides exact wording, use it verbatim
+- If the user said "ping {name}" without detail, ask what they want to say
+- Draft one message based on context — don't offer multiple options
+- **Keep messages on a single line with no formatting.** No line breaks, no
+  markdown. Use inline separators (e.g. `•`, `—`) to keep structure. Multi-line
+  formatting is unreliable via browser automation.
+
+## Browser Automation Flow
+
+Once the user has approved the draft, send it as a **single submission** — paste
+the entire message at once rather than typing line by line.
+
+### Step 1: Identify the Chat Platform
+
+Check which platform is available:
+
+- Look for an open tab matching the configured chat URL
+- If no tab is open, ask the user which platform to use and navigate to it
+
+### Step 2: Open a Chat with the Recipient
+
+1. Use the platform's search or "New chat" feature
+2. Type the recipient's full name
+3. Wait for search results to populate (take a screenshot to verify)
+4. Click the correct person from the results
+
+If the person doesn't appear in search, inform the user — they may not be in the
+same organization.
+
+### Step 3: Send the Approved Message
+
+1. Read the approved draft file to get the message body (below the `---`)
+2. Click the message compose box
+3. Paste the entire message as a single submission
+4. Press Enter or click Send
+5. Take a screenshot to confirm the message was sent
+
+### Step 4: Update Knowledge Graph (Optional)
+
+If the message is substantive (not just "hey" or "thanks"), note the interaction
+on the person's knowledge note:
+
+```markdown
+- {YYYY-MM-DD}: Messaged on {Platform} re: {topic}
+```
+
+## Error Handling
+
+- **Platform not loaded / auth required:** Tell the user to sign in first, then
+  retry
+- **Person not found in search:** Report back — they may be external or using a
+  different display name. Ask the user for the exact name
+- **Chat already open:** If a chat with this person is already visible, use it
+  directly
+- **UI not as expected:** Take a screenshot and describe what you see. Don't
+  click blindly
+
+## Constraints
+
+- **Always confirm before sending.** Never send a message without explicit user
+  approval — this is a hard requirement
+- **One message at a time.** Don't batch-send to multiple people without
+  confirming each one
+- **No file attachments.** This skill handles text messages only
+- **No group chats.** Targets 1:1 chats only
+- **No message deletion or editing.** Once sent, it's sent
+- **Respect ethics rules.** Never send messages that contain personal judgments,
+  gossip, or sensitive information per the knowledge base ethics policy

package/template/.claude/skills/sync-apple-calendar/SKILL.md

@@ -37,10 +37,11 @@ their calendar.
 
 ## Implementation
 
-Run the sync as a single Python script. This avoids N+1 sqlite3 invocations (one
-per event for attendees) and handles all data transformation in one pass:
+Run the sync as a single Node.js script with embedded SQLite. This avoids N+1
+process invocations (one per event for attendees) and handles all data
+transformation in one pass:
 
-    python3 scripts/sync.py [--days N]
+    node scripts/sync.mjs [--days N]
 
 - `--days N` — how many days back to sync (default: 30)
 
@@ -97,8 +98,7 @@ Each `{event_id}.json` file:
 
 ## Constraints
 
-- Open database read-only (`-readonly`)
+- Open database read-only (`readOnly: true`)
 - This sync is stateless — always queries the current sliding window
 - All-day events may have null end times — use start date as end date
 - All-day events have timezone `_float` — omit timezone from output
-- Output format matches Google Calendar event format for downstream consistency

package/template/.claude/skills/sync-apple-calendar/scripts/sync.mjs

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+/**
+ * Sync Apple Calendar events to ~/.cache/fit/basecamp/apple_calendar/ as JSON.
+ *
+ * Queries the macOS Calendar SQLite database (via node:sqlite) for events in a
+ * sliding window — N days in the past through 14 days in the future. Writes one
+ * JSON file per event and removes files for events that fall outside the window.
+ * Attendee details (name, email, status, role) are batch-fetched and included.
+ *
+ * Requires macOS with Calendar app configured and Full Disk Access granted.
+ */
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  console.log(`sync-apple-calendar — sync calendar events to JSON
+
+Usage: node scripts/sync.mjs [--days N] [-h|--help]
+
+Options:
+  --days N     Days back to sync (default: 30)
+  -h, --help   Show this help message and exit
+
+Requires macOS with Calendar configured and Full Disk Access granted.`);
+  process.exit(0);
+}
+
+import { DatabaseSync } from "node:sqlite";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const HOME = homedir();
+const OUTDIR = join(HOME, ".cache/fit/basecamp/apple_calendar");
+
+/** Core Data epoch: 2001-01-01T00:00:00Z */
+const EPOCH_MS = Date.UTC(2001, 0, 1);
+
+const DB_PATHS = [
+  join(
+    HOME,
+    "Library/Group Containers/group.com.apple.calendar/Calendar.sqlitedb",
+  ),
+  join(HOME, "Library/Calendars/Calendar.sqlitedb"),
+];
+
+const STATUS_MAP = {
+  0: "unknown",
+  1: "pending",
+  2: "accepted",
+  3: "declined",
+  4: "tentative",
+  5: "delegated",
+  6: "completed",
+  7: "in-process",
+};
+
+const ROLE_MAP = {
+  0: "unknown",
+  1: "required",
+  2: "optional",
+  3: "chair",
+};
+
+/**
+ * Find the Apple Calendar database.
+ * @returns {string}
+ */
+function findDb() {
+  const db = DB_PATHS.find((p) => existsSync(p));
+  if (!db) {
+    console.error(
+      "Error: Apple Calendar database not found. Is Calendar configured?",
+    );
+    process.exit(1);
+  }
+  return db;
+}
+
+/**
+ * Open the database in read-only mode with retry on lock.
+ * @param {string} dbPath
+ * @returns {import("node:sqlite").DatabaseSync}
+ */
+function openDb(dbPath) {
+  try {
+    return new DatabaseSync(dbPath, { readOnly: true });
+  } catch (err) {
+    if (err.message.includes("locked")) {
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 2000);
+      return new DatabaseSync(dbPath, { readOnly: true });
+    }
+    throw err;
+  }
+}
+
+/**
+ * Execute a read-only query and return results.
+ * @param {import("node:sqlite").DatabaseSync} db
+ * @param {string} sql
+ * @returns {Array<Record<string, any>>}
+ */
+function query(db, sql) {
+  try {
+    return db.prepare(sql).all();
+  } catch (err) {
+    console.error(`SQLite error: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Convert Core Data timestamp to ISO 8601.
+ * @param {number | null} ts - Seconds since 2001-01-01
+ * @param {string | null} tzName
+ * @returns {string | null}
+ */
+function coredataToIso(ts, tzName) {
+  if (ts == null) return null;
+  const ms = EPOCH_MS + ts * 1000;
+  const dt = new Date(ms);
+
+  if (tzName && tzName !== "_float") {
+    try {
+      return (
+        dt.toLocaleString("sv-SE", { timeZone: tzName }).replace(" ", "T") +
+        getUtcOffset(dt, tzName)
+      );
+    } catch {
+      // Fall through to UTC
+    }
+  }
+  return dt.toISOString();
+}
+
+/**
+ * Get UTC offset string for a timezone at a given instant.
+ * @param {Date} dt
+ * @param {string} tzName
+ * @returns {string} e.g. "+02:00" or "-05:00"
+ */
+function getUtcOffset(dt, tzName) {
+  try {
+    const parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: tzName,
+      timeZoneName: "longOffset",
+    }).formatToParts(dt);
+    const tzPart = parts.find((p) => p.type === "timeZoneName");
+    if (tzPart) {
+      // "GMT+2" → "+02:00", "GMT-5:30" → "-05:30", "GMT" → "+00:00"
+      const match = tzPart.value.match(/GMT([+-])(\d{1,2})(?::(\d{2}))?/);
+      if (match) {
+        const sign = match[1];
+        const hours = match[2].padStart(2, "0");
+        const mins = (match[3] ?? "00").padStart(2, "0");
+        return `${sign}${hours}:${mins}`;
+      }
+      return "+00:00"; // GMT with no offset
+    }
+  } catch {
+    // Fallback
+  }
+  return "Z";
+}
+
+// --- Main ---
+
+function main() {
+  let daysBack = 30;
+  const daysIdx = process.argv.indexOf("--days");
+  if (daysIdx !== -1 && process.argv[daysIdx + 1]) {
+    daysBack = parseInt(process.argv[daysIdx + 1], 10);
+  }
+
+  const dbPath = findDb();
+  mkdirSync(OUTDIR, { recursive: true });
+
+  const now = Date.now();
+  const start = new Date(now - daysBack * 86400000);
+  const end = new Date(now + 14 * 86400000);
+  const startTs = (start.getTime() - EPOCH_MS) / 1000;
+  const endTs = (end.getTime() - EPOCH_MS) / 1000;
+
+  const db = openDb(dbPath);
+
+  try {
+    // Fetch events with a single query
+    const events = query(
+      db,
+      `
+      SELECT
+        ci.ROWID AS id,
+        ci.summary,
+        ci.start_date,
+        ci.end_date,
+        ci.start_tz,
+        ci.end_tz,
+        ci.all_day,
+        ci.description,
+        ci.has_attendees,
+        ci.conference_url,
+        loc.title AS location,
+        cal.title AS calendar_name,
+        org.address AS organizer_email,
+        org.display_name AS organizer_name
+      FROM CalendarItem ci
+      LEFT JOIN Location loc ON loc.ROWID = ci.location_id
+      LEFT JOIN Calendar cal ON cal.ROWID = ci.calendar_id
+      LEFT JOIN Identity org ON org.ROWID = ci.organizer_id
+      WHERE ci.start_date <= ${endTs}
+        AND COALESCE(ci.end_date, ci.start_date) >= ${startTs}
+        AND ci.summary IS NOT NULL
+        AND ci.summary != ''
+      ORDER BY ci.start_date ASC
+      LIMIT 1000;
+    `,
+    );
+
+    // Collect event IDs for batch attendee query
+    const eventIds = events.map((ev) => String(ev.id));
+
+    // Batch-fetch all attendees in one query
+    const attendeesByEvent = {};
+    if (eventIds.length > 0) {
+      const idList = eventIds.join(",");
+      const attendeesRaw = query(
+        db,
+        `
+        SELECT
+          p.owner_id,
+          p.email,
+          p.status,
+          p.role,
+          p.is_self,
+          p.entity_type,
+          i.display_name
+        FROM Participant p
+        LEFT JOIN Identity i ON i.ROWID = p.identity_id
+        WHERE p.owner_id IN (${idList})
+          AND p.entity_type = 7;
+      `,
+      );
+      for (const a of attendeesRaw) {
+        attendeesByEvent[a.owner_id] ??= [];
+        attendeesByEvent[a.owner_id].push(a);
+      }
+    }
+
+    // Write event JSON files
+    const writtenIds = new Set();
+    for (const ev of events) {
+      const eid = ev.id;
+
+      // Organizer — strip mailto: prefix
+      let orgEmail = ev.organizer_email ?? null;
+      if (orgEmail?.startsWith("mailto:")) orgEmail = orgEmail.slice(7);
+
+      // Attendees
+      const attendees = [];
+      for (const a of attendeesByEvent[eid] ?? []) {
+        if (!a.email) continue;
+        attendees.push({
+          email: a.email,
+          name: (a.display_name ?? "").trim() || null,
+          status: STATUS_MAP[a.status] ?? "unknown",
+          role: ROLE_MAP[a.role] ?? "unknown",
+          self: Boolean(a.is_self),
+        });
+      }
+
+      const isAllDay = Boolean(ev.all_day);
+
+      const eventJson = {
+        id: `apple_cal_${eid}`,
+        summary: ev.summary,
+        start: {
+          dateTime: coredataToIso(ev.start_date, ev.start_tz),
+          timeZone: ev.start_tz !== "_float" ? ev.start_tz : null,
+        },
+        end: {
+          dateTime: coredataToIso(ev.end_date ?? ev.start_date, ev.end_tz),
+          timeZone: ev.end_tz !== "_float" ? ev.end_tz : null,
+        },
+        allDay: isAllDay,
+        location: ev.location || null,
+        description: ev.description || null,
+        conferenceUrl: ev.conference_url || null,
+        calendar: ev.calendar_name || null,
+        organizer: orgEmail
+          ? { email: orgEmail, name: (ev.organizer_name ?? "").trim() || null }
+          : null,
+        attendees: attendees.length > 0 ? attendees : null,
+      };
+
+      const filename = `${eid}.json`;
+      writeFileSync(join(OUTDIR, filename), JSON.stringify(eventJson, null, 2));
+      writtenIds.add(filename);
+    }
+
+    // Clean up events outside the window
+    let removed = 0;
+    for (const fname of readdirSync(OUTDIR)) {
+      if (fname.endsWith(".json") && !writtenIds.has(fname)) {
+        unlinkSync(join(OUTDIR, fname));
+        removed++;
+      }
+    }
+
+    console.log("Apple Calendar Sync Complete");
+    console.log(`Events synced: ${writtenIds.size}`);
+    console.log(
+      `Time window: ${start.toISOString().slice(0, 10)} to ${end.toISOString().slice(0, 10)}`,
+    );
+    console.log(`Files cleaned up: ${removed} (outside window)`);
+    console.log(`Output: ${OUTDIR}`);
+  } finally {
+    db.close();
+  }
+}
+
+main();

package/template/.claude/skills/sync-apple-mail/SKILL.md

@@ -41,10 +41,10 @@ their email.
 
 ## Implementation
 
-Run the sync as a single Python script. This avoids N+1 shell invocations and
-handles all data transformation in one pass:
+Run the sync as a single Node.js script with embedded SQLite. This avoids N+1
+process invocations and handles all data transformation in one pass:
 
-    python3 scripts/sync.py [--days N]
+    node scripts/sync.mjs [--days N]
 
 - `--days N` — how many days back to look on first sync (default: 30)
 
@@ -61,7 +61,7 @@ The script:
 7. Updates sync state timestamp
 8. Reports summary (threads processed, files written)
 
-The script calls `scripts/parse-emlx.py` to extract plain text bodies from
+The script imports `scripts/parse-emlx.mjs` to extract plain text bodies from
 `.emlx` / `.partial.emlx` files (handles HTML-only emails by stripping tags).
 
 ## Database Schema
@@ -128,7 +128,7 @@ Rules:
 - `.emlx` / `.partial.emlx` not found → fall back to database summary field
 - `.emlx` parse error → fall back to database summary field
 - HTML-only email → strip tags and use as plain text body (handled by
-  parse-emlx.py)
+  parse-emlx.mjs)
 - `find` timeout → skip that message's body, use summary; attachment index empty
 - Attachment file not found on disk → listed as `*(not available)*` in markdown
 - Attachment copy fails (permissions, disk full) → listed as `*(not available)*`
@@ -137,7 +137,7 @@ Rules:
 
 ## Constraints
 
-- Open database read-only (`-readonly`)
+- Open database read-only (`readOnly: true`)
 - Only sync Inbox and Sent folders
 - Limit to 500 threads per run
 - Incremental: only threads with new messages since last sync