@codemieai/code 0.0.33 → 0.0.34

package/dist/agents/plugins/claude/plugin/commands/memory-add.md

@@ -1,44 +1,325 @@
-# Add New Knowledge to CLAUDE Memory Files
+# Add New Knowledge to Project Documentation
 
-FYI: You, Claude Code, manage persistent memory using `CLAUDE.md` files for shared project context. The system recursively searches upward from the current working directory to load all relevant `CLAUDE.md` files, ensuring project-level context is available. Subdirectory `CLAUDE.md` files are only loaded when working within those subfolders, keeping the active context focused and efficient.
+**Purpose**: Capture important learnings from the current session that should persist for future work.
 
-Additionally, placing a `CLAUDE.md` in your home directory (e.g., `~/.claude/CLAUDE.md`) provides a global, cross-project memory that is merged into every session under your home directory.
+**Context**: You manage persistent memory using documentation systems. Common approaches:
+- **CLAUDE.md files** - Project-specific context loaded recursively from working directory
+- **Structured guides** - Organized documentation by topic/category (if present)
+- **README/docs** - Traditional documentation files
 
-## Summary of Memory File Behavior
+Projects may use any combination of these systems or none at all.
 
-**Shared Project Memory (`CLAUDE.md`)**:
-- Located in the repository root or any working directory
-- Checked into version control for team-wide context sharing
-- Loaded recursively from the current directory up to the root
+---
+## Additional user's input
+Additional context/input from user: $ARGUMENTS. Might be empty by default.
+
+## When to Add Documentation
+
+**✅ DO add documentation when**:
+- You learned something **non-obvious** about the project
+- User corrected a **pattern or approach** you used
+- You struggled to find critical information that should be documented
+- You discovered an important **architectural decision** or **gotcha**
+- User provided context about "**why**" something is done a certain way
+- You had to infer important details that aren't clear from code alone
+- A pattern contradicts common conventions for this language/framework
+
+**❌ DON'T add documentation when**:
+- Information is **obvious from well-written code**
+- It's a **one-time fix** or edge case
+- It's **implementation details** that may change frequently
+- User just made a **typo correction** or minor fix
+- Information already exists in documentation
+- It's **standard practice** (not project-specific)
+
+**Rule of Thumb**: If you would struggle with this again in a future session without documentation, add it. If it's obvious or self-evident, skip it.
+
+---
+
+## Step 1: Identify What You Learned
+
+Reflect on the session:
+
+**Documentation Triggers**:
+- [ ] I was corrected on an implementation pattern
+- [ ] I learned about a project-specific convention
+- [ ] I discovered non-obvious behavior or gotcha
+- [ ] I struggled to locate important information
+- [ ] I learned architectural decisions or "why" behind choices
+- [ ] I found out about critical integration points
+- [ ] I discovered error handling or security patterns
+- [ ] I learned testing or tooling conventions
+- [ ] I discovered how components interact
+
+**What specifically did I learn?**
+- Specific pattern: _____
+- Why it matters: _____
+- Where it applies: _____
+
+---
+
+## Step 2: Determine Scope
+
+**Broad Knowledge** (affects multiple components or entire project):
+- Architectural patterns
+- Error handling conventions
+- Logging patterns
+- Security practices
+- Testing strategies
+- Code quality standards
+- Build/deployment processes
+
+→ Add to **project-wide documentation** (root CLAUDE.md, main docs, or broad guides)
+
+**Specific Knowledge** (affects one component/module):
+- Module-specific patterns
+- Component integration details
+- Directory-specific conventions
+- Local gotchas or behaviors
+
+→ Add to **component documentation** (component CLAUDE.md or specific doc section)
 
-**On-Demand Subdirectory Loading**:
-- `CLAUDE.md` files in child folders are loaded only when editing files in those subfolders
-- Prevents unnecessary context bloat
+---
+
+## Step 3: Find Documentation Location
+
+**Discover existing documentation**:
+```bash
+# Find CLAUDE.md files
+find . -name "CLAUDE.md" -not -path "*/node_modules/*" -not -path "*/.git/*"
+
+# Check for documentation directories
+ls -la docs/ documentation/ .claude/guides/ 2>/dev/null
+```
+
+**Decision Tree**:
 
-**Global User Memory (`~/.claude/CLAUDE.md`)**:
-- Acts as a personal, cross-project memory
-- Automatically merged into sessions under your home directory
+```
+Is knowledge broad/project-wide?
+├─ YES → Add to root documentation
+│   ├─ Root CLAUDE.md (if exists)
+│   ├─ README.md or ARCHITECTURE.md
+│   ├─ docs/ or documentation/ directory
+│   └─ Create root CLAUDE.md if none exists
+│
+└─ NO (component-specific) → Add to component documentation
+    ├─ Component CLAUDE.md (if exists)
+    ├─ Component README.md
+    └─ Create component CLAUDE.md if appropriate
+```
+
+**Common Patterns**:
+- **Root CLAUDE.md**: Project overview, architecture, main patterns
+- **Component CLAUDE.md**: `src/[module]/CLAUDE.md`, `lib/[feature]/CLAUDE.md`
+- **Structured docs**: `docs/architecture.md`, `docs/development.md`, etc.
+- **README files**: High-level overview, setup, common patterns
 
 ---
 
-## Instructions
+## Step 4: Format the Knowledge
+
+**For CLAUDE.md Files**:
+
+```markdown
+## [Topic Area or Module Name]
+
+**[Specific Pattern/Knowledge]**:
+- **What**: Brief description of the pattern/approach
+- **Why**: Reason or context for this decision
+- **Where**: Applicable locations or when to use it
+- **Gotcha**: Non-obvious behavior (if any)
 
-If during your session:
-* You learned something new about the project
-* I corrected you on a specific implementation detail
-* I corrected source code you generated
-* You struggled to find specific information and had to infer details about the project
-* You lost track of the project structure and had to look up information in the source code
+**Example** (if helpful):
+```[language]
+// Concise code example demonstrating pattern
+```
+```
+
+**For Structured Documentation**:
+
+```markdown
+## [Pattern/Topic Name]
+
+**Context**: When/why this pattern is used
+
+**Pattern**:
+[Description of the approach]
+
+**Example**:
+```[language]
+// Code example demonstrating pattern
+```
+
+**Rationale**: Why we do it this way
+
+**Common Pitfalls**: What to avoid
+```
+
+---
+
+## Step 5: Add the Documentation
+
+**For CLAUDE.md Files**:
+1. Open or create the appropriate CLAUDE.md file
+2. Find relevant section or create new heading
+3. Add knowledge in structured format
+4. Keep it concise and scannable
+5. Include example only if pattern isn't obvious
+
+**For Other Documentation**:
+1. Locate the appropriate file (README, ARCHITECTURE, etc.)
+2. Find relevant section or create one
+3. Add information following existing format/style
+4. Keep consistent with rest of document
+5. Update table of contents if applicable
+
+**Quality Checklist**:
+- [ ] Clearly states what the pattern/knowledge is
+- [ ] Explains why it matters (not just what)
+- [ ] Specific enough to be actionable
+- [ ] Concise (no unnecessary words)
+- [ ] Example included if pattern is non-obvious
+- [ ] Placed in most logical location
+- [ ] Doesn't duplicate existing documentation
+
+---
+
+## Step 6: Cross-Reference (if applicable)
+
+If knowledge spans multiple areas or files:
+
+**In CLAUDE.md**:
+```markdown
+**Related Documentation**:
+- See [ARCHITECTURE.md](./ARCHITECTURE.md) for system design
+- See [src/auth/CLAUDE.md](./src/auth/CLAUDE.md) for auth patterns
+```
+
+**In structured docs**:
+```markdown
+**See also**:
+- [Component Documentation](../component/CLAUDE.md)
+- [Related Guide](./related-guide.md)
+```
+
+---
+
+## Common Documentation Patterns
+
+**Architectural Decisions**:
+```markdown
+## Architecture
+
+**[Decision Name]**: We use [pattern/approach]
+- **Rationale**: [Why this choice was made]
+- **Trade-offs**: [What we gained/lost]
+- **Alternative considered**: [What we didn't choose and why]
+```
+
+**Error Handling**:
+```markdown
+## Error Handling
+
+- Use [specific error types/classes] for [scenario]
+- Always [pattern] when [condition]
+- Never [anti-pattern] because [reason]
+```
+
+**Testing Conventions**:
+```markdown
+## Testing
+
+- Test files: [location pattern]
+- Mocking: [approach and tools]
+- Coverage: [requirements]
+- Gotcha: [non-obvious testing behavior]
+```
+
+**Integration Points**:
+```markdown
+## [External Service/Component]
+
+- **Authentication**: [method]
+- **Configuration**: [where/how]
+- **Error handling**: [approach]
+- **Gotcha**: [non-obvious behavior]
+```
+
+---
+
+## Examples (Generic, adapt to your project)
+
+**Broad Pattern → Project Documentation**:
+```
+Learning: "Project uses custom error classes for each failure category"
+Location: Root CLAUDE.md or docs/development.md
+Section: Error Handling
+```
+
+**Component-Specific → Component Documentation**:
+```
+Learning: "Auth module requires initialization before any API calls"
+Location: src/auth/CLAUDE.md
+Section: Setup and Initialization
+```
+
+**Architectural → Architecture Documentation**:
+```
+Learning: "System uses event-driven architecture with message queue"
+Location: ARCHITECTURE.md or root CLAUDE.md
+Section: System Architecture
+```
+
+**Gotcha → Relevant Documentation**:
+```
+Learning: "Database connections must be manually closed in serverless"
+Location: src/database/CLAUDE.md or docs/database.md
+Section: Connection Management
+```
+
+---
+
+## Common Pitfalls to Avoid
+
+**❌ Don't**:
+- Document what's obvious from code
+- Add every minor detail or edge case
+- Duplicate information across multiple files
+- Include temporary workarounds or TODOs
+- Write exhaustive implementation details
+- Add information that changes frequently
+- Over-document standard language features
+
+**✅ Do**:
+- Focus on "why" and "gotchas"
+- Keep it concise and actionable
+- Place in most specific applicable location
+- Cross-reference related documentation
+- Update existing docs rather than creating new files
+- Validate information is still accurate before adding
+- Document decisions and trade-offs
+
+---
 
-...that is relevant, was not known initially, and should be persisted, add it to the appropriate `CLAUDE.md` file. If the information is relevant for a subdirectory only, place or update it in the `CLAUDE.md` file within that subdirectory.
+## Quick Decision Guide
 
-When specific information belongs to a particular subcomponent, ensure you place it in the CLAUDE file for that component.
+**Question Flow**:
+1. Is this **non-obvious** and **worth remembering**?
+   → NO: Skip
+2. Is it **broad/reusable** across components?
+   → YES: Add to project-wide docs
+3. Is it **component-specific**?
+   → YES: Add to component docs
+4. Does it **already exist** in documentation?
+   → YES: Update if outdated, skip if accurate
+5. Will I **struggle without** this in future sessions?
+   → YES: Add it / NO: Skip
 
-**For example (CodeMie CLI)**:
-* Information about agent plugins → `src/agents/CLAUDE.md`
-* Information about provider integration → `src/providers/CLAUDE.md`
-* Information about CLI commands → `src/cli/CLAUDE.md`
-* Information about analytics system → `src/analytics/CLAUDE.md`
-* Information about workflow management → `src/workflows/CLAUDE.md`
+**File Selection**:
+- **Project pattern** → Root CLAUDE.md, README, or main docs
+- **Component behavior** → Component CLAUDE.md or README
+- **Architecture** → ARCHITECTURE.md or root CLAUDE.md
+- **Setup/workflow** → README.md or CONTRIBUTING.md
+- **API patterns** → Relevant component or API docs
 
-This ensures important knowledge is retained and available in future sessions.
+**Remember**: Less documentation that's accurate and maintained is better than comprehensive documentation that becomes stale. Focus on capturing **critical, non-obvious knowledge** that helps future work.

package/dist/agents/plugins/claude/plugin/commands/memory-refresh.md

@@ -1,54 +1,233 @@
-# Refresh and Audit CLAUDE Memory Files
+# Refresh and Audit Project Documentation
 
-**Instructions:**
+**Purpose**: Verify and update project documentation to reflect current implementation.
 
-**Step 1: Get Overview**
+**CRITICAL**: Not every code change requires documentation updates. Only update documentation when:
+- Implementation patterns have actually changed
+- New architectural decisions were made
+- Critical information is missing or incorrect
+- Non-obvious behaviors have been introduced
 
-List all CLAUDE.md files in the project hierarchy and identify key directories that should have documentation.
+If documentation accurately reflects the current codebase, no changes are needed.
 
-Key directories to check:
-* Root directory → `CLAUDE.md`
-* Agent system → `src/agents/CLAUDE.md`
-* Provider system → `src/providers/CLAUDE.md`
-* CLI commands → `src/cli/CLAUDE.md`
-* Analytics system → `src/analytics/CLAUDE.md`
-* Workflow management → `src/workflows/CLAUDE.md`
 
-**Step 2: Iterative Review**
 
-Process each directory systematically, starting with the root `CLAUDE.md` file:
+## Additional user's input
+Additional context/input from user: $ARGUMENTS. Might be empty by default.
 
-**If CLAUDE.md exists:**
-- Load the current content
-- Compare documented patterns against actual implementation
-- Identify outdated, incorrect, or missing information
+## Step 1: Discover What Documentation Exists
 
-**If CLAUDE.md does NOT exist:**
-- Follow the memory-init process (see `.claude/commands/memory-init.md`):
-  1. Investigate architecture of the directory and subdirectories
-  2. Analyze design patterns, dependencies, abstractions, naming conventions
-  3. Create new CLAUDE.md file capturing this knowledge
+Identify documentation systems in this project:
 
-**Step 3: Update and Refactor**
+**A. Structured Guides** (if present):
+Common locations to check:
+- `docs/`, `.claude/guides/`, `.codemie/guides/`, `documentation/`
+- Look for topical organization (architecture, development, testing, etc.)
 
-For each memory file (existing or newly created):
-- Verify all technical claims against the current codebase
-- Remove obsolete information
-- Consolidate duplicate entries
-- Ensure information is in the most appropriate file
+**B. CLAUDE.md Files** (if present):
+- Root `CLAUDE.md` (project overview)
+- Component-specific `CLAUDE.md` in subdirectories
+- Common in: `src/`, `lib/`, feature directories
 
-When information belongs to a specific subcomponent, ensure it's placed correctly:
-* Agent-specific patterns → `src/agents/CLAUDE.md`
-* Provider integration details → `src/providers/CLAUDE.md`
-* CLI command patterns → `src/cli/CLAUDE.md`
-* Analytics system details → `src/analytics/CLAUDE.md`
-* Workflow management patterns → `src/workflows/CLAUDE.md`
+**C. Other Documentation**:
+- `README.md`, `CONTRIBUTING.md`, `ARCHITECTURE.md`
+- Wiki, Confluence, or external docs (mentioned in README)
 
-**Documentation Content Guidelines (applies to both new and refreshed files):**
-- Purpose and responsibility of this module
+**Note**: Projects may have any combination of these, or none at all.
+
+---
+
+## Step 2: Review Recent Changes
+
+Before reviewing documentation, understand what changed:
+
+1. **Check recent commits**: `git log --oneline -10`
+2. **Check current changes**: `git status` and `git diff`
+3. **Identify impact areas**:
+   - Did architectural patterns change?
+   - Were new components/modules added?
+   - Did core approaches evolve (error handling, testing, etc.)?
+   - Were security practices updated?
+   - Did integrations or APIs change?
+
+**Decision Point**: If changes are minor (bug fixes, typos, small refactors), documentation likely doesn't need updates. Only proceed if changes affect patterns, architecture, or critical knowledge.
+
+---
+
+## Step 3: Audit Structured Guides (if present)
+
+For each guide/doc file that exists:
+
+**Review Process**:
+1. Load the content
+2. Compare documented patterns against actual implementation
+3. Check if described approaches still match the codebase
+4. Identify outdated, incorrect, or missing information
+
+**Update Only If**:
+- [ ] Pattern described no longer matches implementation
+- [ ] New pattern emerged that should be documented
+- [ ] Critical information is missing or incorrect
+- [ ] Examples reference deleted/renamed code
+- [ ] Security or architectural decisions changed
+
+**Common Documentation Topics** (adapt to your project):
+- Architecture and system design
+- Error handling and logging patterns
+- Testing strategies and setup
+- Security practices
+- API patterns and conventions
+- Database/data patterns
+- Development workflow
+- Deployment and operations
+
+---
+
+## Step 4: Audit CLAUDE.md Files (if present)
+
+For each CLAUDE.md file:
+
+**Find CLAUDE.md Files**:
+```bash
+find . -name "CLAUDE.md" -not -path "*/node_modules/*" -not -path "*/.git/*"
+```
+
+**Review Process**:
+1. Load current content
+2. Compare against actual implementation in that directory
+3. Check if file structure/organization changed
+4. Identify outdated, incorrect, or missing information
+
+**Update Only If**:
+- [ ] Module purpose or responsibility changed
+- [ ] Key architectural decisions evolved
+- [ ] Important implementation details missing
+- [ ] Documented patterns no longer used
+- [ ] New gotchas or non-obvious behaviors introduced
+
+**Typical CLAUDE.md Content** (adapt to project style):
+- Purpose and responsibility of module
 - Key architectural decisions
 - Important implementation details
-- Common patterns used throughout the code
-- Any gotchas or non-obvious behaviors
+- Common patterns used
+- Non-obvious behaviors or gotchas
+- Integration points with other modules
+
+---
+
+## Step 5: Determine What Needs Updating
+
+Categorize findings:
+
+**Definitely Update**:
+- Documented pattern now incorrect
+- Missing critical information for understanding
+- Security or architectural approach changed
+- Examples reference non-existent code
+- Misleading or confusing content
+
+**Probably Update**:
+- New project-wide pattern should be documented
+- Testing strategy evolved
+- Integration points changed
+- Important context missing
+
+**No Update Needed**:
+- Bug fixes that don't affect patterns
+- Code refactoring maintaining same approach
+- Typo fixes or variable renames
+- Documentation already accurate
+- Changes are self-evident from code
+
+---
+
+## Step 6: Execute Selective Updates
+
+Only modify files where changes are actually needed:
+
+**For Structured Guides**:
+1. Edit specific sections that are outdated
+2. Update code examples if references changed
+3. Add new patterns only if broadly applicable
+4. Remove obsolete information
+5. Keep content focused and concise
+
+**For CLAUDE.md Files**:
+1. Verify technical claims against current code
+2. Update specific sections that changed
+3. Add new critical information
+4. Remove obsolete patterns
+5. Ensure info is in most appropriate file
+
+**Content Placement**:
+- **Broad patterns** (used across project) → Root docs or main CLAUDE.md
+- **Component-specific** (local to one area) → Component CLAUDE.md or specific guide section
+- **Project-wide conventions** → Root README or CLAUDE.md
+- **Module implementation details** → Module-level CLAUDE.md
+
+---
+
+## Step 7: Validate Changes
+
+Before finalizing:
+
+**Accuracy Check**:
+- [ ] All technical claims verified against current code
+- [ ] Examples reference existing files/functions
+- [ ] Patterns match actual implementation
+- [ ] No contradictions between different docs
+
+**Relevance Check**:
+- [ ] Information is actionable
+- [ ] Content helps future understanding
+- [ ] No duplicate information across files
+- [ ] No obsolete references
+
+**Quality Check**:
+- [ ] Clear and concise language
+- [ ] Examples are accurate
+- [ ] Proper markdown formatting
+- [ ] Links work (if any)
+
+---
+
+## Key Principles
+
+**Accuracy Over Completeness**:
+- Better to have less documentation that's accurate
+- Don't document what's obvious from well-written code
+- Focus on "why" and "gotchas", not "what" (code shows "what")
+
+**Selective Updates**:
+- Not every commit requires documentation changes
+- Only update when patterns or understanding actually shifts
+- If in doubt, verify against actual implementation
+
+**Appropriate Placement**:
+- Put information where it's most useful
+- Avoid duplication across files
+- Component-specific → component docs
+- Project-wide → root docs
+
+**Maintainability**:
+- Keep documentation focused
+- Remove outdated content promptly
+- Cross-reference related docs
+- Use examples sparingly but effectively
+
+---
+
+## Decision Checklist
+
+Before making changes, ask:
+
+1. **Is this change needed?** (Does doc mismatch implementation?)
+2. **Is it significant?** (Will this help future understanding?)
+3. **Where should it go?** (Most specific applicable location)
+4. **What's the scope?** (Component-specific or project-wide?)
+5. **Is it accurate?** (Verified against current code?)
+6. **Is it clear?** (Would someone else understand this?)
+
+**If unsure**: Verify implementation first, then update documentation.
 
-Focus on clarity, accuracy, and relevance. Remove any information that no longer serves the project.
+**Remember**: Documentation serves the code, not vice versa. Focus on critical, non-obvious knowledge that helps future work.

package/dist/agents/plugins/gemini/gemini.plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gemini.plugin.d.ts","sourceRoot":"","sources":["../../../../src/agents/plugins/gemini/gemini.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAGlE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAE/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gDAAgD,CAAC;AAoF7F;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,aA2ClC,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;IAChD,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,kBAAkB,CAAyB;;IAYnD;;;OAGG;IACH,kBAAkB,IAAI,eAAe;IAIrC;;OAEG;IACH,iBAAiB,IAAI,cAAc;IAInC;;;OAGG;IACH,qBAAqB,IAAI,sBAAsB;CAGhD"}
+{"version":3,"file":"gemini.plugin.d.ts","sourceRoot":"","sources":["../../../../src/agents/plugins/gemini/gemini.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAGlE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAE/E,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,gDAAgD,CAAC;AAoF7F;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,aAwClC,CAAC;AAEF;;GAEG;AACH,qBAAa,YAAa,SAAQ,gBAAgB;IAChD,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,kBAAkB,CAAyB;;IAYnD;;;OAGG;IACH,kBAAkB,IAAI,eAAe;IAIrC;;OAEG;IACH,iBAAiB,IAAI,cAAc;IAInC;;;OAGG;IACH,qBAAqB,IAAI,sBAAsB;CAGhD"}

package/dist/agents/plugins/gemini/gemini.plugin.js

@@ -102,9 +102,6 @@ export const GeminiPluginMetadata = {
                 },
                 tools: {
                     enableHooks: true
-                },
-                hooks: {
-                    enabled: true
                 }
             });
             return env;

package/dist/agents/plugins/gemini/gemini.plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"gemini.plugin.js","sourceRoot":"","sources":["../../../../src/agents/plugins/gemini/gemini.plugin.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"gemini.plugin.js","sourceRoot":"","sources":["../../../../src/agents/plugins/gemini/gemini.plugin.ts"],"names":[],"mappings":"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"}

package/dist/agents/plugins/opencode/index.d.ts

@@ -0,0 +1,8 @@
+export { OpenCodePlugin, OpenCodePluginMetadata } from './opencode.plugin.js';
+export { OPENCODE_MODEL_CONFIGS, getModelConfig, type OpenCodeModelConfig } from './opencode-model-configs.js';
+export { OpenCodeSessionAdapter } from './opencode.session.js';
+export { getOpenCodeStoragePath, getOpenCodeSessionsPath, getOpenCodeMessagesPath, getOpenCodePartsPath, getSessionStoragePath } from './opencode.paths.js';
+export type { OpenCodeSession, OpenCodeMessage, OpenCodePart, OpenCodeTokens } from './opencode-message-types.js';
+export { isTextPart, isToolPart, isFilePart, isReasoningPart, isStepFinishPart, isAssistantMessage } from './opencode-message-types.js';
+export type { SessionDiscoveryOptions, SessionDescriptor } from '../../core/session/discovery-types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/agents/plugins/opencode/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/agents/plugins/opencode/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,KAAK,mBAAmB,EACzB,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAE/D,OAAO,EACL,sBAAsB,EACtB,uBAAuB,EACvB,uBAAuB,EACvB,oBAAoB,EAEpB,qBAAqB,EACtB,MAAM,qBAAqB,CAAC;AAE7B,YAAY,EACV,eAAe,EACf,eAAe,EACf,YAAY,EACZ,cAAc,EACf,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,UAAU,EACV,UAAU,EACV,UAAU,EACV,eAAe,EACf,gBAAgB,EAChB,kBAAkB,EACnB,MAAM,6BAA6B,CAAC;AAErC,YAAY,EACV,uBAAuB,EACvB,iBAAiB,EAClB,MAAM,uCAAuC,CAAC"}