@forwardimpact/basecamp 2.0.0 → 2.2.0

package/template/.claude/skills/manage-tasks/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: manage-tasks
+description: Create, update, list, and close tasks on per-person task boards in knowledge/Tasks/. Manages task lifecycle, extracts action items from other skills, and keeps boards current. Use when the user asks to add, update, or review tasks, or when chained from extract-entities or process-hyprnote.
+---
+
+# Manage Tasks
+
+Manage per-person task boards in `knowledge/Tasks/`. Each person has a single
+living document that tracks all their open, in-progress, blocked, and recently
+completed tasks. Task boards are the **canonical source** for task tracking —
+other notes (People, Projects) link to them rather than duplicating.
+
+## Trigger
+
+Run this skill:
+
+- When the user asks to add, update, close, or list tasks
+- When chained from `extract-entities` or `process-hyprnote` with extracted
+  action items
+- When the user asks to see someone's task board or workload
+- On a schedule to perform housekeeping (prune done items, flag overdue)
+
+## Prerequisites
+
+- `knowledge/Tasks/` directory exists
+- User identity configured in `USER.md`
+
+## Inputs
+
+### User-initiated
+
+- Person name and task details from the user's request
+
+### Chained from other skills
+
+Action items extracted by `extract-entities` or `process-hyprnote`, passed as
+structured data:
+
+```
+TASKS:
+- Owner: {Full Name}
+  Task: {Description — starts with a verb}
+  Priority: high|medium|low
+  Due: YYYY-MM-DD (if known)
+  Source: meeting|email
+  Source date: YYYY-MM-DD
+  Project: {Project Name} (if applicable)
+  Context: {Brief context about where this came from}
+```
+
+## Outputs
+
+- `knowledge/Tasks/{Person Name}.md` — created or updated task boards
+
+---
+
+## Task Board Format
+
+Each task board is a markdown file with four sections, always in this order:
+
+```markdown
+# {Person Name}
+
+## In Progress
+## Open
+## Blocked
+## Recently Done
+```
+
+All four sections are always present, even if empty.
+
+**Task entry format:**
+
+```
+- [ ] **{Task title}** | {priority} | due {YYYY-MM-DD} | [[Projects/Name]]
+  {Context line with source info and backlinks.}
+```
+
+**Key conventions:**
+
+- **Priorities:** `high` | `medium` | `low` — omit if medium (default)
+- **Due dates:** Only include if there's a real deadline. Format:
+  `due YYYY-MM-DD`
+- **No task IDs.** Tasks are identified by their bold title. Keep titles unique
+  within a person's board.
+- **Recently Done:** Keep the last 14 days. Older items pruned during
+  housekeeping.
+
+## Before Starting
+
+1. Read `USER.md` to get user identity.
+2. Determine the operation: **add**, **update**, **close**, **list**, or
+   **housekeeping**.
+
+## Step 1: Resolve the Person
+
+For any task operation, resolve the person to their canonical name:
+
+```bash
+ls knowledge/Tasks/
+rg "{name}" knowledge/People/
+```
+
+If the person doesn't have a task board yet, create one from the template (Step
+4 covers creation).
+
+## Step 2: Read Current Task Board
+
+```bash
+cat "knowledge/Tasks/{Person Name}.md"
+```
+
+Parse existing tasks to:
+
+- Avoid duplicates (same person, similar description)
+- Understand current workload
+- Find the right insertion point
+
+## Step 3: Perform the Operation
+
+### Add a Task
+
+1. Check for duplicates — same person, similar task title or description. If a
+   near-duplicate exists, update it instead of creating a new entry.
+2. Determine the section:
+   - Default: `## Open`
+   - If user says "I'm working on" / "started" → `## In Progress`
+   - If blocked → `## Blocked`
+3. Format the task entry:
+   ```
+   - [ ] **{Task title}** | {priority} | due {YYYY-MM-DD} | [[Projects/Name]]
+     {Context line with source info and backlinks.}
+   ```
+4. Add the entry at the **bottom** of the appropriate section.
+5. If the task references a project, verify the project note exists.
+
+### Update a Task
+
+1. Find the task by title (fuzzy match OK — bold text between `**`).
+2. Apply changes:
+   - **Status change:** Move the entire entry between sections
+   - **Priority change:** Update the `| {priority} |` segment
+   - **Due date change:** Update or add `| due YYYY-MM-DD |`
+   - **Add context:** Append to the indented line
+3. Use the Edit tool for targeted modifications.
+
+### Close a Task
+
+1. Find the task by title.
+2. Remove it from its current section.
+3. Add to the **top** of `## Recently Done`:
+   ```
+   - [x] **{Task title}** | completed {YYYY-MM-DD}
+   ```
+   (Drop priority, due date, project link, and context — keep it compact.)
+
+### List Tasks
+
+Query across all task boards:
+
+```bash
+# All open/in-progress tasks
+rg "^- \[ \] \*\*" knowledge/Tasks/
+
+# Tasks for a specific project
+rg "Projects/{Name}" knowledge/Tasks/
+
+# High priority tasks
+rg "\| high \|" knowledge/Tasks/
+
+# Overdue tasks — find all due dates and compare against today
+rg "due 20[0-9]{2}-[0-9]{2}-[0-9]{2}" knowledge/Tasks/
+
+# Blocked tasks
+rg -A1 "^- \[ \]" knowledge/Tasks/ | rg -B1 "Waiting on"
+```
+
+Present results in a clean summary, grouped by person or project as appropriate
+for the user's question.
+
+### Housekeeping (Scheduled)
+
+Run across all task boards:
+
+1. **Prune done items:** Remove completed tasks older than 14 days from
+   `## Recently Done`.
+2. **Flag overdue:** Any task with `due {date}` in the past that's still in
+   `## Open` or `## In Progress` — check if it needs attention. Do NOT
+   auto-modify the task; instead, report overdue items to the user.
+3. **Deduplicate:** If identical tasks appear on the same board, merge them.
+4. **Validate links:** Spot-check that `[[People/]]` and `[[Projects/]]`
+   references point to existing notes.
+
+## Step 4: Write Updates
+
+### New task board
+
+Create `knowledge/Tasks/{Person Name}.md` with all four sections:
+
+```markdown
+# {Person Name}
+
+## In Progress
+
+## Open
+
+## Blocked
+
+## Recently Done
+```
+
+### Existing task board
+
+Use the Edit tool to make targeted changes — add, move, or modify individual
+task entries. Do NOT rewrite the entire file.
+
+## Step 5: Migrate Open Items (One-time)
+
+When first setting up task boards, or when the user asks, migrate existing
+`## Open items` from People and Project notes:
+
+1. Scan notes for `## Open items` sections with content:
+   ```bash
+   rg -l "## Open items" knowledge/People/ knowledge/Projects/
+   ```
+2. For each note with open items, read the items and convert them to task board
+   entries.
+3. Add each item to the appropriate person's task board.
+4. **Do NOT remove** the original open items from source notes — they serve as
+   the historical record. The task board becomes the living tracker.
+
+## Quality Checklist
+
+- [ ] Task title is clear and actionable (starts with a verb)
+- [ ] Priority set appropriately (omit if medium)
+- [ ] Due date included only if there's a real deadline
+- [ ] Project linked with `[[Projects/Name]]` if applicable
+- [ ] No duplicate tasks on the board
+- [ ] Recently Done pruned to last 14 days (housekeeping)
+- [ ] All backlinks use absolute paths `[[Folder/Name]]`
+- [ ] Context line is concise (1-2 lines max)
+- [ ] New task board has all four sections present

package/template/.claude/skills/organize-files/SKILL.md

@@ -61,7 +61,7 @@ Run when the user asks to find, organize, clean up, or tidy files on their Mac.
 
 Get an overview of both directories:
 
-    bash scripts/summarize.sh
+    node scripts/summarize.mjs
 
 ## Finding Files
 
@@ -79,8 +79,8 @@ find ~/Desktop -maxdepth 1 \( -name "Screenshot*" -o -name "Screen Shot*" \)
 Organize a directory into type-based subdirectories (Documents, Images,
 Archives, Installers, Screenshots):
 
-    bash scripts/organize-by-type.sh ~/Downloads
-    bash scripts/organize-by-type.sh ~/Desktop
+    node scripts/organize-by-type.mjs ~/Downloads
+    node scripts/organize-by-type.mjs ~/Desktop
 
 The script creates subdirectories and moves matching files. It does NOT delete
 anything.

package/template/.claude/skills/organize-files/scripts/organize-by-type.mjs

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Organize files in a directory by type into subdirectories.
+ *
+ * Scans the top level of the given directory and moves files into category
+ * subdirectories: Screenshots, Documents, Images, Archives, and Installers.
+ * Categories are determined by file extension and name prefix. Files that do
+ * not match any category are left in place. Does NOT delete anything.
+ */
+
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  renameSync,
+  statSync,
+} from "node:fs";
+import { extname, join } from "node:path";
+
+const HELP = `organize-by-type — sort files into type-based subdirectories
+
+Usage: node scripts/organize-by-type.mjs <directory> [-h|--help]
+
+Creates subdirectories (Documents, Images, Archives, Installers, Screenshots)
+and moves matching top-level files into them. Does NOT delete any files.`;
+
+if (process.argv.includes("-h") || process.argv.includes("--help")) {
+  console.log(HELP);
+  process.exit(0);
+}
+
+const CATEGORIES = [
+  {
+    name: "Screenshots",
+    test: (name) =>
+      name.startsWith("Screenshot") || name.startsWith("Screen Shot"),
+  },
+  {
+    name: "Documents",
+    test: (_name, ext) =>
+      [
+        ".pdf",
+        ".doc",
+        ".docx",
+        ".txt",
+        ".md",
+        ".rtf",
+        ".csv",
+        ".xlsx",
+      ].includes(ext),
+  },
+  {
+    name: "Images",
+    test: (_name, ext) =>
+      [".png", ".jpg", ".jpeg", ".gif", ".webp"].includes(ext),
+  },
+  {
+    name: "Archives",
+    test: (name, ext) =>
+      [".zip", ".rar"].includes(ext) || name.endsWith(".tar.gz"),
+  },
+  {
+    name: "Installers",
+    test: (_name, ext) => ext === ".dmg",
+  },
+];
+
+function main() {
+  const dir = process.argv[2];
+  if (!dir) {
+    console.error("Usage: node scripts/organize-by-type.mjs <directory>");
+    process.exit(1);
+  }
+  if (!existsSync(dir) || !statSync(dir).isDirectory()) {
+    console.error(`Error: Directory not found: ${dir}`);
+    process.exit(1);
+  }
+
+  // Create subdirectories
+  for (const cat of CATEGORIES) {
+    mkdirSync(join(dir, cat.name), { recursive: true });
+  }
+
+  let moved = 0;
+  for (const name of readdirSync(dir)) {
+    const fullPath = join(dir, name);
+    const stat = statSync(fullPath, { throwIfNoEntry: false });
+    if (!stat || !stat.isFile()) continue;
+
+    const ext = extname(name).toLowerCase();
+    for (const cat of CATEGORIES) {
+      if (cat.test(name, ext)) {
+        const dest = join(dir, cat.name, name);
+        renameSync(fullPath, dest);
+        console.log(`${name} -> ${cat.name}/`);
+        moved++;
+        break;
+      }
+    }
+  }
+
+  console.log(`\nOrganization complete: ${dir} (${moved} files moved)`);
+}
+
+main();

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