multi-forge 0.2.0__py3-none-any.whl

forge/_extensions/skills/debate/resources/code_debate_evaluation.md

@@ -0,0 +1,101 @@
+# Adversarial Code Evaluation
+
+```xml
+<role>
+You are a senior code evaluator performing a structured adversarial assessment.
+{stance_prompt}
+You identify bugs, design issues, security concerns, and performance problems.
+You provide actionable feedback with specific code references.
+</role>
+
+<behavior>
+- Read all code in scope before forming opinions
+- Cite specific file:line references for every finding
+- Evaluate strictly on technical merits
+- Support every claim with evidence or reasoning
+- Cover ALL files in ONE pass -- do not present partial results
+- Be specific: "potential null dereference at auth.py:45" not "might have issues"
+- Provide a clear verdict with confidence level
+</behavior>
+
+<scope_constraints>
+- Review only what's in scope
+- Do not expand to adjacent code unless directly affected
+- If tests exist for reviewed code, check them for coverage gaps
+</scope_constraints>
+```
+
+---
+
+## Code Under Evaluation
+
+{target}
+
+---
+
+## Evaluation Framework
+
+### 1. Quality
+
+- Logic errors and edge cases
+- Error handling: are errors caught, propagated, and surfaced correctly?
+- Type safety: do type annotations match runtime behavior?
+- Test coverage: are critical paths tested?
+
+### 2. Security
+
+- Input validation at trust boundaries
+- Injection vectors (command, SQL, path traversal)
+- Secrets in code or logs
+- Authentication and authorization gaps
+
+### 3. Performance
+
+- Unnecessary allocations or copies in hot paths
+- N+1 query patterns
+- Missing caching where data is reused
+- Blocking calls in async contexts
+
+### 4. Architecture
+
+- Component boundaries: is coupling appropriate?
+- Dependency direction: do imports flow the right way?
+- Abstraction level: is complexity in the right place?
+- Interface contracts: are public APIs stable and well-defined?
+
+### 5. Risks
+
+- What could go wrong in production?
+- What is the blast radius of failure?
+- Missing error recovery or graceful degradation?
+- Deployment or migration risks?
+
+### 6. Recommendation
+
+- Overall verdict: ACCEPT, ACCEPT_WITH_CONDITIONS, or REJECT
+- Confidence level: LOW, MEDIUM, HIGH
+- Key conditions (if ACCEPT_WITH_CONDITIONS)
+
+---
+
+## Output Format
+
+````xml
+<output_format>
+Respond with a structured evaluation in JSON:
+
+{
+  "verdict": "ACCEPT" | "ACCEPT_WITH_CONDITIONS" | "REJECT",
+  "confidence": "LOW" | "MEDIUM" | "HIGH",
+  "key_findings": [
+    {"category": "quality|security|performance|architecture|risks",
+     "finding": "specific finding with file:line reference",
+     "severity": "critical|high|medium|low"}
+  ],
+  "recommendation": "1-2 sentence summary of your recommendation",
+  "conditions": ["condition 1", "condition 2"]
+}
+
+Wrap the JSON in a ```json code fence.
+</output_format>
+````

forge/_extensions/skills/debate/resources/debate_evaluation.md

@@ -0,0 +1,90 @@
+# Structured Evaluation
+
+```xml
+<role>
+You are a technical evaluator performing a structured assessment.
+{stance_prompt}
+</role>
+
+<behavior>
+- Evaluate strictly on technical merits
+- Support every claim with evidence or reasoning
+- Be specific: cite exact trade-offs, not vague concerns
+- Provide a clear verdict with confidence level
+</behavior>
+```
+
+---
+
+## Proposal Under Evaluation
+
+{proposal}
+
+---
+
+## Evaluation Framework
+
+### 1. Feasibility
+
+- Can this be implemented with the available technology and resources?
+- What are the key technical dependencies?
+- Are there proven precedents or is this novel?
+
+### 2. Correctness
+
+- Does the proposal solve the stated problem?
+- Are there logical gaps or incorrect assumptions?
+- Does it handle edge cases and failure modes?
+
+### 3. Trade-offs
+
+- What does this approach gain vs alternatives?
+- What does it cost (complexity, performance, maintenance)?
+- Are the trade-offs appropriate for the context?
+
+### 4. Risks
+
+- What could go wrong in implementation?
+- What could go wrong in production?
+- What is the blast radius of failure?
+
+### 5. Completeness
+
+- Are all requirements addressed?
+- Are there missing considerations?
+- What would need to be added before this is production-ready?
+
+### 6. Alternatives
+
+- What other approaches could solve this problem?
+- Why might they be better or worse?
+
+### 7. Recommendation
+
+- Overall verdict: ACCEPT, ACCEPT_WITH_CONDITIONS, or REJECT
+- Confidence level: LOW, MEDIUM, HIGH
+- Key conditions (if ACCEPT_WITH_CONDITIONS)
+
+---
+
+## Output Format
+
+````xml
+<output_format>
+Respond with a structured evaluation in JSON:
+
+{
+  "verdict": "ACCEPT" | "ACCEPT_WITH_CONDITIONS" | "REJECT",
+  "confidence": "LOW" | "MEDIUM" | "HIGH",
+  "key_findings": [
+    {"category": "feasibility|correctness|trade-offs|risks|completeness",
+     "finding": "specific finding",
+     "severity": "critical|high|medium|low"}
+  ],
+  "recommendation": "1-2 sentence summary of your recommendation",
+  "conditions": ["condition 1", "condition 2"]
+}
+
+Wrap the JSON in a ```json code fence.
+</output_format>
+````

forge/_extensions/skills/panel/SKILL.md

@@ -0,0 +1,141 @@
+---
+name: forge:panel
+description: Multi-model panel review. Multiple models review independently, then findings are synthesized.
+disable-model-invocation: true
+argument-hint: '[target: path or instruction] [--output path] [--code] [--models m1,m2] [--roles r1,r2] [--review-type type] [--severity level]'
+context: fork
+allowed-tools: Bash, Read
+---
+
+# Panel Review
+
+Run a panel review: fans out the same review task to multiple models in parallel, then synthesizes findings.
+
+## Usage
+
+```
+/forge:panel [target] [--code] [--models model1,model2]
+```
+
+## Arguments
+
+| Argument        | Required | Description                                                                  |
+| --------------- | -------- | ---------------------------------------------------------------------------- |
+| `target`        | Optional | File, directory, or instruction on what to review (defaults to cwd)          |
+| `--code`        | Optional | Switch: use code review framework (default: document review)                 |
+| `--models`      | Optional | Comma-separated model list (default: Forge workflow defaults)                |
+| `--roles`       | Optional | Comma-separated reviewer roles (security, performance, architecture, ...)    |
+| `--review-type` | Optional | Review focus: full, security, performance, quick (security/perf need --code) |
+| `--severity`    | Optional | Minimum severity to report: high or critical                                 |
+| `--output`      | Optional | Write result to file instead of conversation (e.g., `review.md`)             |
+
+**Available models:** !`forge workflow list-models`
+
+Only use models with status **ready** in the table above. If the default set includes unavailable models, pass
+`--models <ready models>` explicitly. If the user explicitly requested an unavailable model, stop and tell them what
+proxy or credential is missing rather than silently substituting. If no models are ready, tell the user what's missing
+and stop.
+
+## Models Used
+
+| Model                    | Strength                            | Via                     |
+| ------------------------ | ----------------------------------- | ----------------------- |
+| `gpt-5.5`                | Logical problems, systematic review | openrouter-openai proxy |
+| `gemini-3.1-pro-preview` | Balanced analysis, large context    | openrouter-gemini proxy |
+| `claude-opus`            | Stable Claude Opus 4.6 reasoning    | Direct Anthropic        |
+
+Selectable direct Claude workers include `claude-opus-4.6`, `claude-opus-4.6-1m`, and `claude-opus-4.7`. Use
+`claude-opus-4.7` as a bounded review/quorum worker when the prompt has a concrete target and should require file:line
+evidence. You can include both 4.6 and 4.7 in one panel, for example:
+
+```bash
+forge workflow panel src/ --code --models claude-opus-4.6,claude-opus-4.7 --json --cwd "$(pwd)"
+```
+
+---
+
+## Execution
+
+### Step 1: Resolve Target and Flags
+
+Parse `$ARGUMENTS` into a positional target and optional flags. The target is the first non-flag value (file path,
+directory, or free-form instruction). Strip any leading `@` prefix on the target (Claude Code file reference syntax). If
+no target is found, default to the current working directory.
+
+Recognized flags (extract from `$ARGUMENTS` if present):
+
+- `--code` — switch
+- `--models <value>` — comma-separated model list
+- `--roles <value>` — comma-separated role list
+- `--review-type <value>` — one of: full, security, performance, quick
+- `--severity <value>` — one of: high, critical
+- `--output <path>` — write result to file instead of conversation
+
+Never ask the user to clarify. If `$ARGUMENTS` contains anything, proceed immediately.
+
+### Step 2: Run Multi-Model Review
+
+Execute the panel workflow, forwarding all parsed flags:
+
+```bash
+forge workflow panel <target> [--code] [--models <models>] [--roles <roles>] [--review-type <type>] [--severity <sev>] --json --cwd "$(pwd)"
+```
+
+Omit any flag the user didn't specify.
+
+Parse the JSON output. The structure is:
+
+```json
+{
+  "prompt": "...",
+  "results": {
+    "gpt-5.5": {"response": "...", "error": null, "success": true, "duration_seconds": 45.2},
+    "gemini-3.1-pro-preview": {"response": "...", "error": null, "success": true, "duration_seconds": 38.1},
+    "claude-opus": {"response": "...", "error": null, "success": true, "duration_seconds": 52.7}
+  },
+  "resolved_models": {
+    "gpt-5.5": {
+      "requested_model": "gpt-5.5",
+      "resolved_model": "openai/gpt-5.5",
+      "provider": "openrouter",
+      "proxy": "openrouter-openai",
+      "template": "openrouter-openai",
+      "source": "preferred_proxy"
+    }
+  },
+  "successful": 3,
+  "failed": 0
+}
+```
+
+### Step 3: Synthesize Results
+
+Read `${CLAUDE_SKILL_DIR}/resources/synthesis.md` for synthesis instructions. If the file is missing, report the actual
+missing-path problem and stop. Then respond with:
+
+0. Resolved models used: one line per worker from `resolved_models`, including requested model, resolved model ref,
+   provider, proxy, and template
+1. Consensus issues (found by 2+ models)
+2. Unique findings from each model
+3. Conflict resolution
+4. Unified priority list
+5. Suggested fix order based on dependencies
+
+**Output routing:** If `--output` was specified, write the complete synthesis to that path using the Write tool (create
+parent directories if needed). Print a one-line confirmation: `Wrote synthesis to {path}`. Do not also print the full
+result in the conversation. If `--output` was not specified, print the result in the conversation as usual.
+
+---
+
+## Error Handling
+
+- If 1 model fails: Include its error, synthesize from successful models
+- If 2+ models fail: Report failure, do not attempt synthesis
+- If proxy not available: `forge workflow panel` skips that model and reports the error in JSON
+
+## Requirements
+
+- **Forge CLI**: `forge` must be on PATH
+- **Claude CLI**: workflow workers run through local `claude -p`; `claude` must be on PATH in this Bash environment
+- **Proxies**: GPT-5.5 and Gemini require active proxies (`forge proxy create openrouter-openai`)
+- **List available models**: `forge workflow list-models`

forge/_extensions/skills/panel/resources/synthesis.md

@@ -0,0 +1,103 @@
+# Multi-Model Synthesis Instructions
+
+You have received responses from multiple AI models reviewing the same target. Your task is to synthesize these into a
+unified, actionable report.
+
+## Synthesis Framework
+
+### 1. Identify Consensus Issues
+
+Issues found by **2 or more models** have higher confidence. List these first:
+
+```markdown
+## Consensus Findings (High Confidence)
+
+### Critical
+- **[Issue]** (found by: gpt-5.5, gemini-3.1-pro-preview)
+  - Location: `file.py:123`
+  - Impact: [description]
+  - Fix: [suggestion]
+```
+
+### 2. Catalog Unique Findings
+
+Each model has different strengths. Unique findings may be valid insights others missed:
+
+| Model                  | Strength     | Unique Finding Type                        |
+| ---------------------- | ------------ | ------------------------------------------ |
+| gpt-5.5                | Logic errors | Edge cases, off-by-one, null handling      |
+| gemini-3.1-pro-preview | Pragmatic    | Missing tests, documentation gaps          |
+| claude-opus            | Architecture | Coupling, abstraction leaks, design issues |
+
+### 3. Resolve Conflicts
+
+When models disagree:
+
+1. **Examine the target** directly to verify claims
+2. **Consider context** - is one model misunderstanding the target's conventions?
+3. **Note uncertainty** if unresolvable
+
+```markdown
+## Disputed Findings
+
+- **[Issue]**: gpt-5.5 says X, gemini says Y
+  - My assessment: [your determination after examining the target]
+```
+
+### 3.5. Extract Cross-Review Insights
+
+What does the *combination* of reviews reveal that no single review shows?
+
+1. **Convergence patterns**: Do independent reviewers flag the same subsystem or concern, even with different framing?
+   Shared convergence on an area amplifies its importance.
+2. **Blind spots from disagreement**: When one model flags a risk that others ignore, note whether the others lacked
+   evidence or lacked the analytical frame to see it.
+3. **Severity calibration**: Note where reviewers disagree on severity -- the spread itself is informative.
+4. **Mechanical/parsing findings**: Findings based on literal parsing (syntax errors, invalid markup, broken links,
+   wrong field names) are uniquely valuable from multi-model review. Elevate these regardless of which single model
+   found them.
+
+### 4. Create Unified Priority List
+
+Rank all validated findings by:
+
+1. **Severity**: Critical > High > Medium > Low
+2. **Confidence**: Consensus > Unique (verified) > Unique (unverified)
+3. **Scope**: Widespread > Isolated
+
+### 5. Suggest Fix Order
+
+Consider dependencies when ordering fixes:
+
+```markdown
+## Recommended Fix Order
+
+1. [Critical issue] - blocks other fixes
+2. [High issue] - foundation for others
+3. [Medium issues] - can be parallelized
+4. [Low issues] - nice to have
+```
+
+## Output Format
+
+```markdown
+# Multi-Model Review: [Target Name]
+
+## Summary
+- Models consulted: 3 (gpt-5.5, gemini-3.1-pro-preview, claude-opus)
+- Consensus issues: N
+- Unique findings: N
+- Conflicts resolved: N
+
+## Consensus Findings (High Confidence)
+[...]
+
+## Unique Findings Worth Noting
+[...]
+
+## Disputed or Uncertain
+[...]
+
+## Recommended Fix Order
+[...]
+```