@dex-ai/coding-extensions 0.2.4

package/skills/git-workflow/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: git-workflow
+description: Multi-repository git coordination — coordinated commits, branch management, version bumps, and release workflows across workspace repos.
+---
+
+## What I do
+
+- Coordinate git operations across multiple repositories in a workspace
+- Manage version bumps and package publishing sequences
+- Handle branch creation, commits, and merges across repos
+- Ensure dependency ordering for cross-repo changes
+- Guide release workflows with proper verification
+
+## When to use me
+
+Use this skill when:
+- Making changes that span multiple repositories
+- Performing version bumps across interdependent packages
+- Publishing packages to a registry (Verdaccio, npm)
+- Creating coordinated branches or PRs across repos
+- Needing to understand dependency order for changes
+
+## Core Principles
+
+### Dependency Order Matters
+
+When making cross-repo changes, work bottom-up through the dependency graph:
+1. SDK/core packages first (they have no internal deps)
+2. Mid-level packages that depend on SDK
+3. Top-level packages (CLI, agent) last
+
+### Atomic Logical Units
+
+Each commit should be a logical unit of work. For cross-repo changes:
+- Each repo gets its own commit(s)
+- Commits should reference the same feature/fix
+- The workspace should be buildable after each repo's commit
+
+### Verify Before Commit
+
+Always verify before committing:
+- `bun run typecheck` passes
+- `bun run test` passes (or at least no regressions)
+- Build succeeds if applicable
+
+---
+
+## Patterns
+
+### Coordinated Cross-Repo Change
+
+When a change touches multiple repos (e.g., adding a new SDK export used by CLI):
+
+```bash
+# 1. Make SDK change
+cd dex-ai-sdk
+# ... make changes ...
+bun run typecheck && bun run test
+git add -A && git commit -m "feat: add new export"
+
+# 2. Publish SDK (if using Verdaccio)
+bun publish --registry http://localhost:4873
+
+# 3. Update consumer
+cd ../dex-ai-coding-agent
+bun install  # picks up new SDK version
+# ... make changes using new export ...
+bun run typecheck && bun run test
+git add -A && git commit -m "feat: use new SDK export"
+```
+
+### Version Bump Workflow
+
+For bumping versions across the workspace:
+
+```bash
+# 1. Determine bump type (patch/minor/major)
+# 2. Bump in dependency order:
+
+# Core SDK
+cd dex-ai-sdk
+# bump version in package.json
+git add -A && git commit -m "chore: bump to X.Y.Z"
+bun publish --registry http://localhost:4873
+
+# Each dependent package
+cd ../dex-ai-providers
+# bump version, update @dex-ai/sdk dep version
+git add -A && git commit -m "chore: bump to X.Y.Z"
+bun publish --registry http://localhost:4873
+
+# ... continue up the dependency tree
+```
+
+### Feature Branch Across Repos
+
+```bash
+BRANCH="feat/my-feature"
+
+# Create branch in all affected repos
+for repo in dex-ai-sdk dex-ai-providers dex-ai-coding-agent; do
+  cd /path/to/$repo
+  git checkout -b $BRANCH
+done
+
+# Work on changes, commit in each repo
+# When done, merge in dependency order (SDK first)
+```
+
+### Quick Status Check
+
+```bash
+# Check status across all repos
+for dir in /path/to/workspace/dex-ai-*/; do
+  echo "=== $(basename $dir) ==="
+  cd "$dir"
+  git status --short
+  echo
+done
+```
+
+---
+
+## Commit Message Convention
+
+Use conventional commits:
+- `feat:` — New feature
+- `fix:` — Bug fix
+- `chore:` — Maintenance (version bumps, deps)
+- `docs:` — Documentation only
+- `refactor:` — Code restructuring without behavior change
+- `test:` — Adding or updating tests
+
+Keep messages concise. Reference related repos when relevant:
+```
+feat: add streaming support
+
+Required by dex-ai-coding-agent for real-time output.
+```
+
+---
+
+## Safety Rules
+
+- **Never force push** to main/master without explicit user approval
+- **Never rebase shared branches** without confirmation
+- **Always check `git status`** before committing to avoid unintended files
+- **Verify builds pass** before pushing
+- **Use `git diff --stat`** to review what's changing before commit
+
+## Dependency Graph (Dex Project)
+
+```
+dex-ai-sdk (base — no internal deps)
+├── dex-ai-providers
+├── dex-ai-context
+├── dex-ai-memory
+├── dex-ai-knowledge
+├── dex-ai-mcp
+├── dex-ai-devtools
+├── dex-ai-core-extensions
+├── dex-ai-coding-extensions
+├── dex-pi-compat
+├── dex-ai-vue-tui-markdown
+├── dex-ai-vue-tui
+└── dex-ai-coding-agent (top — depends on most others)
+```

package/skills/retrospective/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: retrospective
+description: Performs a post-session retrospective to extract learnings into Dex's persistent memory. Stores facts, updates procedures, and removes stale knowledge. Focused on information that can't be discovered or inferred from the codebase.
+---
+
+## What I do
+
+- Analyze the completed conversation to extract actionable learnings
+- Store durable knowledge as **facts** via `memory_remember_fact`
+- Create/update **procedures** via `memory_store_procedure` for reusable workflows
+- Remove stale facts via `memory_forget_fact`
+- Filter out anything discoverable from the codebase or inferrable from context
+
+## When to use me
+
+Use this skill when:
+- A significant task or feature has been completed
+- The user asks for a retrospective
+- Multiple decisions were made that could inform future work
+- User preferences or patterns were revealed through interaction
+- At the end of a work session to capture learnings
+
+## Core Principles
+
+### Only What I Can't Discover
+
+If I can find it by reading code, exploring the filesystem, or inferring from context — DO NOT capture it. Only capture things that:
+- Were explicitly stated by the user as a preference
+- Were decided through conversation (not obvious from context)
+- Represent a pattern that repeated across the session
+- Would save time or prevent mistakes in future sessions
+
+### Specific Over General
+
+Bad: "The user prefers clean code"
+Good: "The user rejects emoji in code files and comments"
+
+Bad: "The project uses TypeScript"
+Good: "The user wants snake_case for database columns but camelCase everywhere else"
+
+### Actionable & Atomic
+
+Each fact should be a single, specific claim. Each procedure should be a concrete, repeatable workflow.
+
+---
+
+## Retrospective Workflow
+
+### Step 1: Analyze the Conversation
+
+Review the entire session and identify:
+
+**User Preferences** — Things the user told me about how they want me to behave:
+- Communication style preferences
+- Code style preferences not enforced by tooling
+- Workflow preferences (e.g., "always ask before committing")
+- Things they corrected me on (patterns to avoid)
+- Things they praised (patterns to repeat)
+
+**Project Learnings** — Things about THIS project not obvious from code:
+- Architectural decisions explained by the user
+- Historical context ("we used to do X but switched to Y because...")
+- Team conventions not yet codified
+- Known issues or gotchas mentioned
+- Preferred patterns for new code
+
+**Workflow Patterns** — Multi-step processes discovered or taught:
+- Build/deploy sequences
+- Testing workflows
+- Release processes
+- Debugging approaches that worked
+
+**Skill Feedback** — How well did active skills perform:
+- What was missing or unclear
+- What I had to figure out that a skill should have told me
+- Steps that were awkward or could be streamlined
+
+### Step 2: Filter
+
+For each potential learning, ask:
+
+1. **Can I discover this from the codebase?** → Discard
+2. **Can I infer this from context?** → Discard
+3. **Is this specific and actionable?** → If no, discard
+4. **Will this help me in future sessions?** → If no, discard
+
+### Step 3: Execute Memory Operations
+
+#### Facts (via `memory_remember_fact`)
+
+For user preferences and project learnings:
+
+```
+Subject: "user" or project/package name
+Predicate: concise relationship (e.g., "prefers", "requires", "avoids")
+Object: the specific value
+```
+
+Examples:
+- `("user", "prefers", "concise responses without explanations unless asked")`
+- `("user", "commit-style", "imperative mood, no emoji, reference issue numbers")`
+- `("dex-ai-sdk", "testing-pattern", "vitest with happy-dom, mock external deps")`
+- `("project", "deploy-requires", "version bump → verdaccio publish → CLI rebuild")`
+
+#### Procedures (via `memory_store_procedure`)
+
+For multi-step workflows discovered or taught:
+
+```
+Title: descriptive action phrase
+Body: step-by-step markdown with exact commands/paths
+Tags: relevant categories
+```
+
+Examples:
+- Title: "Publishing a new package version"
+- Title: "Debugging TUI rendering issues"
+- Title: "Adding a new extension to the CLI"
+
+#### Removals (via `memory_forget_fact`)
+
+For stale or incorrect facts discovered during the session:
+- Facts contradicted by new information
+- Facts about things that no longer exist
+- Facts the user explicitly corrected
+
+### Step 4: Present Summary
+
+Format the output as:
+
+```markdown
+# Retrospective Summary
+
+## Facts Stored
+| Subject | Predicate | Object | Source |
+|---------|-----------|--------|--------|
+| ... | ... | ... | [What prompted this] |
+
+## Facts Removed
+| Subject | Predicate | Reason |
+|---------|-----------|--------|
+| ... | ... | [Why removed] |
+
+## Procedures Stored/Updated
+| Title | Tags | Summary |
+|-------|------|---------|
+| ... | ... | [Brief description] |
+
+## Discarded (Discoverable/Inferrable)
+- [Things considered but rejected]
+
+## Skill Improvement Notes
+- [Observations about skill performance for future updates]
+```
+
+---
+
+## Filtering Heuristics
+
+### DISCARD — Discoverable from codebase:
+- Programming language, framework, dependencies
+- File structure and organization
+- Naming conventions visible in existing code
+- Test framework from config files
+- Lint rules, build scripts, TypeScript config
+- Any pattern that appears in existing code
+
+### DISCARD — Inferrable from context:
+- Monorepo structure (if packages/ exists)
+- TypeScript usage (if .ts files exist)
+- General coding best practices
+
+### KEEP — Not discoverable:
+- "I prefer X over Y even though Y is more common"
+- "We tried X before and it didn't work because [context]"
+- "Always do X when Y" (explicit instruction)
+- "Don't do X" (explicit prohibition)
+- Historical context and reasoning
+- Corrections to my behavior
+- Workflow preferences
+
+---
+
+## Quality Checks
+
+Before executing memory operations:
+
+- [ ] Every fact is specific and atomic (one claim per fact)
+- [ ] No fact is discoverable from the codebase
+- [ ] No fact is inferrable from context
+- [ ] Each fact has a clear source from the conversation
+- [ ] Procedures have exact commands/paths, not vague steps
+- [ ] Existing facts checked — update rather than duplicate
+- [ ] Stale facts identified for removal

package/skills/skill-creator/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: skill-creator
+description: Expert at creating, updating, and managing Dex skills (SKILL.md files and extension-based skills) with proper structure, naming, and best practices.
+---
+
+## What I do
+
+- Create well-structured Dex skills with proper YAML frontmatter and markdown content
+- Update existing skills while preserving conventions
+- Validate skill structure and naming
+- Create both file-based skills (~/.dex/skills/) and extension-based skills
+- Advise on skill design, scope, and reusability
+
+## When to use me
+
+Use this skill when:
+- Creating a new Dex skill
+- Updating or refactoring an existing skill
+- Validating skill structure
+- Learning best practices for skill design
+
+## Skill Locations
+
+### File-based skills (user-defined)
+```
+~/.dex/skills/<skill-name>/SKILL.md
+```
+
+### Extension-based skills (bundled)
+```typescript
+// In an extension package
+export function myExtension(): Extension {
+  return {
+    name: "my-extension",
+    skills: [{
+      name: "my-skill",
+      description: "What it does",
+      content: "## Markdown content...",
+    }],
+  };
+}
+```
+
+### Project-scoped skills
+```
+<project>/.dex/skills/<skill-name>/SKILL.md
+```
+
+## Directory Layout
+
+A file-based skill directory:
+```
+my-skill/
+├── SKILL.md           # Required entrypoint
+├── reference.md       # Optional: loaded on demand via get_skill
+├── examples/
+│   └── sample.md
+└── scripts/
+    └── helper.sh
+```
+
+## Naming Rules
+
+Skill names MUST:
+- Be 1-64 characters
+- Be lowercase alphanumeric with single hyphen separators
+- Not start or end with `-`
+- Not contain consecutive `--`
+- Match regex: `^[a-z0-9]+(-[a-z0-9]+)*$`
+
+Valid: `git-release`, `code-review`, `api-docs`, `test-helper`
+Invalid: `GitRelease`, `api_docs`, `-test`, `my--skill`
+
+## Frontmatter
+
+Every SKILL.md starts with YAML frontmatter:
+
+```yaml
+---
+name: <skill-name>           # Optional, overrides directory name
+description: <1-1536 chars>  # Strongly recommended, used for catalog/auto-invocation
+---
+```
+
+The `description` is what Dex uses in the "Available Skills" catalog listing. Make it specific enough to trigger on the right tasks but not so narrow it never activates.
+
+## Content Structure
+
+After frontmatter, structure with clear sections:
+
+1. **What I do** — Bullet list of capabilities
+2. **When to use me** — Trigger conditions and use cases
+3. **Core Principles** — Key rules and guidelines
+4. **Step-by-step workflows** — Numbered procedures
+5. **Templates** — Output format templates if applicable
+6. **Exit Criteria** — How to know when done
+
+## Creation Workflow
+
+### Step 1: Define the skill
+- What problem does this skill solve?
+- When should the agent use it?
+- What are the key steps or rules?
+- What tools does it leverage?
+
+### Step 2: Choose a name
+- Concise and descriptive
+- Follows naming rules
+- Doesn't conflict with existing skills
+
+### Step 3: Write the description
+- 1-1536 characters
+- Front-loads the key use case
+- Specific enough to avoid false matches
+- Mentions key actions/outputs
+
+### Step 4: Write the content
+- Clear, actionable instructions
+- Use markdown headers for structure
+- Include templates/examples
+- Reference specific Dex tools by name
+- Add exit criteria
+
+### Step 5: Create the file
+For file-based: `~/.dex/skills/<name>/SKILL.md`
+For extension-based: create a package under `skills/` with `src/index.ts`
+
+### Step 6: Validate
+- [ ] SKILL.md exists (ALL CAPS filename)
+- [ ] Frontmatter has at minimum a `description`
+- [ ] Name passes validation regex
+- [ ] Description is 1-1536 characters
+- [ ] Content is clear and actionable
+- [ ] References valid tool names
+
+## Best Practices
+
+- Keep skills focused on a single domain or workflow
+- Use bullet points and numbered lists for clarity
+- Include examples whenever possible
+- Reference specific Dex tools (`memory_remember_fact`, `ast_grep_search`, `lsp_diagnostics`, etc.)
+- Keep descriptions specific but not overly narrow
+- Include exit criteria so the agent knows when it's done
+- For complex skills, use phases with clear gates between them
+- Avoid duplicating information the agent already has in its system prompt