abelworkflow 0.1.0

package/skills/confidence-check/confidence.ts

@@ -0,0 +1,335 @@
+/**
+ * Confidence Check - Pre-implementation confidence assessment
+ *
+ * Prevents wrong-direction execution by assessing confidence BEFORE starting.
+ * Requires ≥90% confidence to proceed with implementation.
+ *
+ * Token Budget: 100-200 tokens
+ * ROI: 25-250x token savings when stopping wrong direction
+ *
+ * Test Results (2025-10-21):
+ * - Precision: 1.000 (no false positives)
+ * - Recall: 1.000 (no false negatives)
+ * - 8/8 test cases passed
+ *
+ * Confidence Levels:
+ *    - High (≥90%): Root cause identified, solution verified, no duplication, architecture-compliant
+ *    - Medium (70-89%): Multiple approaches possible, trade-offs require consideration
+ *    - Low (<70%): Investigation incomplete, unclear root cause, missing official docs
+ */
+
+import { existsSync, readdirSync } from 'fs';
+import { join, dirname } from 'path';
+
+export interface Context {
+  task?: string;
+  test_file?: string;
+  test_name?: string;
+  markers?: string[];
+  duplicate_check_complete?: boolean;
+  architecture_check_complete?: boolean;
+  official_docs_verified?: boolean;
+  oss_reference_complete?: boolean;
+  root_cause_identified?: boolean;
+  confidence_checks?: string[];
+  [key: string]: any;
+}
+
+/**
+ * Pre-implementation confidence assessment
+ *
+ * Usage:
+ *   const checker = new ConfidenceChecker();
+ *   const confidence = await checker.assess(context);
+ *
+ *   if (confidence >= 0.9) {
+ *     // High confidence - proceed immediately
+ *   } else if (confidence >= 0.7) {
+ *     // Medium confidence - present options to user
+ *   } else {
+ *     // Low confidence - STOP and request clarification
+ *   }
+ */
+export class ConfidenceChecker {
+  /**
+   * Assess confidence level (0.0 - 1.0)
+   *
+   * Investigation Phase Checks:
+   * 1. No duplicate implementations? (25%)
+   * 2. Architecture compliance? (25%)
+   * 3. Official documentation verified? (20%)
+   * 4. Working OSS implementations referenced? (15%)
+   * 5. Root cause identified? (15%)
+   *
+   * @param context - Task context with investigation flags
+   * @returns Confidence score (0.0 = no confidence, 1.0 = absolute certainty)
+   */
+  async assess(context: Context): Promise<number> {
+    let score = 0.0;
+    const checks: string[] = [];
+
+    // Check 1: No duplicate implementations (25%)
+    if (this.noDuplicates(context)) {
+      score += 0.25;
+      checks.push("✅ No duplicate implementations found");
+    } else {
+      checks.push("❌ Check for existing implementations first");
+    }
+
+    // Check 2: Architecture compliance (25%)
+    if (this.architectureCompliant(context)) {
+      score += 0.25;
+      checks.push("✅ Uses existing tech stack (e.g., Supabase)");
+    } else {
+      checks.push("❌ Verify architecture compliance (avoid reinventing)");
+    }
+
+    // Check 3: Official documentation verified (20%)
+    if (this.hasOfficialDocs(context)) {
+      score += 0.2;
+      checks.push("✅ Official documentation verified");
+    } else {
+      checks.push("❌ Read official docs first");
+    }
+
+    // Check 4: Working OSS implementations referenced (15%)
+    if (this.hasOssReference(context)) {
+      score += 0.15;
+      checks.push("✅ Working OSS implementation found");
+    } else {
+      checks.push("❌ Search for OSS implementations");
+    }
+
+    // Check 5: Root cause identified (15%)
+    if (this.rootCauseIdentified(context)) {
+      score += 0.15;
+      checks.push("✅ Root cause identified");
+    } else {
+      checks.push("❌ Continue investigation to identify root cause");
+    }
+
+    // Store check results for reporting
+    context.confidence_checks = checks;
+
+    // Display checks
+    console.log("📋 Confidence Checks:");
+    checks.forEach(check => console.log(`   ${check}`));
+    console.log("");
+
+    return score;
+  }
+
+  /**
+   * Check if official documentation exists
+   *
+   * Looks for:
+   * - README.md in project
+   * - CLAUDE.md and AGENTS.md with relevant patterns
+   * - docs/ directory with related content
+   */
+  private hasOfficialDocs(context: Context): boolean {
+    // Check context flag first (for testing)
+    if ('official_docs_verified' in context) {
+      return context.official_docs_verified ?? false;
+    }
+
+    // Check for test file path
+    const testFile = context.test_file;
+    if (!testFile) {
+      return false;
+    }
+
+    // Walk up directory tree to find project root (same logic as Python version)
+    let projectRoot = dirname(testFile);
+
+    while (true) {
+      // Check for documentation files
+      if (existsSync(join(projectRoot, 'README.md'))) {
+        return true;
+      }
+      if (existsSync(join(projectRoot, 'CLAUDE.md'))) {
+        return true;
+      }
+      if (existsSync(join(projectRoot, 'AGENTS.md'))) {
+        return true;
+      }
+      if (existsSync(join(projectRoot, 'docs'))) {
+        return true;
+      }
+
+      // Move up one directory
+      const parent = dirname(projectRoot);
+      if (parent === projectRoot) break; // Reached root (same as Python: parent != project_root)
+      projectRoot = parent;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check for duplicate implementations
+   *
+   * Before implementing, verify:
+   * - No existing similar functions/modules (Glob/Grep)
+   * - No helper functions that solve the same problem
+   * - No libraries that provide this functionality
+   *
+   * Returns true if no duplicates found (investigation complete)
+   */
+  private noDuplicates(context: Context): boolean {
+    // This is a placeholder - actual implementation should:
+    // 1. Search codebase with Glob/Grep for similar patterns
+    // 2. Check project dependencies for existing solutions
+    // 3. Verify no helper modules provide this functionality
+    return context.duplicate_check_complete ?? false;
+  }
+
+  /**
+   * Check architecture compliance
+   *
+   * Verify solution uses existing tech stack:
+   * - Supabase project → Use Supabase APIs (not custom API)
+   * - Next.js project → Use Next.js patterns (not custom routing)
+   * - Turborepo → Use workspace patterns (not manual scripts)
+   *
+   * Returns true if solution aligns with project architecture
+   */
+  private architectureCompliant(context: Context): boolean {
+    // This is a placeholder - actual implementation should:
+    // 1. Read CLAUDE.md and AGENTS.md for project tech stack
+    // 2. Verify solution uses existing infrastructure
+    // 3. Check not reinventing provided functionality
+    return context.architecture_check_complete ?? false;
+  }
+
+  /**
+   * Check if working OSS implementations referenced
+   *
+   * Search for:
+   * - Similar open-source solutions
+   * - Reference implementations in popular projects
+   * - Community best practices
+   *
+   * Returns true if OSS reference found and analyzed
+   */
+  private hasOssReference(context: Context): boolean {
+    // This is a placeholder - actual implementation should:
+    // 1. Search GitHub for similar implementations
+    // 2. Read popular OSS projects solving same problem
+    // 3. Verify approach matches community patterns
+    return context.oss_reference_complete ?? false;
+  }
+
+  /**
+   * Check if root cause is identified with high certainty
+   *
+   * Verify:
+   * - Problem source pinpointed (not guessing)
+   * - Solution addresses root cause (not symptoms)
+   * - Fix verified against official docs/OSS patterns
+   *
+   * Returns true if root cause clearly identified
+   */
+  private rootCauseIdentified(context: Context): boolean {
+    // This is a placeholder - actual implementation should:
+    // 1. Verify problem analysis complete
+    // 2. Check solution addresses root cause
+    // 3. Confirm fix aligns with best practices
+    return context.root_cause_identified ?? false;
+  }
+
+  /**
+   * Check if existing patterns can be followed
+   *
+   * Looks for:
+   * - Similar test files
+   * - Common naming conventions
+   * - Established directory structure
+   */
+  private hasExistingPatterns(context: Context): boolean {
+    const testFile = context.test_file;
+    if (!testFile) {
+      return false;
+    }
+
+    const testDir = dirname(testFile);
+
+    // Check for other test files in same directory
+    if (existsSync(testDir)) {
+      try {
+        const files = readdirSync(testDir);
+        const testFiles = files.filter(f =>
+          f.startsWith('test_') && f.endsWith('.py')
+        );
+        return testFiles.length > 1;
+      } catch {
+        return false;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if implementation path is clear
+   *
+   * Considers:
+   * - Test name suggests clear purpose
+   * - Markers indicate test type
+   * - Context has sufficient information
+   */
+  private hasClearPath(context: Context): boolean {
+    // Check test name clarity
+    const testName = context.test_name ?? '';
+    if (!testName || testName === 'test_example') {
+      return false;
+    }
+
+    // Check for markers indicating test type
+    const markers = context.markers ?? [];
+    const knownMarkers = new Set([
+      'unit', 'integration', 'hallucination',
+      'performance', 'confidence_check', 'self_check'
+    ]);
+
+    const hasMarkers = markers.some(m => knownMarkers.has(m));
+
+    return hasMarkers || testName.length > 10;
+  }
+
+  /**
+   * Get recommended action based on confidence level
+   *
+   * @param confidence - Confidence score (0.0 - 1.0)
+   * @returns Recommended action
+   */
+  getRecommendation(confidence: number): string {
+    if (confidence >= 0.9) {
+      return "✅ High confidence (≥90%) - Proceed with implementation";
+    } else if (confidence >= 0.7) {
+      return "⚠️ Medium confidence (70-89%) - Continue investigation, DO NOT implement yet";
+    } else {
+      return "❌ Low confidence (<70%) - STOP and continue investigation loop";
+    }
+  }
+}
+
+/**
+ * Legacy function-based API for backward compatibility
+ *
+ * @deprecated Use ConfidenceChecker class instead
+ */
+export async function confidenceCheck(context: Context): Promise<number> {
+  const checker = new ConfidenceChecker();
+  return checker.assess(context);
+}
+
+/**
+ * Legacy getRecommendation for backward compatibility
+ *
+ * @deprecated Use ConfidenceChecker.getRecommendation() instead
+ */
+export function getRecommendation(confidence: number): string {
+  const checker = new ConfidenceChecker();
+  return checker.getRecommendation(confidence);
+}

package/skills/context7-auto-research/.env

@@ -0,0 +1,4 @@
+# Context7 API Key Configuration
+# Get your API key from: https://context7.com/dashboard
+
+CONTEXT7_API_KEY=ctx7sk-d4d4d513-e3ae-44ae-b67d-30c046898ecf

package/skills/context7-auto-research/.env.example

@@ -0,0 +1,4 @@
+# Context7 API Key Configuration
+# Get your API key from: https://context7.com/dashboard
+
+CONTEXT7_API_KEY=

package/skills/context7-auto-research/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: context7-auto-research
+version: 1.0.1
+author: BenedictKing
+description: Automatically fetches up-to-date documentation from Context7 when users ask about libraries, frameworks, APIs, or need code examples. Triggers proactively without explicit user request.
+allowed-tools:
+  - Bash
+user-invocable: true
+---
+
+# Context7 Auto Research
+
+Fetch current official documentation from Context7 when a user asks about a library, framework, package, or API.
+
+## Trigger
+
+Activate proactively when the request includes any of these:
+
+- How to use, configure, install, migrate, or implement something in a named library/framework
+- Documentation, reference, API, examples, or best practices for a library/framework
+- Version-specific behavior such as `React 19`, `Next.js 15`, `Vue 3.5`
+- Code generation that depends on framework or package APIs
+
+Common cues:
+
+- Chinese requests such as `如何实现` `怎么写` `配置` `安装` `文档` `参考` `示例`
+- English requests such as `how to` `configure` `install` `docs` `reference` `example`
+- Library mentions such as `React` `Next.js` `Vue` `Prisma` `Tailwind` `Express`
+- Package or repository names from npm, PyPI, GitHub, or official docs sites
+
+## Workflow
+
+1. Run from this skill directory and use `./context7-api.js`.
+2. Search with the full user query:
+
+```bash
+cd skills/context7-auto-research
+node ./context7-api.js --help
+node ./context7-api.js search '<library-name>' - <<'__C7_QUERY__'
+<full user query>
+__C7_QUERY__
+```
+
+3. Pick the best match in this order:
+- Exact library name
+- Official package over forks
+- Version match when the user specified one
+- Higher trust score
+
+4. Fetch focused documentation:
+
+```bash
+node ./context7-api.js context '<library-id>' - <<'__C7_QUERY__'
+<feature name or focused question>
+__C7_QUERY__
+```
+
+5. Answer with the retrieved documentation:
+- Prefer current behavior over memory
+- Mention version when relevant
+- Extract only the needed points
+- Include concise code examples when useful
+- If the CLI returns `ok: false`, treat the lookup as failed even if JSON was printed
+
+## Fallback
+
+- If search returns no useful match, ask for the exact package or repository name.
+- If Context7 fails, say the lookup failed and label the answer as based on local knowledge.
+- If multiple libraries are involved, fetch only the ones needed for the answer.
+
+## Environment
+
+- Preferred: `CONTEXT7_API_KEY` environment variable
+- Also supported: `<skill-dir>/.env`
+- CLI help: `node ./context7-api.js --help`
+
+## Notes
+
+- The helper accepts either inline query text or `-` to read the query from stdin.
+- Use the full user question for search; use a narrower feature query for context when possible.
+- The CLI prints structured JSON for `search` and `context`, including error cases.
+- The CLI exits non-zero when the lookup or argument parsing fails.
+- Requires network access and is subject to Context7 coverage and rate limits.

package/skills/context7-auto-research/context7-api.js

@@ -0,0 +1,283 @@
+#!/usr/bin/env node
+
+/**
+ * Context7 API Helper Script
+ * Provides simple CLI interface to Context7 API for skill integration
+ */
+
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+
+const API_BASE = 'https://context7.com/api/v2';
+const STDIN_TIMEOUT_MS = 3000;
+const MAX_STDIN_BYTES = 100 * 1024;
+
+function printJson(value) {
+  console.log(JSON.stringify(value, null, 2));
+}
+
+function buildErrorResult(commandName, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const result = {
+    ok: false,
+    fallback: 'local-knowledge',
+    error: {
+      command: commandName,
+      message
+    }
+  };
+
+  if (commandName === 'search') {
+    result.libraries = [];
+  } else if (commandName === 'context') {
+    result.results = [];
+  }
+
+  return result;
+}
+
+function printErrorResult(commandName, error, exitCode = 1) {
+  printJson(buildErrorResult(commandName, error));
+  process.exit(exitCode);
+}
+
+function printUsage() {
+  console.error(`Usage:
+  context7-api.js search <libraryName> <query|->
+  context7-api.js context <libraryId> <query|->
+
+Examples:
+  node context7-api.js search react "useEffect cleanup"
+  node context7-api.js context /facebook/react -
+
+Config:
+  CONTEXT7_API_KEY from environment, or .env in the script directory`);
+}
+
+// Load API key from .env file in skill directory or from environment variable
+function loadApiKey() {
+  // First try environment variable
+  if (process.env.CONTEXT7_API_KEY) {
+    return process.env.CONTEXT7_API_KEY;
+  }
+
+  // Then try .env file in skill directory
+  const envPath = path.join(__dirname, '.env');
+  let envContent;
+  try {
+    envContent = fs.readFileSync(envPath, 'utf8');
+  } catch {
+    return null;
+  }
+  for (const line of envContent.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue;
+    }
+    const separatorIndex = trimmed.indexOf('=');
+    if (separatorIndex === -1) {
+      continue;
+    }
+    const key = trimmed.slice(0, separatorIndex).trim();
+    if (key !== 'CONTEXT7_API_KEY') {
+      continue;
+    }
+    const value = trimmed.slice(separatorIndex + 1).trim();
+    if (value) {
+      return value.replace(/^["']|["']$/g, '');
+    }
+  }
+
+  return null;
+}
+
+const API_KEY = loadApiKey();
+
+function makeRequest(path, params = {}) {
+  return new Promise((resolve, reject) => {
+    const queryString = new URLSearchParams(params).toString();
+    const url = `${API_BASE}${path}?${queryString}`;
+    const headers = {
+      'User-Agent': 'Context7-Skill/1.0'
+    };
+
+    if (API_KEY) {
+      headers.Authorization = `Bearer ${API_KEY}`;
+    }
+
+    const options = {
+      headers
+    };
+
+    const req = https.get(url, options, (res) => {
+      let data = '';
+
+      res.on('data', (chunk) => {
+        data += chunk;
+      });
+
+      res.on('end', () => {
+        if (res.statusCode === 200) {
+          try {
+            resolve(JSON.parse(data));
+          } catch (e) {
+            resolve(data);
+          }
+        } else {
+          reject(new Error(`API Error ${res.statusCode}: ${data}`));
+        }
+      });
+    });
+
+    req.setTimeout(10000, () => {
+      req.destroy(new Error('Request timeout after 10s'));
+    });
+
+    req.on('error', reject);
+  });
+}
+
+async function searchLibrary(libraryName, query) {
+  return makeRequest('/libs/search', {
+    libraryName,
+    query
+  });
+}
+
+async function getContext(libraryId, query) {
+  return makeRequest('/context', {
+    libraryId,
+    query,
+    type: 'json'
+  });
+}
+
+// Read query from stdin (avoids all shell escaping issues)
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    if (process.stdin.isTTY) {
+      reject(new Error('Cannot read query from stdin: no piped input detected. Pass the query as an argument, or use - with piped stdin.'));
+      return;
+    }
+
+    let data = '';
+    let byteLength = 0;
+    let timeoutId;
+
+    function cleanup() {
+      clearTimeout(timeoutId);
+      process.stdin.removeListener('data', onData);
+      process.stdin.removeListener('end', onEnd);
+      process.stdin.removeListener('error', onError);
+    }
+
+    function fail(error) {
+      cleanup();
+      reject(error);
+    }
+
+    function resetTimeout() {
+      clearTimeout(timeoutId);
+      timeoutId = setTimeout(() => {
+        fail(new Error('Timed out waiting for stdin query input. Pass the query as an argument, or pipe it with -.'));
+      }, STDIN_TIMEOUT_MS);
+    }
+
+    function onData(chunk) {
+      data += chunk;
+      byteLength += Buffer.byteLength(chunk, 'utf8');
+      if (byteLength > MAX_STDIN_BYTES) {
+        fail(new Error(`Stdin query input exceeded ${MAX_STDIN_BYTES} bytes. Pass a shorter query.`));
+        return;
+      }
+      resetTimeout();
+    }
+
+    function onEnd() {
+      const query = data.trim();
+      cleanup();
+      if (!query) {
+        reject(new Error('Stdin query input was empty. Pass a non-empty query as an argument, or pipe it with -.'));
+        return;
+      }
+      resolve(query);
+    }
+
+    function onError(error) {
+      fail(error);
+    }
+
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', onData);
+    process.stdin.on('end', onEnd);
+    process.stdin.on('error', onError);
+    resetTimeout();
+    process.stdin.resume();
+  });
+}
+
+async function resolveQuery(queryArgs) {
+  if (queryArgs.length === 0) {
+    return '';
+  }
+
+  if (queryArgs.length === 1 && queryArgs[0] === '-') {
+    return readStdin();
+  }
+
+  if (queryArgs.includes('-')) {
+    throw new Error('Invalid query arguments: when using -, it must be the only query argument.');
+  }
+
+  return queryArgs.join(' ');
+}
+
+// CLI Interface
+const command = process.argv[2];
+const args = process.argv.slice(3);
+
+async function main() {
+  if (!command || command === '--help' || command === '-h' || command === 'help') {
+    printUsage();
+    process.exit(command ? 0 : 1);
+  }
+
+  if (command === 'search') {
+    const libraryName = args[0];
+    try {
+      const query = await resolveQuery(args.slice(1));
+      if (!libraryName || !query) {
+        printErrorResult('search', new Error('Missing required arguments: search requires <libraryName> and a non-empty <query|->.'));
+        return;
+      }
+      const result = await searchLibrary(libraryName, query);
+      printJson(result);
+    } catch (error) {
+      printErrorResult('search', error);
+    }
+  } else if (command === 'context') {
+    const libraryId = args[0];
+    try {
+      const query = await resolveQuery(args.slice(1));
+      if (!libraryId || !query) {
+        printErrorResult('context', new Error('Missing required arguments: context requires <libraryId> and a non-empty <query|->.'));
+        return;
+      }
+      const result = await getContext(libraryId, query);
+      printJson(result);
+    } catch (error) {
+      printErrorResult('context', error);
+    }
+  } else {
+    printUsage();
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  if (command === 'search' || command === 'context') {
+    printErrorResult(command, error);
+  }
+  process.exit(1);
+});