opencode-knowledge-work 0.0.0-stage → 0.1.1

package/content/enterprise-search/README.md

@@ -0,0 +1,157 @@
+# Enterprise Search
+
+An enterprise search plugin primarily designed for [Cowork](https://claude.com/product/cowork), Anthropic's agentic desktop application — though it also works in Claude Code. Search across all your company's tools in one place — email, chat, documents, and wikis — without switching between apps.
+
+---
+
+## How It Works
+
+One query searches all your connected tools simultaneously. Claude decomposes your question, runs targeted searches across every source, and synthesizes the results into a single coherent answer with source attribution.
+
+```
+You: "What did we decide about the API redesign?"
+              ↓ Claude searches
+~~chat: #engineering thread from Tuesday with the decision
+~~email: Follow-up email from Sarah with the spec
+~~cloud storage: Updated API design doc (modified yesterday)
+              ↓ Claude synthesizes
+"The team decided on Tuesday to go with REST over GraphQL.
+ Sarah sent the updated spec Thursday. The design doc
+ reflects the final approach."
+```
+
+No tab switching. No remembering which tool has what. Ask the question, get the answer.
+
+---
+
+## What It Searches
+
+> If you see unfamiliar placeholders or need to check which tools are connected, see [CONNECTORS.md](CONNECTORS.md).
+
+Connect any combination of sources. The more you connect, the more complete your answers.
+
+| Source | What it finds |
+|--------|---------------|
+| **~~chat** | Messages, threads, channels, DMs |
+| **~~email** | Emails, attachments, conversations |
+| **~~cloud storage** | Docs, sheets, slides, PDFs |
+| **Wiki / Knowledge Base** | Internal documentation, runbooks |
+| **Project Management** | Tasks, issues, epics, milestones |
+| **CRM** | Accounts, contacts, opportunities |
+| **Ticketing** | Support tickets, customer issues |
+
+Each source is an MCP connection. Add more sources in your MCP settings to expand what Claude can search.
+
+---
+
+## Commands
+
+| Command | What it does |
+|---------|--------------|
+| `/search` | Search across all connected sources in one query |
+| `/digest` | Generate a daily or weekly digest of activity across all sources |
+
+### Search
+
+```
+/enterprise-search:search what's the status of Project Aurora?
+/enterprise-search:search from:sarah about:budget after:2025-01-01
+/enterprise-search:search decisions made in #product this week
+```
+
+Supports filters: `from:`, `in:`, `after:`, `before:`, `type:` — applied intelligently across each source's native query syntax.
+
+### Digest
+
+```
+/enterprise-search:digest --daily      # What happened today across all sources
+/enterprise-search:digest --weekly     # Weekly rollup grouped by project/topic
+```
+
+Highlights action items, decisions, and mentions of you. Groups activity by topic so you can skim what matters.
+
+---
+
+## Skills
+
+Three skills power the search experience:
+
+**Search Strategy** — Query decomposition and source-specific translation. Breaks your natural language question into targeted searches per source, handles ambiguity, and falls back gracefully when sources are unavailable.
+
+**Source Management** — Knows which MCP sources are available, guides you to connect new ones, manages source priority, and handles rate limits.
+
+**Knowledge Synthesis** — Combines results from multiple sources into coherent answers. Deduplicates cross-source information, attributes sources, scores confidence based on freshness and authority, and summarizes large result sets.
+
+---
+
+## Example Workflows
+
+### Finding a decision
+
+```
+You: /enterprise-search:search when did we decide to switch to Postgres?
+
+Claude searches:
+  ~~chat → #engineering, #infrastructure for "postgres" "switch" "decision"
+  ~~email → threads with "postgres" in subject
+  ~~cloud storage → docs mentioning database migration
+
+Result: "The decision was made March 3 in #infrastructure (link).
+         Sarah's email on March 4 confirmed the timeline.
+         The migration plan doc was updated March 5."
+```
+
+### Catching up after time off
+
+```
+You: /enterprise-search:digest --weekly
+
+Claude scans:
+  ~~chat → channels you're in, DMs, mentions
+  ~~email → inbox activity
+  ~~cloud storage → docs shared with you or modified
+
+Result: Grouped summary by project with action items
+        flagged and decisions highlighted.
+```
+
+### Finding an expert
+
+```
+You: /enterprise-search:search who knows about our Kubernetes setup?
+
+Claude searches:
+  ~~chat → messages about Kubernetes, k8s, clusters
+  ~~cloud storage → docs authored about infrastructure
+  Wiki → runbooks and architecture docs
+
+Result: "Based on message history and doc authorship,
+         Alex and Priya are your go-to people for k8s.
+         Here's the main runbook (link)."
+```
+
+---
+
+## Getting Started
+
+```bash
+# 1. Install
+claude plugin marketplace add anthropics/knowledge-work-plugins
+claude plugin install enterprise-search@knowledge-work-plugins
+
+# 2. Search across everything
+/enterprise-search:search [your question here]
+
+# 3. Get a digest
+/enterprise-search:digest --daily
+```
+
+The more sources you connect via MCP, the more complete your search results. Start with ~~chat, ~~email, and ~~cloud storage, then add your wiki, project management tool, and CRM as needed.
+
+---
+
+## Philosophy
+
+Knowledge workers spend hours every week hunting for information scattered across tools. The answer exists somewhere — in a Slack thread, an email chain, a doc, a wiki page — but finding it means searching each tool individually, cross-referencing results, and hoping you checked the right place.
+
+Enterprise Search treats all your tools as one searchable knowledge base. One query, all sources, synthesized results. Your company's knowledge shouldn't be locked in silos. Search everything at once.

package/content/enterprise-search/skills/enterprise-search-digest/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: digest
+description: Generate a daily or weekly digest of activity across all connected sources. Use when catching up after time away, starting the day and wanting a summary of mentions and action items, or reviewing a week's decisions and document updates grouped by project.
+argument-hint: "[--daily | --weekly | --since <date>]"
+---
+
+# Digest Command
+
+> If you see unfamiliar placeholders or need to check which tools are connected, see [CONNECTORS.md](../../CONNECTORS.md).
+
+Scan recent activity across all connected sources and generate a structured digest highlighting what matters.
+
+## Instructions
+
+### 1. Parse Flags
+
+Determine the time window from the user's input:
+
+- `--daily` — Last 24 hours (default if no flag specified)
+- `--weekly` — Last 7 days
+
+The user may also specify a custom range:
+- `--since yesterday`
+- `--since Monday`
+- `--since 2025-01-20`
+
+### 2. Check Available Sources
+
+Identify which MCP sources are connected (same approach as the search command):
+
+- **~~chat** — channels, DMs, mentions
+- **~~email** — inbox, sent, threads
+- **~~cloud storage** — recently modified docs shared with user
+- **~~project tracker** — tasks assigned, completed, commented on
+- **~~CRM** — opportunity updates, account activity
+- **~~knowledge base** — recently updated wiki pages
+
+If no sources are connected, guide the user:
+```
+To generate a digest, you'll need at least one source connected.
+Check your MCP settings to add ~~chat, ~~email, ~~cloud storage, or other tools.
+```
+
+### 3. Gather Activity from Each Source
+
+**~~chat:**
+- Search for messages mentioning the user (`to:me`)
+- Check channels the user is in for recent activity
+- Look for threads the user participated in
+- Identify new messages in key channels
+
+**~~email:**
+- Search recent inbox messages
+- Identify threads with new replies
+- Flag emails with action items or questions directed at the user
+
+**~~cloud storage:**
+- Find documents recently modified or shared with the user
+- Note new comments on docs the user owns or collaborates on
+
+**~~project tracker:**
+- Tasks assigned to the user (new or updated)
+- Tasks completed by others that the user follows
+- Comments on tasks the user is involved with
+
+**~~CRM:**
+- Opportunity stage changes
+- New activities logged on accounts the user owns
+- Updated contacts or accounts
+
+**~~knowledge base:**
+- Recently updated documents in relevant collections
+- New documents created in watched areas
+
+### 4. Identify Key Items
+
+From all gathered activity, extract and categorize:
+
+**Action Items:**
+- Direct requests made to the user ("Can you...", "Please...", "@user")
+- Tasks assigned or due soon
+- Questions awaiting the user's response
+- Review requests
+
+**Decisions:**
+- Conclusions reached in threads or emails
+- Approvals or rejections
+- Policy or direction changes
+
+**Mentions:**
+- Times the user was mentioned or referenced
+- Discussions about the user's projects or areas
+
+**Updates:**
+- Status changes on projects the user follows
+- Document updates in the user's domain
+- Completed items the user was waiting on
+
+### 5. Group by Topic
+
+Organize the digest by topic, project, or theme rather than by source. Merge related activity across sources:
+
+```
+## Project Aurora
+- ~~chat: Design review thread concluded — team chose Option B (#design, Tuesday)
+- ~~email: Sarah sent updated spec incorporating feedback (Wednesday)
+- ~~cloud storage: "Aurora API Spec v3" updated by Sarah (Wednesday)
+- ~~project tracker: 3 tasks moved to In Progress, 2 completed
+
+## Budget Planning
+- ~~email: Finance team requesting Q2 projections by Friday
+- ~~chat: Todd shared template in #finance (Monday)
+- ~~cloud storage: "Q2 Budget Template" shared with you (Monday)
+```
+
+### 6. Format the Digest
+
+Structure the output clearly:
+
+```
+# [Daily/Weekly] Digest — [Date or Date Range]
+
+Sources scanned: ~~chat, ~~email, ~~cloud storage, [others]
+
+## Action Items (X items)
+- [ ] [Action item 1] — from [person], [source] ([date])
+- [ ] [Action item 2] — from [person], [source] ([date])
+
+## Decisions Made
+- [Decision 1] — [context] ([source], [date])
+- [Decision 2] — [context] ([source], [date])
+
+## [Topic/Project Group 1]
+[Activity summary with source attribution]
+
+## [Topic/Project Group 2]
+[Activity summary with source attribution]
+
+## Mentions
+- [Mention context] — [source] ([date])
+
+## Documents Updated
+- [Doc name] — [who modified, what changed] ([date])
+```
+
+### 7. Handle Unavailable Sources
+
+If any source fails or is unreachable:
+```
+Note: Could not reach [source name] for this digest.
+The following sources were included: [list of successful sources].
+```
+
+Do not let one failed source prevent the digest from being generated. Produce the best digest possible from available sources.
+
+### 8. Summary Stats
+
+End with a quick summary:
+```
+---
+[X] action items · [Y] decisions · [Z] mentions · [W] doc updates
+Across [N] sources · Covering [time range]
+```
+
+## Notes
+
+- Default to `--daily` if no flag is specified
+- Group by topic/project, not by source — users care about what happened, not where it happened
+- Action items should always be listed first — they are the most actionable part of a digest
+- Deduplicate cross-source activity (same decision in ~~chat and email = one entry)
+- For weekly digests, prioritize significance over completeness — highlight what matters, skip noise
+- If the user has a memory system (CLAUDE.md), use it to decode people names and project references
+- Include enough context in each item that the user can decide whether to dig deeper without clicking through

package/content/enterprise-search/skills/enterprise-search-knowledge-synthesis/SKILL.md

@@ -0,0 +1,258 @@
+---
+name: knowledge-synthesis
+description: Combines search results from multiple sources into coherent, deduplicated answers with source attribution. Handles confidence scoring based on freshness and authority, and summarizes large result sets effectively.
+user-invocable: false
+---
+
+# Knowledge Synthesis
+
+The last mile of enterprise search. Takes raw results from multiple sources and produces a coherent, trustworthy answer.
+
+## The Goal
+
+Transform this:
+```
+~~chat result: "Sarah said in #eng: 'let's go with REST, GraphQL is overkill for our use case'"
+~~email result: "Subject: API Decision — Sarah's email confirming REST approach with rationale"
+~~cloud storage result: "API Design Doc v3 — updated section 2 to reflect REST decision"
+~~project tracker result: "Task: Finalize API approach — marked complete by Sarah"
+```
+
+Into this:
+```
+The team decided to go with REST over GraphQL for the API redesign. Sarah made the
+call, noting that GraphQL was overkill for the current use case. This was discussed
+in #engineering on Tuesday, confirmed via email Wednesday, and the design doc has
+been updated to reflect the decision. The related ~~project tracker task is marked complete.
+
+Sources:
+- ~~chat: #engineering thread (Jan 14)
+- ~~email: "API Decision" from Sarah (Jan 15)
+- ~~cloud storage: "API Design Doc v3" (updated Jan 15)
+- ~~project tracker: "Finalize API approach" (completed Jan 15)
+```
+
+## Deduplication
+
+### Cross-Source Deduplication
+
+The same information often appears in multiple places. Identify and merge duplicates:
+
+**Signals that results are about the same thing:**
+- Same or very similar text content
+- Same author/sender
+- Timestamps within a short window (same day or adjacent days)
+- References to the same entity (project name, document, decision)
+- One source references another ("as discussed in ~~chat", "per the email", "see the doc")
+
+**How to merge:**
+- Combine into a single narrative item
+- Cite all sources where it appeared
+- Use the most complete version as the primary text
+- Add unique details from each source
+
+### Deduplication Priority
+
+When the same information exists in multiple sources, prefer:
+```
+1. The most complete version (fullest context)
+2. The most authoritative source (official doc > chat)
+3. The most recent version (latest update wins for evolving info)
+```
+
+### What NOT to Deduplicate
+
+Keep as separate items when:
+- The same topic is discussed but with different conclusions
+- Different people express different viewpoints
+- The information evolved meaningfully between sources (v1 vs v2 of a decision)
+- Different time periods are represented
+
+## Citation and Source Attribution
+
+Every claim in the synthesized answer must be attributable to a source.
+
+### Attribution Format
+
+Inline for direct references:
+```
+Sarah confirmed the REST approach in her email on Wednesday.
+The design doc was updated to reflect this (~~cloud storage: "API Design Doc v3").
+```
+
+Source list at the end for completeness:
+```
+Sources:
+- ~~chat: #engineering discussion (Jan 14) — initial decision thread
+- ~~email: "API Decision" from Sarah Chen (Jan 15) — formal confirmation
+- ~~cloud storage: "API Design Doc v3" last modified Jan 15 — updated specification
+```
+
+### Attribution Rules
+
+- Always name the source type (~~chat, ~~email, ~~cloud storage, etc.)
+- Include the specific location (channel, folder, thread)
+- Include the date or relative time
+- Include the author when relevant
+- Include document/thread titles when available
+- For ~~chat, note the channel name
+- For ~~email, note the subject line and sender
+- For ~~cloud storage, note the document title
+
+## Confidence Levels
+
+Not all results are equally trustworthy. Assess confidence based on:
+
+### Freshness
+
+| Recency | Confidence impact |
+|---------|------------------|
+| Today / yesterday | High confidence for current state |
+| This week | Good confidence |
+| This month | Moderate — things may have changed |
+| Older than a month | Lower confidence — flag as potentially outdated |
+
+For status queries, heavily weight freshness. For policy/factual queries, freshness matters less.
+
+### Authority
+
+| Source type | Authority level |
+|-------------|----------------|
+| Official wiki / knowledge base | Highest — curated, maintained |
+| Shared documents (final versions) | High — intentionally published |
+| Email announcements | High — formal communication |
+| Meeting notes | Moderate-high — may be incomplete |
+| Chat messages (thread conclusions) | Moderate — informal but real-time |
+| Chat messages (mid-thread) | Lower — may not reflect final position |
+| Draft documents | Low — not finalized |
+| Task comments | Contextual — depends on commenter |
+
+### Expressing Confidence
+
+When confidence is high (multiple fresh, authoritative sources agree):
+```
+The team decided to use REST for the API redesign. [direct statement]
+```
+
+When confidence is moderate (single source or somewhat dated):
+```
+Based on the discussion in #engineering last month, the team was leaning
+toward REST for the API redesign. This may have evolved since then.
+```
+
+When confidence is low (old data, informal source, or conflicting signals):
+```
+I found a reference to an API migration discussion from three months ago
+in ~~chat, but I couldn't find a formal decision document. The information
+may be outdated. You might want to check with the team for current status.
+```
+
+### Conflicting Information
+
+When sources disagree:
+```
+I found conflicting information about the API approach:
+- The ~~chat discussion on Jan 10 suggested GraphQL
+- But Sarah's email on Jan 15 confirmed REST
+- The design doc (updated Jan 15) reflects REST
+
+The most recent sources indicate REST was the final decision,
+but the earlier ~~chat discussion explored GraphQL first.
+```
+
+Always surface conflicts rather than silently picking one version.
+
+## Summarization Strategies
+
+### For Small Result Sets (1-5 results)
+
+Present each result with context. No summarization needed — give the user everything:
+```
+[Direct answer synthesized from results]
+
+[Detail from source 1]
+[Detail from source 2]
+
+Sources: [full attribution]
+```
+
+### For Medium Result Sets (5-15 results)
+
+Group by theme and summarize each group:
+```
+[Overall answer]
+
+Theme 1: [summary of related results]
+Theme 2: [summary of related results]
+
+Key sources: [top 3-5 most relevant sources]
+Full results: [count] items found across [sources]
+```
+
+### For Large Result Sets (15+ results)
+
+Provide a high-level synthesis with the option to drill down:
+```
+[Overall answer based on most relevant results]
+
+Summary:
+- [Key finding 1] (supported by N sources)
+- [Key finding 2] (supported by N sources)
+- [Key finding 3] (supported by N sources)
+
+Top sources:
+- [Most authoritative/relevant source]
+- [Second most relevant]
+- [Third most relevant]
+
+Found [total count] results across [source list].
+Want me to dig deeper into any specific aspect?
+```
+
+### Summarization Rules
+
+- Lead with the answer, not the search process
+- Do not list raw results — synthesize them into narrative
+- Group related items from different sources together
+- Preserve important nuance and caveats
+- Include enough detail that the user can decide whether to dig deeper
+- Always offer to provide more detail if the result set was large
+
+## Synthesis Workflow
+
+```
+[Raw results from all sources]
+          ↓
+[1. Deduplicate — merge same info from different sources]
+          ↓
+[2. Cluster — group related results by theme/topic]
+          ↓
+[3. Rank — order clusters and items by relevance to query]
+          ↓
+[4. Assess confidence — freshness × authority × agreement]
+          ↓
+[5. Synthesize — produce narrative answer with attribution]
+          ↓
+[6. Format — choose appropriate detail level for result count]
+          ↓
+[Coherent answer with sources]
+```
+
+## Anti-Patterns
+
+**Do not:**
+- List results source by source ("From ~~chat: ... From ~~email: ... From ~~cloud storage: ...")
+- Include irrelevant results just because they matched a keyword
+- Bury the answer under methodology explanation
+- Present conflicting info without flagging the conflict
+- Omit source attribution
+- Present uncertain information with the same confidence as well-supported facts
+- Summarize so aggressively that useful detail is lost
+
+**Do:**
+- Lead with the answer
+- Group by topic, not by source
+- Flag confidence levels when appropriate
+- Surface conflicts explicitly
+- Attribute all claims to sources
+- Offer to go deeper when result sets are large