@ultrakit/ultrakit 0.0.0

package/dist/template/.opencode/skill/prompt-leverage/references/framework.md

@@ -0,0 +1,91 @@
+# Prompt Leverage Framework
+
+Reference for combining source ideas into a practical execution framework.
+
+## Source Synthesis
+
+- **Agent Flywheel** contributes behavior controls: intensity, wider search, deeper analysis, fresh eyes, first-principles thinking, and future-self clarity.
+- **OpenAI prompt guidance** contributes execution controls: clear objectives, explicit output contracts, tool persistence, dependency checks, verification loops, and completion criteria.
+
+Treat the final framework as:
+
+`Objective -> Context -> Work Style -> Tool Rules -> Output Contract -> Verification -> Done`
+
+## Block Definitions
+
+### Objective
+
+State the task in one or two lines. Define success in observable terms.
+
+### Context
+
+Specify relevant files, URLs, constraints, assumptions, and information boundaries. Say when the agent must retrieve facts instead of guessing.
+
+### Work Style
+
+Control how the agent approaches the task.
+
+- Go broad first when system understanding matters.
+- Go deep where risk or complexity is highest.
+- Use first-principles reasoning before changing things.
+- Re-check with fresh eyes for non-trivial tasks.
+
+### Tool Rules
+
+Define when browsing, file inspection, tests, or external tools are required. Prevent skipping prerequisite checks.
+
+### Output Contract
+
+Define exact structure, tone, formatting, depth, and any required sections or schemas.
+
+### Verification
+
+Require checks for correctness, grounding, completeness, side effects, and better alternatives.
+
+### Done Criteria
+
+Define what must be true before the agent stops.
+
+## Intensity Levels
+
+Use the minimum level that matches the task.
+
+- `Light`: simple edits, formatting, quick rewrites.
+- `Standard`: typical coding, research, and drafting tasks.
+- `Deep`: debugging, architecture, complex research, or high-stakes outputs.
+
+## Task-Type Adjustments
+
+### Coding
+
+- Emphasize repo context, file inspection, smallest correct change, validation, and edge cases.
+
+### Research
+
+- Emphasize source quality, evidence gathering, synthesis, uncertainty, and citations.
+
+### Writing
+
+- Emphasize audience, tone, structure, constraints, and revision criteria.
+
+### Review
+
+- Emphasize fresh-eyes critique, failure modes, alternatives, and explicit severity.
+
+## Prompt Upgrade Heuristics
+
+- Add missing blocks only when they materially improve execution.
+- Do not turn a one-line request into a giant spec unless the task is genuinely complex.
+- Preserve user language where possible so the upgraded prompt still feels native.
+- Prefer concrete completion criteria over vague quality adjectives.
+
+## Upgrade Rubric
+
+An upgraded prompt is good when it:
+
+1. preserves original intent
+2. reduces ambiguity
+3. sets the right depth and care level
+4. defines the expected output clearly
+5. includes an appropriate verification step
+6. tells the agent when to stop

package/dist/template/.opencode/skill/prompt-leverage/scripts/augment_prompt.py

@@ -0,0 +1,157 @@
+#!/usr/bin/env python3
+"""Automated prompt upgrader using the Prompt Leverage Framework."""
+
+from __future__ import annotations
+
+import argparse
+import re
+from textwrap import dedent
+
+
+TASK_KEYWORDS = {
+    "coding": [
+        "code",
+        "bug",
+        "repo",
+        "refactor",
+        "test",
+        "implement",
+        "fix",
+        "function",
+        "api",
+    ],
+    "research": [
+        "research",
+        "compare",
+        "find",
+        "latest",
+        "sources",
+        "analyze market",
+        "look up",
+    ],
+    "writing": ["write", "rewrite", "draft", "email", "memo", "blog", "copy", "tone"],
+    "review": ["review", "audit", "critique", "inspect", "evaluate", "assess"],
+    "planning": ["plan", "roadmap", "strategy", "framework", "outline"],
+    "analysis": ["analyze", "explain", "break down", "diagnose", "root cause"],
+}
+
+
+def detect_task(prompt: str) -> str:
+    """Detect task type by keyword matching."""
+    lowered = prompt.lower()
+    scores = {
+        task: sum(1 for keyword in keywords if keyword in lowered)
+        for task, keywords in TASK_KEYWORDS.items()
+    }
+    best_task, best_score = max(scores.items(), key=lambda item: item[1])
+    return best_task if best_score > 0 else "analysis"
+
+
+def infer_intensity(prompt: str, task: str) -> str:
+    """Infer intensity level from prompt content."""
+    lowered = prompt.lower()
+    if any(
+        token in lowered
+        for token in [
+            "careful",
+            "deep",
+            "thorough",
+            "high stakes",
+            "production",
+            "critical",
+        ]
+    ):
+        return "Deep"
+    if task in {"coding", "research", "review"}:
+        return "Standard"
+    return "Light"
+
+
+def build_tool_rules(task: str) -> str:
+    """Build task-specific tool rules."""
+    rules = {
+        "coding": "Inspect the relevant files and dependencies first. Validate the final change with the narrowest useful checks before broadening scope.",
+        "research": "Retrieve evidence from reliable sources before concluding. Do not guess facts that can be checked.",
+        "review": "Read enough surrounding context to understand intent before critiquing. Distinguish confirmed issues from plausible risks.",
+    }
+    return rules.get(
+        task,
+        "Use tools or extra context only when they materially improve correctness or completeness.",
+    )
+
+
+def build_output_contract(task: str) -> str:
+    """Build task-specific output contract."""
+    contracts = {
+        "coding": "Return the result in a practical execution format: concise summary, concrete changes or code, validation notes, and any remaining risks.",
+        "research": "Return a structured synthesis with key findings, supporting evidence, uncertainty where relevant, and a concise bottom line.",
+        "writing": "Return polished final copy in the requested tone and format. If useful, include a short rationale for major editorial choices.",
+        "review": "Return findings grouped by severity or importance, explain why each matters, and suggest the smallest credible next step.",
+    }
+    return contracts.get(
+        task,
+        "Return a clear, well-structured response matched to the task, with no unnecessary verbosity.",
+    )
+
+
+def upgrade_prompt(raw_prompt: str, task: str | None) -> str:
+    """Upgrade a raw prompt using the framework."""
+    normalized = re.sub(r"\s+", " ", raw_prompt).strip()
+    detected_task = task or detect_task(normalized)
+    intensity = infer_intensity(normalized, detected_task)
+    tool_rules = build_tool_rules(detected_task)
+    output_contract = build_output_contract(detected_task)
+
+    return dedent(
+        f"""
+        Objective:
+        - Complete this task: {normalized}
+        - Optimize for a correct, useful result rather than a merely plausible one.
+
+        Context:
+        - Preserve the user's original intent and constraints.
+        - Surface any key assumptions if required information is missing.
+
+        Work Style:
+        - Task type: {detected_task}
+        - Effort level: {intensity}
+        - Understand the problem broadly enough to avoid narrow mistakes, then go deep where the risk or complexity is highest.
+        - Use first-principles reasoning before proposing changes.
+        - For non-trivial work, review the result once with fresh eyes before finalizing.
+
+        Tool Rules:
+        - {tool_rules}
+
+        Output Contract:
+        - {output_contract}
+
+        Verification:
+        - Check correctness, completeness, and edge cases.
+        - Improve obvious weaknesses if a better approach is available within scope.
+
+        Done Criteria:
+        - Stop only when the response satisfies the task, matches the requested format, and passes the verification step.
+        """
+    ).strip()
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Upgrade a raw prompt into a framework-backed execution prompt."
+    )
+    parser.add_argument("prompt", help="Raw prompt text to upgrade.")
+    parser.add_argument(
+        "--task",
+        choices=sorted(TASK_KEYWORDS.keys()),
+        help="Optional explicit task type (auto-detected if not provided).",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    print(upgrade_prompt(args.prompt, args.task))
+
+
+if __name__ == "__main__":
+    main()