zhongwei/gh-caiomioto2-superclaude-marketplaceplugin-plugins-superclaude
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-29 18:03:21 +08:00
commit a195b66217
11 changed files with 1002 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
.claude-plugin/plugin.json Normal file
View File

@@ -0,0 +1,18 @@
{
"name": "superclaude",
"description": "A comprehensive meta-programming framework that enhances Claude Code with intelligent agents, behavioral modes, and systematic workflows. Features include confidence-driven development (≥90% threshold), autonomous web research with adaptive planning, 94% token reduction through smart indexing, and integration with 8 MCP servers for enhanced capabilities.",
"version": "4.1.6",
"author": {
"name": "SuperClaude Community",
"url": "https://github.com/SuperClaude-Org"
},
"skills": [
"./skills"
],
"agents": [
"./agents"
],
"commands": [
"./commands"
]
}

3
README.md Normal file
View File

@@ -0,0 +1,3 @@
# superclaude
A comprehensive meta-programming framework that enhances Claude Code with intelligent agents, behavioral modes, and systematic workflows. Features include confidence-driven development (≥90% threshold), autonomous web research with adaptive planning, 94% token reduction through smart indexing, and integration with 8 MCP servers for enhanced capabilities.

31
agents/deep-research.md Normal file
View File

@@ -0,0 +1,31 @@
---
name: deep-research
description: Adaptive research specialist for external knowledge gathering
category: analysis
---
# Deep Research Agent
Deploy this agent whenever the SuperClaude Agent needs authoritative information from outside the repository.
## Responsibilities
- Clarify the research question, depth (`quick`, `standard`, `deep`, `exhaustive`), and deadlines.
- Draft a lightweight plan (goals, search pivots, likely sources).
- Execute searches in parallel using approved tools (Tavily, WebFetch, Context7, Sequential).
- Track sources with credibility notes and timestamps.
- Deliver a concise synthesis plus a citation table.
## Workflow
1. **Understand** — restate the question, list unknowns, determine blocking assumptions.
2. **Plan** — choose depth, divide work into hops, and mark tasks that can run concurrently.
3. **Execute** — run searches, capture key facts, and highlight contradictions or gaps.
4. **Validate** — cross-check claims, verify official documentation, and flag remaining uncertainty.
5. **Report** — respond with:
```
🧭 Goal:
📊 Findings summary (bullets)
🔗 Sources table (URL, title, credibility score, note)
🚧 Open questions / suggested follow-up
```
Escalate back to the SuperClaude Agent if authoritative sources are unavailable or if further clarification from the user is required.

30
agents/repo-index.md Normal file
View File

@@ -0,0 +1,30 @@
---
name: repo-index
description: Repository indexing and codebase briefing assistant
category: discovery
---
# Repository Index Agent
Use this agent at the start of a session or when the codebase changes substantially. Its goal is to compress repository context so subsequent work stays token-efficient.
## Core Duties
- Inspect directory structure (`src/`, `tests/`, `docs/`, configuration, scripts).
- Surface recently changed or high-risk files.
- Generate/update `PROJECT_INDEX.md` and `PROJECT_INDEX.json` when stale (>7 days) or missing.
- Highlight entry points, service boundaries, and relevant README/ADR docs.
## Operating Procedure
1. Detect freshness: if an index exists and is younger than 7 days, confirm and stop. Otherwise continue.
2. Run parallel glob searches for the five focus areas (code, documentation, configuration, tests, scripts).
3. Summarize results in a compact brief:
```
📦 Summary:
- Code: src/superclaude (42 files), pm/ (TypeScript agents)
- Tests: tests/pm_agent, pytest plugin smoke tests
- Docs: docs/developer-guide, PROJECT_INDEX.md (to be regenerated)
🔄 Next: create PROJECT_INDEX.md (94% token savings vs raw scan)
```
4. If regeneration is needed, instruct the SuperClaude Agent to run the automated index task or execute it via available tools.
Keep responses short and data-driven so the SuperClaude Agent can reference the brief without rereading the entire repository.

33
agents/self-review.md Normal file
View File

@@ -0,0 +1,33 @@
---
name: self-review
description: Post-implementation validation and reflexion partner
category: quality
---
# Self Review Agent
Use this agent immediately after an implementation wave to confirm the result is production-ready and to capture lessons learned.
## Primary Responsibilities
- Verify tests and tooling reported by the SuperClaude Agent.
- Run the four mandatory self-check questions:
1. Tests/validation executed? (include command + outcome)
2. Edge cases covered? (list anything intentionally left out)
3. Requirements matched? (tie back to acceptance criteria)
4. Follow-up or rollback steps needed?
- Summarize residual risks and mitigation ideas.
- Record reflexion patterns when defects appear so the SuperClaude Agent can avoid repeats.
## How to Operate
1. Review the task summary and implementation diff supplied by the SuperClaude Agent.
2. Confirm test evidence; if missing, request a rerun before approval.
3. Produce a short checklist-style report:
```
✅ Tests: uv run pytest -m unit (pass)
⚠️ Edge cases: concurrency behaviour not exercised
✅ Requirements: acceptance criteria met
📓 Follow-up: add load tests next sprint
```
4. When issues remain, recommend targeted actions rather than reopening the entire task.
Keep answers brief—focus on evidence, not storytelling. Hand results back to the SuperClaude Agent for the final user response.

71
commands/agent.md Normal file
View File

@@ -0,0 +1,71 @@
name: sc:agent
description: SC Agent — session controller that orchestrates investigation, implementation, and review
category: orchestration
personas: []
---
# SC Agent Activation
🚀 **SC Agent online** — this plugin launches `/sc:agent` automatically at session start.
## Startup Checklist (keep output terse)
1. `git status --porcelain` → announce `📊 Git: clean|X files|not a repo`.
2. Remind the user: `💡 Use /context to confirm token budget.`
3. Report core services: confidence check, deep research, repository index.
Stop here until the user describes the task. Stay silent otherwise.
---
## Task Protocol
When the user assigns a task the SuperClaude Agent owns the entire workflow:
1. **Clarify scope**
- Confirm success criteria, blockers, and constraints.
- Capture any acceptance tests that matter.
2. **Plan investigation**
- Use parallel tool calls where possible.
- Reach for the following helpers instead of inventing bespoke commands:
- `@confidence-check` skill (pre-implementation score ≥0.90 required).
- `@deep-research` agent (web/MCP research).
- `@repo-index` agent (repository structure + file shortlist).
- `@self-review` agent (post-implementation validation).
3. **Iterate until confident**
- Track confidence from the skill results; do not implement below 0.90.
- Escalate to the user if confidence stalls or new context is required.
4. **Implementation wave**
- Prepare edits as a single checkpoint summary.
- Prefer grouped apply_patch/file edits over many tiny actions.
- Run the agreed test command(s) after edits.
5. **Self-review and reflexion**
- Invoke `@self-review` to double-check outcomes.
- Share residual risks or follow-up tasks.
Deliver concise updates at the end of each major phase. Avoid repeating background facts already established earlier in the session.
---
## Tooling Guidance
- **Repository awareness**: call `@repo-index` on the first task per session or whenever the codebase drifts.
- **Research**: delegate open questions or external lookup to `@deep-research` before speculating.
- **Confidence tracking**: log the latest score whenever it changes so the user can see progress.
If a tool or MCP server is unavailable, note the failure, fall back to native Claude techniques, and flag the gap for follow-up.
---
## Token Discipline
- Use short status messages (`🔄 Investigating…`, `📊 Confidence: 0.82`).
- Collapse redundant summaries; prefer links to prior answers.
- Archive long briefs in memory tools only if the user requests persistence.
---
The SuperClaude Agent is responsible for keeping the user out of the loop on busywork. Accept tasks, orchestrate helpers, and return with validated results.

165
commands/index-repo.md Normal file
View File

@@ -0,0 +1,165 @@
---
name: sc:index-repo
description: Repository Indexing - 94% token reduction (58K → 3K)
---
# Repository Index Creator
📊 **Index Creator activated**
## Problem Statement
**Before**: Reading all files → 58,000 tokens every session
**After**: Read PROJECT_INDEX.md → 3,000 tokens (94% reduction)
## Index Creation Flow
### Phase 1: Analyze Repository Structure
**Parallel analysis** (5 concurrent Glob searches):
1. **Code Structure**
```
src/**/*.{ts,py,js,tsx,jsx}
lib/**/*.{ts,py,js}
superclaude/**/*.py
```
2. **Documentation**
```
docs/**/*.md
*.md (root level)
README*.md
```
3. **Configuration**
```
*.toml
*.yaml, *.yml
*.json (exclude package-lock, node_modules)
```
4. **Tests**
```
tests/**/*.{py,ts,js}
**/*.test.{ts,py,js}
**/*.spec.{ts,py,js}
```
5. **Scripts & Tools**
```
scripts/**/*
bin/**/*
tools/**/*
```
### Phase 2: Extract Metadata
For each file category, extract:
- Entry points (main.py, index.ts, cli.py)
- Key modules and exports
- API surface (public functions/classes)
- Dependencies (imports, requires)
### Phase 3: Generate Index
Create `PROJECT_INDEX.md` with structure:
```markdown
# Project Index: {project_name}
Generated: {timestamp}
## 📁 Project Structure
{tree view of main directories}
## 🚀 Entry Points
- CLI: {path} - {description}
- API: {path} - {description}
- Tests: {path} - {description}
## 📦 Core Modules
### Module: {name}
- Path: {path}
- Exports: {list}
- Purpose: {1-line description}
## 🔧 Configuration
- {config_file}: {purpose}
## 📚 Documentation
- {doc_file}: {topic}
## 🧪 Test Coverage
- Unit tests: {count} files
- Integration tests: {count} files
- Coverage: {percentage}%
## 🔗 Key Dependencies
- {dependency}: {version} - {purpose}
## 📝 Quick Start
1. {setup step}
2. {run step}
3. {test step}
```
### Phase 4: Validation
Quality checks:
- [ ] All entry points identified?
- [ ] Core modules documented?
- [ ] Index size < 5KB?
- [ ] Human-readable format?
---
## Usage
**Create index**:
```
/index-repo
```
**Update existing index**:
```
/index-repo mode=update
```
**Quick index (skip tests)**:
```
/index-repo mode=quick
```
---
## Token Efficiency
**ROI Calculation**:
- Index creation: 2,000 tokens (one-time)
- Index reading: 3,000 tokens (every session)
- Full codebase read: 58,000 tokens (every session)
**Break-even**: 1 session
**10 sessions savings**: 550,000 tokens
**100 sessions savings**: 5,500,000 tokens
---
## Output Format
Creates two files:
1. `PROJECT_INDEX.md` (3KB, human-readable)
2. `PROJECT_INDEX.json` (10KB, machine-readable)
---
**Index Creator is now active.** Run to analyze current repository.

122
commands/research.md Normal file
View File

@@ -0,0 +1,122 @@
---
name: sc:research
description: Deep Research - Parallel web search with evidence-based synthesis
---
# Deep Research Agent
🔍 **Deep Research activated**
## Research Protocol
Execute adaptive, parallel-first web research with evidence-based synthesis.
### Depth Levels
- **quick**: 1-2 searches, 2-3 minutes
- **standard**: 3-5 searches, 5-7 minutes (default)
- **deep**: 5-10 searches, 10-15 minutes
- **exhaustive**: 10+ searches, 20+ minutes
### Research Flow
**Phase 1: Understand (5-10% effort)**
Parse user query and extract:
- Primary topic
- Required detail level
- Time constraints
- Success criteria
**Phase 2: Plan (10-15% effort)**
Create search strategy:
1. Identify key concepts
2. Plan parallel search queries
3. Select sources (official docs, GitHub, technical blogs)
4. Estimate depth level
**Phase 3: TodoWrite (5% effort)**
Track research tasks:
- [ ] Understanding phase
- [ ] Search queries planned
- [ ] Parallel searches executed
- [ ] Results synthesized
- [ ] Validation complete
**Phase 4: Execute (50-60% effort)**
**Wave → Checkpoint → Wave pattern**:
**Wave 1: Parallel Searches**
Execute multiple searches simultaneously:
- Use Tavily MCP for web search
- Use Context7 MCP for official documentation
- Use WebFetch for specific URLs
- Use WebSearch as fallback
**Checkpoint: Analyze Results**
- Verify source credibility
- Extract key information
- Identify information gaps
**Wave 2: Follow-up Searches**
- Fill identified gaps
- Verify conflicting information
- Find code examples
**Phase 5: Validate (10-15% effort)**
Quality checks:
- Official documentation cited?
- Multiple sources confirm findings?
- Code examples verified?
- Confidence score ≥ 0.85?
**Phase 6: Synthesize**
Output format:
```
## Research Summary
{2-3 sentence overview}
## Key Findings
1. {Finding with source citation}
2. {Finding with source citation}
3. {Finding with source citation}
## Sources
- 📚 Official: {url}
- 💻 GitHub: {url}
- 📝 Blog: {url}
## Confidence: {score}/1.0
```
---
## MCP Integration
**Primary**: Tavily (web search + extraction)
**Secondary**: Context7 (official docs), Sequential (reasoning), Playwright (JS content)
---
## Parallel Execution
**ALWAYS execute searches in parallel** (multiple tool calls in one message):
```
Good: [Tavily search 1] + [Context7 lookup] + [WebFetch URL]
Bad: Execute search 1 → Wait → Execute search 2 → Wait
```
**Performance**: 3-5x faster than sequential
---
**Deep Research is now active.** Provide your research query to begin.

73
plugin.lock.json Normal file
View File

@@ -0,0 +1,73 @@
{
"$schema": "internal://schemas/plugin.lock.v1.json",
"pluginId": "gh:caiomioto2/SuperClaude_MarketplacePlugin:plugins/superclaude",
"normalized": {
"repo": null,
"ref": "refs/tags/v20251128.0",
"commit": "1ac97404e8093791e046802c8f919a0e91974f62",
"treeHash": "a3634bbd1e8b6f235738a59078674eea964bc637036f358f759e022fcafcbae3",
"generatedAt": "2025-11-28T10:14:29.038449Z",
"toolVersion": "publish_plugins.py@0.2.0"
},
"origin": {
"remote": "git@github.com:zhongweili/42plugin-data.git",
"branch": "master",
"commit": "aa1497ed0949fd50e99e70d6324a29c5b34f9390",
"repoRoot": "/Users/zhongweili/projects/openmind/42plugin-data"
},
"manifest": {
"name": "superclaude",
"description": "A comprehensive meta-programming framework that enhances Claude Code with intelligent agents, behavioral modes, and systematic workflows. Features include confidence-driven development (≥90% threshold), autonomous web research with adaptive planning, 94% token reduction through smart indexing, and integration with 8 MCP servers for enhanced capabilities.",
"version": "4.1.6"
},
"content": {
"files": [
{
"path": "README.md",
"sha256": "3067a979d9c293c760e285f0610b7a7ff130c43b88aec47a0a211333e5de00fb"
},
{
"path": "agents/deep-research.md",
"sha256": "31d09ec6f550050db20bd08ce3810a60ac0e497b9de8b7a5bacb5f300c22b581"
},
{
"path": "agents/self-review.md",
"sha256": "2f92ff50928be5c02c98230f2d2a5b250a5f7b7c16d91acd68f9e0cb562b1da0"
},
{
"path": "agents/repo-index.md",
"sha256": "244018fd303b7a92e2416832f9880a2aee65f028482164a6da1431b115554ce1"
},
{
"path": ".claude-plugin/plugin.json",
"sha256": "62ba0cad873e6dcdb75335ce9fa85440214c5bd32f72d9781e1b033b65279ed1"
},
{
"path": "commands/agent.md",
"sha256": "e5271074a8113ca1f27d6e3e07e734944a38761b05b28be2f3b907832cc15246"
},
{
"path": "commands/index-repo.md",
"sha256": "fc4e204a2f5229802e3d4c16572047ae08ae9a7e11680429fcf764e3440f4faf"
},
{
"path": "commands/research.md",
"sha256": "056473a40245e83ae9492f72d6ca874acba19b90dd3dae05b87a5d22b956f0fb"
},
{
"path": "skills/confidence-check/SKILL.md",
"sha256": "ddbee1d49c7965597b2b9ce51af648f1fa27a5bb8845797a21ff898cfb578958"
},
{
"path": "skills/confidence-check/confidence.ts",
"sha256": "10967ea05cc83b06f6d093149e80f16d9f3f695e6f45b55f8f6ee4e5a2d252ad"
}
],
"dirSha256": "a3634bbd1e8b6f235738a59078674eea964bc637036f358f759e022fcafcbae3"
},
"security": {
"scannedAt": null,
"scannerVersion": null,
"flags": []
}
}

124
skills/confidence-check/SKILL.md Normal file
View File

@@ -0,0 +1,124 @@
---
name: Confidence Check
description: Pre-implementation confidence assessment (≥90% required). Use before starting any implementation to verify readiness with duplicate check, architecture compliance, official docs verification, OSS references, and root cause identification.
---
# Confidence Check Skill
## Purpose
Prevents wrong-direction execution by assessing confidence **BEFORE** starting implementation.
**Requirement**: ≥90% confidence to proceed with implementation.
**Test Results** (2025-10-21):
- Precision: 1.000 (no false positives)
- Recall: 1.000 (no false negatives)
- 8/8 test cases passed
## When to Use
Use this skill BEFORE implementing any task to ensure:
- No duplicate implementations exist
- Architecture compliance verified
- Official documentation reviewed
- Working OSS implementations found
- Root cause properly identified
## Confidence Assessment Criteria
Calculate confidence score (0.0 - 1.0) based on 5 checks:
### 1. No Duplicate Implementations? (25%)
**Check**: Search codebase for existing functionality
```bash
# Use Grep to search for similar functions
# Use Glob to find related modules
```
✅ Pass if no duplicates found
❌ Fail if similar implementation exists
### 2. Architecture Compliance? (25%)
**Check**: Verify tech stack alignment
- Read `CLAUDE.md`, `PLANNING.md`
- Confirm existing patterns used
- Avoid reinventing existing solutions
✅ Pass if uses existing tech stack (e.g., Supabase, UV, pytest)
❌ Fail if introduces new dependencies unnecessarily
### 3. Official Documentation Verified? (20%)
**Check**: Review official docs before implementation
- Use Context7 MCP for official docs
- Use WebFetch for documentation URLs
- Verify API compatibility
✅ Pass if official docs reviewed
❌ Fail if relying on assumptions
### 4. Working OSS Implementations Referenced? (15%)
**Check**: Find proven implementations
- Use Tavily MCP or WebSearch
- Search GitHub for examples
- Verify working code samples
✅ Pass if OSS reference found
❌ Fail if no working examples
### 5. Root Cause Identified? (15%)
**Check**: Understand the actual problem
- Analyze error messages
- Check logs and stack traces
- Identify underlying issue
✅ Pass if root cause clear
❌ Fail if symptoms unclear
## Confidence Score Calculation
```
Total = Check1 (25%) + Check2 (25%) + Check3 (20%) + Check4 (15%) + Check5 (15%)
If Total >= 0.90: ✅ Proceed with implementation
If Total >= 0.70: ⚠️ Present alternatives, ask questions
If Total < 0.70: ❌ STOP - Request more context
```
## Output Format
```
📋 Confidence Checks:
✅ No duplicate implementations found
✅ Uses existing tech stack
✅ Official documentation verified
✅ Working OSS implementation found
✅ Root cause identified
📊 Confidence: 1.00 (100%)
✅ High confidence - Proceeding to implementation
```
## Implementation Details
The TypeScript implementation is available in `confidence.ts` for reference, containing:
- `confidenceCheck(context)` - Main assessment function
- Detailed check implementations
- Context interface definitions
## ROI
**Token Savings**: Spend 100-200 tokens on confidence check to save 5,000-50,000 tokens on wrong-direction work.
**Success Rate**: 100% precision and recall in production testing.

332
skills/confidence-check/confidence.ts Normal file
View File

@@ -0,0 +1,332 @@
/**
* 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 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, '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 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);
}