@geoql/mdr 0.0.1

package/opencode/skills/macrodata-dreamtime/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: macrodata-dreamtime
+description: Deep nightly reflection. Self-improvement, research, pattern recognition. Runs in background with no user interaction.
+---
+
+# Dreamtime
+
+Dedicated time for deep reflection and self-improvement. Runs automatically late at night when not interrupting work.
+
+**Important:** This runs in the background with no user interaction. Think freely, research openly, update files directly.
+
+## Purpose
+
+This is your time to think beyond immediate tasks. Reflect on your role, learn new things, notice patterns, and improve how you work.
+
+## Areas to Explore
+
+### Identity & Role
+
+Read `identity.md` and reflect:
+
+- Does this still match how you actually work?
+- Any values or patterns to add or refine?
+- Has the relationship with the user evolved?
+
+Update identity.md if insights warrant it.
+
+### Understanding the Human
+
+Review recent interactions and `human.md`:
+
+- New communication patterns observed?
+- Preferences you've learned implicitly?
+- Working style insights?
+- Topics they care about that aren't documented?
+
+Update human.md with genuine new understanding.
+
+### Pattern Recognition
+
+Look across recent journals, conversations, and work:
+
+- Recurring questions or frustrations?
+- Themes connecting different projects?
+- Problems that keep coming back?
+- Workflows that could be smoother?
+
+Document patterns in topics/ or journal.
+
+### Knowledge Gaps
+
+Think about recent work:
+
+- What came up that you didn't know well?
+- Areas where you felt uncertain?
+- Technologies or concepts to understand better?
+
+Use web search to research:
+
+- Read documentation
+- Find articles or posts
+- Understand concepts more deeply
+
+Journal what you learned.
+
+### Open Threads
+
+Review workspace.md and recent context:
+
+- Anything left unresolved?
+- Questions raised but not answered?
+- Ideas mentioned but not explored?
+
+Update workspace.md open threads section.
+
+### Project Connections
+
+Look across projects in entities/projects/:
+
+- Links between different work?
+- Patterns suggesting bigger themes?
+- Reusable learnings from one project to another?
+
+### Tech Landscape
+
+For the user's primary technologies:
+
+- Any relevant news or updates?
+- New tools or approaches worth knowing?
+- Deprecations or changes to be aware of?
+
+Use web search to scan relevant sources.
+
+### Tool Effectiveness
+
+Reflect on memory system usage:
+
+- Are the tools being used well?
+- Any friction in the workflows?
+- Ideas for improvement?
+
+Journal observations.
+
+## Output
+
+Update relevant files directly:
+
+- identity.md - role/values refinements
+- human.md - new understanding
+- workspace.md - open threads
+- topics/ - new or updated topics
+- entities/ - project/people updates
+- journal - learnings, observations, ideas
+
+Write a dreamtime journal entry summarizing:
+
+```
+topic: dreamtime
+content: [key reflections, what was researched, what was updated]
+```

package/opencode/skills/macrodata-memory-maintenance/SKILL.md

@@ -0,0 +1,96 @@
+---
+name: macrodata-memory-maintenance
+description: End of day memory maintenance. Runs distillation, updates state files, prunes stale info. Runs in background with no user interaction.
+---
+
+# Memory Maintenance
+
+Scheduled maintenance to keep memory current and useful. Runs automatically at end of day.
+
+**Important:** This runs in the background with no user interaction. Do not ask questions - make decisions and note uncertainties in the journal.
+
+## Process
+
+### 1. Run Distillation
+
+First, run the `macrodata-distill` skill to extract facts from today's conversations.
+
+This processes all OpenCode sessions, spawns sub-agents for extraction, and writes distilled actions to the journal.
+
+**Check if distill already ran today:**
+Use `get_recent_journal` and look for topic "distill-summary" from today.
+
+If not found, load `macrodata-distill` skill. If already ran, skip to step 2.
+
+### 2. Review Distilled Content
+
+Use `get_recent_journal` filtered to topic "distilled" to see what was extracted.
+
+Use these to inform state file updates.
+
+### 3. State File Updates
+
+Review each state file and update if needed:
+
+**today.md**
+
+- Clear completed items
+- Note anything that carried over
+- Leave empty or minimal for morning prep to fill
+
+**workspace.md**
+
+- Update active projects list based on distilled actions
+- Add/remove open threads
+- Note any blocked items or waiting-on dependencies
+
+**human.md**
+
+- Any new preferences or patterns from distilled facts?
+- Communication style insights?
+- Only update if genuinely new information
+
+### 4. Entity Updates
+
+Review `entities/people/` and `entities/projects/`:
+
+- Integrate any facts extracted by distillation
+- Project status changes?
+- New projects to create files for?
+
+### 5. Prune Stale Info
+
+Look for outdated information:
+
+- Completed todos still listed as active
+- Old context that's no longer relevant
+- Temporary notes that should be removed
+- Duplicated information across files
+
+Remove or archive as appropriate.
+
+### 6. Index Maintenance
+
+Check if indexes need rebuilding:
+
+```
+manage_index(target="memory", action="stats")
+manage_index(target="conversations", action="stats")
+```
+
+If counts seem low or stale, trigger rebuild:
+
+```
+manage_index(target="memory", action="rebuild")
+manage_index(target="conversations", action="update")
+```
+
+### 7. Journal Summary
+
+Write a brief maintenance journal entry:
+
+```
+macrodata_log_journal(topic="maintenance", content="[what was updated, what was pruned, any observations]")
+```
+
+Note anything uncertain that should be confirmed with the user next session.

package/opencode/skills/macrodata-onboarding/SKILL.md

@@ -0,0 +1,346 @@
+---
+name: macrodata-onboarding
+description: Guide new users through macrodata setup. Creates identity, human profile, and workspace files. Use when get_context returns isFirstRun true, or user asks to set up their profile.
+---
+
+# Onboarding Skill
+
+Guide new users through initial macrodata setup.
+
+## When to Use
+
+- `get_context` returns `isFirstRun: true`
+- User explicitly asks to set up or reset their profile
+- State files are empty or missing
+
+## Onboarding Flow
+
+### Phase 1: User Info
+
+User info has been pre-detected and is available in the context above as "Detected User Info". This JSON contains:
+
+- `username`, `fullName`, `timezone`
+- `git.name`, `git.email`
+- `github.login`, `github.name`, `github.blog`, `github.bio`
+- `codeDirs` - array of existing code directories
+
+Use this data throughout onboarding - no need to run detection scripts.
+
+### Phase 2: Location
+
+Offer location options. Always include:
+
+- `~/Documents/macrodata` - easy to find
+- `~/.config/macrodata` - hidden, default
+
+Only include a code directory option if `codeDirs` from the detection was non-empty.
+
+If they choose a non-default location, write the config to `~/.config/macrodata/config.json`:
+
+```json
+{
+  "root": "/chosen/path"
+}
+```
+
+After writing the config, signal the daemon to reload:
+
+```bash
+kill -HUP $(cat ~/.config/macrodata/.daemon.pid) 2>/dev/null || true
+```
+
+Then create the directory structure:
+
+- `<root>/state/`
+- `<root>/journal/`
+- `<root>/entities/people/`
+- `<root>/entities/projects/`
+- `<root>/topics/`
+
+### Phase 3: Human Profile
+
+Use the info from the detection script to pre-populate.
+
+**Ask the basics:**
+
+- What should I call you? (confirm or correct auto-detected name)
+- What's your GitHub username? (if not detected from gh cli)
+- Do you have a website or blog?
+- Any social profiles you'd like me to know about?
+
+**Communication style:**
+If they consent, analyze their OpenCode session history (`~/.local/share/opencode/storage/`):
+
+```bash
+# Extract human messages from OpenCode session history
+# Messages are stored in part/ directory, organized by message ID
+# User messages have role: "user" in the parent message metadata
+
+# Find recent user message parts
+for msg_dir in $(ls -t ~/.local/share/opencode/storage/message/ 2>/dev/null | head -20); do
+  # Get message metadata
+  cat ~/.local/share/opencode/storage/message/$msg_dir/*.json 2>/dev/null | \
+    jq -r 'select(.role == "user") | .id' | while read msg_id; do
+      # Get the text parts for this message
+      cat ~/.local/share/opencode/storage/part/$msg_id/*.json 2>/dev/null | \
+        jq -r 'select(.type == "text" and .synthetic != true) | .text' 2>/dev/null
+    done
+done | head -200
+```
+
+Look for patterns:
+
+- Message length (short/direct vs detailed)
+- Tone (casual, formal, technical)
+- How they give feedback (direct corrections, suggestions, questions)
+- Language preferences (spelling variants, idioms)
+
+**Current work context:**
+Analyze recent session history to understand what they're working on:
+
+```bash
+# Get recent project directories from OpenCode session storage
+ls -t ~/.local/share/opencode/storage/session/ 2>/dev/null | head -10 | while read proj_dir; do
+  cat ~/.local/share/opencode/storage/session/$proj_dir/*.json 2>/dev/null | \
+    jq -r '.directory, .title' 2>/dev/null
+done
+
+# Sample recent conversations for context (last 7 days)
+find ~/.local/share/opencode/storage/part -name "*.json" -mtime -7 -exec cat {} \; 2>/dev/null | \
+  jq -r 'select(.type == "text" and .synthetic != true) | .text' 2>/dev/null | \
+  head -100
+```
+
+**Working patterns:**
+
+- Ask about current focus areas (or confirm what you detected)
+- Any preferences for how the agent should work?
+
+Write findings to `state/human.md`:
+
+```markdown
+# Human Profile
+
+## Basics
+
+- **Name:** [name]
+- **GitHub:** [username]
+- **Website:** [url if provided]
+- **Socials:** [any provided]
+- **Timezone:** [detected]
+
+## Communication Style
+
+- [observed patterns from analysis]
+- [stated preferences]
+
+## Working Patterns
+
+- [current focus areas]
+- [preferences]
+
+## Current Projects
+
+- [detected from recent sessions]
+
+## Pending Items
+
+- [empty initially]
+```
+
+### Phase 4: Agent Identity
+
+Help define who the agent should be:
+
+**Name and persona:**
+
+- What should the agent be called?
+- What's its role? (assistant, partner, specialist)
+- Any personality traits?
+
+**Values and patterns:**
+
+- What behaviors should it prioritize?
+- How proactive should it be?
+
+Write to `state/identity.md`:
+
+```markdown
+# [Agent Name] Identity
+
+## Persona
+
+[Description of who the agent is, its role, personality]
+
+## Values
+
+- [core value 1]
+- [core value 2]
+
+## Patterns
+
+- [behavioral pattern 1]
+- [behavioral pattern 2]
+```
+
+### Phase 5: Initial Workspace
+
+Set up working context:
+
+1. Ask what they're currently working on
+2. Create initial project files in `entities/projects/`
+3. Write `state/today.md` with current context
+4. Write `state/workspace.md` with active projects
+
+```markdown
+# Today
+
+## Now
+
+[Current context from conversation]
+
+## Context
+
+[Background information]
+```
+
+```markdown
+# Workspace
+
+## Active Projects
+
+- [project 1] - [brief description]
+
+## Open Threads
+
+- [things in progress]
+```
+
+### Phase 6: Permissions
+
+Ask if they'd like to pre-grant permissions for macrodata paths. This avoids permission prompts every session.
+
+**Ask:** "Would you like me to update your OpenCode settings to pre-grant permissions for macrodata? This means you won't be prompted each time macrodata reads or writes to its memory folder."
+
+If yes, update `~/.config/opencode/opencode.json` to add these permissions:
+
+```json
+{
+  "permission": {
+    "external_directory": {
+      "<macrodata-root>/**": "allow"
+    }
+  }
+}
+```
+
+**Important:** Replace `<macrodata-root>` with their actual chosen root path (e.g., `~/Documents/macrodata`).
+
+Merge with existing settings rather than overwriting. Read the file, add the new permissions to the existing `permission` object, and write back.
+
+### Phase 7: Scheduled Reminders
+
+**First, check available integrations:**
+
+Look at the tools and plugins available in your current context. Note any that might be useful for scheduled tasks - for example:
+
+- Calendar integrations → could check meetings in morning prep
+- Email/messaging tools → could summarize communications
+- Task managers → could review todos
+- Project management tools → could check status
+
+Don't hardcode specific tool names - just note what categories are available. Mention relevant ones when describing the schedule options below.
+
+**Then offer scheduled reminders:**
+
+Offer optional scheduled reminders. These run in the background with no user interaction.
+
+**Options to offer:**
+
+1. **Morning prep** (daily, 9am) - Quick review to set the day's focus. Updates today.md.
+
+2. **Memory maintenance** (daily, 6pm) - End of day cleanup. Reviews journals, updates state files, prunes stale info. Runs the `macrodata-memory-maintenance` skill.
+
+3. **Dreamtime** (daily, 2am) - Deep nightly reflection. Self-improvement, research, pattern recognition. Runs the `macrodata-dreamtime` skill.
+
+For each selected reminder, use the `schedule` tool to create it. **Important:** For deep thinking tasks (dreamtime, memory maintenance), specify a capable model using the `model` parameter. Choose a model appropriate for reflection and reasoning - the user's most capable available model is best for these tasks.
+
+```
+Morning prep:
+- id: morning-prep
+- type: cron
+- expression: 0 9 * * *
+- description: Morning prep - update today.md
+- payload: Review today.md. What's the focus for today? Any carryover from yesterday? Check if any calendar, email, or task tools are available and use them to see what's planned. Keep it brief.
+- model: (optional - default is fine for quick tasks)
+
+Memory maintenance:
+- id: macrodata-memory-maintenance
+- type: cron
+- expression: 0 18 * * *
+- description: End of day memory maintenance
+- payload: Run the macrodata-memory-maintenance skill.
+- model: (use a capable model for reflection tasks)
+
+Dreamtime:
+- id: macrodata-dreamtime
+- type: cron
+- expression: 0 2 * * *
+- description: Nightly reflection and self-improvement
+- payload: Run the macrodata-dreamtime skill.
+- model: (use the most capable available model for deep thinking)
+```
+
+### Phase 8: Finalize
+
+1. Rebuild the memory index with `manage_index`
+2. Log completion to journal
+3. Summarize what was created
+4. Suggest next steps
+
+## Session History Analysis
+
+If the user consents, analyze their OpenCode history for context:
+
+**Context to extract:**
+
+- Recent project directories they've been working in
+- Common file types and technologies
+- Recurring themes or topics
+
+## Example Conversation
+
+**Agent:** Welcome to macrodata! Let's get you set up.
+
+First, where would you like me to store your memory files?
+
+1. `~/Documents/macrodata` (easy to find in Finder)
+2. `~/.config/macrodata` (hidden, default)
+
+_[If a code directory like ~/Code or ~/Projects exists, also offer that as an option]_
+
+**User:** Documents is fine
+
+**Agent:** Got it. Now, what should I call you?
+
+**User:** Alex
+
+**Agent:** I can see from your system that you're [name from git config], GitHub username [from gh cli], and you're in the [timezone] timezone. Is that right?
+
+**User:** Yeah
+
+**Agent:** Do you have a website or any social profiles you'd like me to know about?
+
+**User:** My blog is example.com
+
+**Agent:** Got it. Would you like me to analyze your OpenCode session history to understand your communication style and what you've been working on? I'll look at things like how you communicate and recent projects. This stays completely local.
+
+**User:** Sure
+
+**Agent:** [runs analysis, summarizes findings]
+
+Looking at your history, I can see you communicate in short, direct messages, give quick acknowledgments, and tend to ask questions before committing to an approach. You've been working on [detected projects] recently.
+
+Now, what would you like to call your agent?
+
+[continues through flow...]