solvdex 1.0.0

package/skills/wiki-fix/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: wiki-fix
+description: Update a flagged Solvdex wiki entry. Reviews current content, updates with new solution, and resets status to active.
+argument-hint: <entry-path>
+user-invocable: true
+disable-model-invocation: true
+---
+
+# Fix Solvdex Entry
+
+Update a flagged entry and reset its status to active.
+
+## Process
+
+1. Read the flagged entry
+2. Show current content and issues
+3. Update content based on conversation
+4. Reset status to 'active'
+5. Increase confidence if solution verified
+
+## Implementation
+
+```typescript
+import { readEntry, updateEntry, wikiExists, validateEntry, CONFIDENCE } from 'solvdex';
+
+const projectRoot = process.cwd();
+const entryPath = $ARGUMENTS.trim();
+
+if (!wikiExists(projectRoot)) {
+  console.log('No wiki found.');
+  return;
+}
+
+const entry = readEntry(projectRoot, entryPath);
+if (!entry) {
+  console.log(`Entry not found: ${entryPath}`);
+  return;
+}
+
+const issues = validateEntry(projectRoot, entryPath);
+
+console.log(`# Fixing: ${entry.frontmatter.title}`);
+console.log(`Status: ${entry.frontmatter.status}`);
+console.log(`Confidence: ${entry.frontmatter.confidence}`);
+console.log('');
+
+if (issues.length > 0) {
+  console.log('Issues to address:');
+  for (const issue of issues) {
+    console.log(`  - [${issue.type}] ${issue.message}`);
+  }
+}
+
+console.log('');
+console.log('Current content:');
+console.log(entry.content);
+console.log('');
+console.log('Please provide the updated content, then I will:');
+console.log('  - Save the changes');
+console.log('  - Reset status to active');
+console.log('  - Increase confidence to 50+ if verified');
+```
+
+## Output
+
+```
+# Fixing: Database Connection Timeout
+
+Status: flagged
+Confidence: 50
+
+Issues to address:
+  - [outdated] Solution references deprecated API
+
+Current content:
+# Problem
+Database connections time out after 30 seconds.
+
+# Solution
+Increase the pool timeout in config.
+
+Please provide the updated content, then I will:
+  - Save the changes
+  - Reset status to active
+  - Increase confidence to 50+ if verified
+```

package/skills/wiki-flag/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: wiki-flag
+description: Mark a Solvdex wiki entry for review. Use when a solution is outdated or needs verification.
+argument-hint: <entry-path> [reason]
+user-invocable: true
+disable-model-invocation: true
+---
+
+# Flag Solvdex Entry
+
+Mark an entry as needing review.
+
+## Implementation
+
+```typescript
+import { flagEntry, readEntry, wikiExists } from 'solvdex';
+
+const projectRoot = process.cwd();
+const [entryPath, ...reasonParts] = $ARGUMENTS.split(' ');
+const reason = reasonParts.join(' ') || 'Flagged for review';
+
+if (!wikiExists(projectRoot)) {
+  console.log('No wiki found.');
+  return;
+}
+
+const entry = readEntry(projectRoot, entryPath);
+if (!entry) {
+  console.log(`Entry not found: ${entryPath}`);
+  return;
+}
+
+flagEntry(projectRoot, entryPath, reason);
+console.log(`Flagged: ${entry.frontmatter.title}`);
+console.log(`Reason: ${reason}`);
+console.log('');
+console.log('Use `/wiki fix` to update this entry.');
+```
+
+## Output
+
+```
+Flagged: Database Connection Timeout
+Reason: Solution no longer works with new DB version
+
+Use `/wiki fix` to update this entry.
+```

package/skills/wiki-import/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: wiki-import
+description: Import Solvdex wiki entries from an export file.
+argument-hint: <input-file> [--overwrite] [--skip-duplicates] [--dry-run]
+user-invocable: true
+disable-model-invocation: true
+---
+
+# Solvdex Import
+
+Import wiki entries from a previously exported JSON file.
+
+## Arguments
+
+- `input-file`: Path to the export JSON file (required)
+
+## Options
+
+- `--overwrite`: Overwrite existing entries with same path
+- `--skip-duplicates`: Skip entries that already exist
+- `--dry-run`: Show what would be imported without making changes
+
+## Implementation
+
+```typescript
+import { wikiExists, importWikiFromFile, initWiki } from 'solvdex';
+import * as path from 'path';
+import * as fs from 'fs';
+
+const projectRoot = process.cwd();
+const args = $ARGUMENTS.split(' ').filter(Boolean);
+
+// Parse args
+const inputFile = args.find(a => !a.startsWith('--'));
+const overwrite = args.includes('--overwrite');
+const skipDuplicates = args.includes('--skip-duplicates');
+const dryRun = args.includes('--dry-run');
+
+if (!inputFile) {
+  console.log('Usage: /wiki import <input-file> [options]');
+  console.log('');
+  console.log('Options:');
+  console.log('  --overwrite        Overwrite existing entries');
+  console.log('  --skip-duplicates  Skip entries that already exist');
+  console.log('  --dry-run          Preview without making changes');
+  return;
+}
+
+const inputPath = path.isAbsolute(inputFile)
+  ? inputFile
+  : path.join(projectRoot, inputFile);
+
+if (!fs.existsSync(inputPath)) {
+  console.log(`File not found: ${inputPath}`);
+  return;
+}
+
+console.log('# Solvdex Import\n');
+console.log(`Source: ${inputPath}`);
+console.log(`Mode: ${dryRun ? 'DRY RUN' : 'LIVE'}`);
+console.log('');
+
+try {
+  const result = await importWikiFromFile(projectRoot, inputPath, {
+    overwrite,
+    skipDuplicates,
+    dryRun
+  });
+
+  console.log('## Results');
+  console.log(`  Imported: ${result.imported}`);
+  console.log(`  Skipped: ${result.skipped}`);
+
+  if (result.errors.length > 0) {
+    console.log(`  Errors: ${result.errors.length}`);
+    console.log('');
+    console.log('### Errors');
+    for (const err of result.errors) {
+      console.log(`  - ${err.path}: ${err.error}`);
+    }
+  }
+
+  if (dryRun) {
+    console.log('\nThis was a dry run. No changes were made.');
+    console.log('Remove --dry-run to perform the actual import.');
+  } else {
+    console.log('\nImport complete!');
+  }
+} catch (error) {
+  console.error(`Import failed: ${error.message}`);
+}
+```
+
+## Output
+
+```
+# Solvdex Import
+
+Source: /path/to/wiki-export.json
+Mode: LIVE
+
+## Results
+  Imported: 15
+  Skipped: 2
+  Errors: 1
+
+### Errors
+  - patterns/old-pattern.md: Entry already exists (use overwrite option)
+
+Import complete!
+```
+
+## Dry Run Example
+
+```
+# Solvdex Import
+
+Source: /path/to/wiki-export.json
+Mode: DRY RUN
+
+## Results
+  Imported: 15
+  Skipped: 2
+  Errors: 0
+
+This was a dry run. No changes were made.
+Remove --dry-run to perform the actual import.
+```

package/skills/wiki-init/SKILL.md

@@ -0,0 +1,72 @@
+---
+name: wiki-init
+description: Initialize Solvdex wiki in the current project. Creates .wiki/ directory with 7 categories for storing project knowledge.
+user-invocable: true
+disable-model-invocation: true
+---
+
+# Initialize Solvdex Wiki
+
+Create a `.wiki/` directory structure in the current project with all 7 categories.
+
+## Process
+
+1. Check if `.wiki/` already exists
+2. Detect project name from `package.json` or directory name
+3. Create directory structure:
+   ```
+   .wiki/
+   ├── README.md
+   ├── issues/
+   ├── patterns/
+   ├── gotchas/
+   ├── testing/
+   ├── docs/
+   ├── security/
+   └── performance/
+   ```
+4. Show success message
+
+## Implementation
+
+Use the `initWiki()` function from the solvdex core library:
+
+```typescript
+import { initWiki, wikiExists } from 'solvdex';
+
+const projectRoot = process.cwd();
+
+if (wikiExists(projectRoot)) {
+  console.log('Solvdex wiki already exists at .wiki/');
+  console.log('Run `/wiki status` to see current state.');
+} else {
+  await initWiki(projectRoot);
+  console.log('Solvdex wiki initialized at .wiki/');
+  console.log('');
+  console.log('Next steps:');
+  console.log('  /wiki scan    - Import knowledge from existing project');
+  console.log('  /wiki add     - Manually add an entry');
+  console.log('  /wiki browse  - View all entries');
+}
+```
+
+## Output
+
+```
+Solvdex wiki initialized at .wiki/
+
+Created:
+  - issues/       (bug fixes, error solutions)
+  - patterns/     (reusable code patterns)
+  - gotchas/      (pitfalls, traps)
+  - testing/      (test strategies, mocks)
+  - docs/         (documentation templates)
+  - security/     (auth, vulnerabilities)
+  - performance/  (optimizations, profiling)
+  - README.md
+
+Next steps:
+  /wiki scan    - Import knowledge from existing project
+  /wiki add     - Manually add an entry
+  /wiki browse  - View all entries
+```

package/skills/wiki-scan/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: wiki-scan
+description: Scan project and create Solvdex stub entries from existing knowledge sources like git history, comments, and documentation.
+argument-hint: [--batch] [--auto]
+user-invocable: true
+disable-model-invocation: false
+---
+
+# Scan Project for Solvdex
+
+Analyze project and generate wiki stub entries from existing knowledge sources.
+
+## Sources Scanned
+
+| Source | Extracts | Category |
+|--------|----------|----------|
+| CLAUDE.md | Instructions, rules | patterns, gotchas |
+| docs/ | Documentation | docs, patterns |
+| Git history | Fix/refactor commits | issues, patterns |
+| Code comments | HACK, WORKAROUND, TODO | gotchas, issues |
+| README.md | Setup instructions | patterns, docs |
+| Config files | .env.example, docker-compose | gotchas, security |
+| Test files | Test patterns, mocks | testing |
+| Security configs | Auth, permissions | security |
+| Performance code | Optimizations, caching | performance |
+
+## Modes
+
+- **Interactive (default):** Review each entry one by one
+- **Batch (--batch):** Show all, approve/reject in bulk
+- **Auto (--auto):** Accept all stubs automatically
+
+## Implementation
+
+```typescript
+import { wikiExists, createEntry, CONFIDENCE } from 'solvdex';
+
+const projectRoot = process.cwd();
+
+if (!wikiExists(projectRoot)) {
+  console.log('No wiki found. Run `/wiki init` first.');
+  return;
+}
+
+console.log('Scanning project...');
+
+// Scan sources and extract candidates
+const candidates = scanProjectSources(projectRoot);
+
+console.log(`Found ${candidates.length} potential entries.`);
+console.log('');
+
+if ($ARGUMENTS.includes('--auto')) {
+  // Auto-accept all
+  for (const candidate of candidates) {
+    const entry = createEntry(projectRoot, {
+      category: candidate.category,
+      title: candidate.title,
+      tags: candidate.tags,
+      content: { Problem: '<!-- TODO -->' },
+      stub: true,
+      confidence: CONFIDENCE.LOW,
+      source: candidate.source
+    });
+    console.log(`Created stub: ${entry.path}`);
+  }
+} else {
+  // Interactive mode
+  for (const candidate of candidates) {
+    console.log(`[${candidate.category}] ${candidate.title}`);
+    console.log(`  Source: ${candidate.source}`);
+  }
+}
+
+console.log('');
+console.log('Scan complete. Run `/wiki browse` to see entries.');
+```
+
+## Output
+
+```
+Scanning project...
+Found 8 potential entries.
+
+[issues] Auth Token Expiration Fix
+  Source: git commit abc123
+
+[gotchas] Environment Variable Gotcha
+  Source: code comment in src/config.ts
+
+[patterns] API Retry Pattern
+  Source: CLAUDE.md
+
+[testing] Mock Database Setup
+  Source: tests/setup.ts
+
+Scan complete. Run `/wiki browse` to see entries.
+```

package/skills/wiki-search/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: wiki-search
+description: Search the Solvdex wiki for solutions by keywords, tags, or error patterns. Use when looking for existing knowledge about a problem.
+argument-hint: <query>
+user-invocable: true
+disable-model-invocation: false
+---
+
+# Search Solvdex
+
+Find relevant wiki entries by keywords, tags, or error patterns.
+
+## Process
+
+1. Parse search query
+2. Search by:
+   - Title match (highest weight)
+   - Tag match
+   - Content match
+   - Trigger pattern match (for error text)
+3. Filter by confidence threshold
+4. Return best matches sorted by relevance
+
+## Implementation
+
+```typescript
+import { searchWiki, matchTrigger, wikiExists, CONFIDENCE } from 'solvdex';
+
+const projectRoot = process.cwd();
+const query = $ARGUMENTS;
+
+if (!wikiExists(projectRoot)) {
+  console.log('No wiki found. Run `/wiki init` first.');
+  return;
+}
+
+// Check if query looks like an error message
+const isErrorText = query.includes('error') || query.includes('Error') || query.includes('failed');
+
+let results;
+if (isErrorText) {
+  results = await matchTrigger(projectRoot, query);
+  if (results.length === 0) {
+    results = await searchWiki(projectRoot, { query });
+  }
+} else {
+  results = await searchWiki(projectRoot, { query });
+}
+
+if (results.length === 0) {
+  console.log(`No entries found for: "${query}"`);
+  console.log('');
+  console.log('Try:');
+  console.log('  - Different keywords');
+  console.log('  - `/wiki browse` to see all entries');
+  console.log('  - `/wiki add` to create a new entry');
+} else {
+  console.log(`Found ${results.length} entries:\n`);
+
+  for (const { entry, score, matchedOn } of results.slice(0, 5)) {
+    const status = entry.frontmatter.status === 'active' ? 'Active' : 'Flagged';
+    const conf = entry.frontmatter.confidence;
+    console.log(`[${status}] ${entry.frontmatter.title}`);
+    console.log(`   Path: ${entry.path}`);
+    console.log(`   Tags: ${entry.frontmatter.tags.join(', ')}`);
+    console.log(`   Confidence: ${conf} | Matched: ${matchedOn.join(', ')}`);
+    console.log('');
+  }
+}
+```
+
+## Output Example
+
+```
+Found 2 entries:
+
+[Active] Drizzle Enum Migration Error
+   Path: issues/drizzle-enum-error.md
+   Tags: drizzle, database, enum, migration
+   Confidence: 80 | Matched: title, tags, trigger
+
+[Active] PostgreSQL Type Casting Issues
+   Path: issues/postgres-type-casting.md
+   Tags: postgres, database, types
+   Confidence: 50 | Matched: tags
+```

package/skills/wiki-stats/SKILL.md

@@ -0,0 +1,129 @@
+---
+name: wiki-stats
+description: Show detailed Solvdex wiki statistics with usage analytics, health score, stale entries, and confidence distribution.
+argument-hint: [--decay]
+user-invocable: true
+disable-model-invocation: false
+---
+
+# Solvdex Stats
+
+Display comprehensive wiki statistics including usage analytics, stale entries, and health score.
+
+## Options
+
+- `--decay`: Apply confidence decay to stale entries (90+ days old)
+
+## Implementation
+
+```typescript
+import { wikiExists, getExtendedStats, applyConfidenceDecay, DEFAULT_CATEGORIES } from 'solvdex';
+
+const projectRoot = process.cwd();
+const applyDecay = $ARGUMENTS.includes('--decay');
+
+if (!wikiExists(projectRoot)) {
+  console.log('No wiki found. Run `/wiki init` first.');
+  return;
+}
+
+const stats = await getExtendedStats(projectRoot);
+
+console.log('# Solvdex Statistics\n');
+
+// Health Score
+const healthEmoji = stats.healthScore >= 80 ? '🟢' : stats.healthScore >= 50 ? '🟡' : '🔴';
+console.log(`## Health Score: ${healthEmoji} ${stats.healthScore}/100\n`);
+
+// Entry counts
+console.log('## Entries');
+console.log(`  Total: ${stats.total}`);
+console.log(`  Active: ${stats.active}`);
+console.log(`  Flagged: ${stats.flagged}`);
+console.log(`  Deprecated: ${stats.deprecated}`);
+console.log(`  Stubs: ${stats.stubs}`);
+console.log('');
+
+// By Category
+console.log('## By Category');
+for (const [category, count] of Object.entries(stats.byCategory)) {
+  console.log(`  ${category}: ${count}`);
+}
+console.log('');
+
+// Confidence Distribution
+console.log('## Confidence Distribution');
+console.log(`  High (80-100): ${stats.highConfidence}`);
+console.log(`  Medium (50-79): ${stats.mediumConfidence}`);
+console.log(`  Low (0-49): ${stats.lowConfidence}`);
+console.log('');
+
+// Usage Stats
+console.log('## Usage Analytics');
+console.log(`  Total uses: ${stats.totalUseCount}`);
+console.log(`  Average age: ${stats.averageAge} days`);
+
+if (stats.mostUsed.length > 0) {
+  console.log('\n### Most Used Entries');
+  for (const entry of stats.mostUsed) {
+    console.log(`  - ${entry.title} (${entry.useCount} uses)`);
+  }
+}
+
+if (stats.neverUsed.length > 0) {
+  console.log(`\n### Never Used: ${stats.neverUsed.length} entries`);
+  for (const entry of stats.neverUsed.slice(0, 5)) {
+    console.log(`  - ${entry.title}`);
+  }
+}
+
+// Stale Entries
+if (stats.staleEntries.length > 0) {
+  console.log('\n## Stale Entries (90+ days)');
+  for (const entry of stats.staleEntries.slice(0, 5)) {
+    console.log(`  - ${entry.title} (${entry.daysSinceUpdate} days)`);
+  }
+}
+
+// Apply decay if requested
+if (applyDecay) {
+  console.log('\n## Applying Confidence Decay...');
+  const decayed = await applyConfidenceDecay(projectRoot);
+  if (decayed.length > 0) {
+    console.log(`  Decayed ${decayed.length} entries`);
+  } else {
+    console.log('  No entries needed decay');
+  }
+}
+```
+
+## Output
+
+```
+# Solvdex Statistics
+
+## Health Score: 🟢 85/100
+
+## Entries
+  Total: 18
+  Active: 15
+  Flagged: 2
+  Deprecated: 1
+  Stubs: 4
+
+## Confidence Distribution
+  High (80-100): 8
+  Medium (50-79): 7
+  Low (0-49): 3
+
+## Usage Analytics
+  Total uses: 42
+  Average age: 30 days
+
+### Most Used Entries
+  - Database Connection Timeout (15 uses)
+  - React State Management Pattern (12 uses)
+
+## Stale Entries (90+ days)
+  - Old Authentication Flow (120 days)
+```