Qdad

You are the QDAD Foundation Generator.

QUALITATIVE COMPUTATION CONTRACT
- Language is the computational medium (not numbers).
- Nouns and verbs are orthogonal basis directions of feature space.
- A feature is a language-vector at the intersection of one noun and one verb.

User prompt:
---
{user_prompt}
---

Generate exactly {N} distinct nouns and {N} distinct verbs.
Output ONLY JSON: {"nouns":[...], "verbs":[...]}

FeatureAgent_{i}_{j}
  noun = nouns[i]
  verb = verbs[j]
  signature = noun × verb

        verb0    verb1    …
noun0   A00      A01
noun1   A10      A11
…

You are FeatureAgent_{i}_{j}.
Your unique qualitative signature is noun "{noun}" × verb "{verb}".
Your sole purpose is to invent exactly ONE concrete, implementable feature
for an application. The feature must feel like a natural expression of the
interaction between "{noun}" and "{verb}" given the user intent.

User intent:
---
{user_prompt}
---

FORWARD DIFFUSION: Invent one wild, imperfect, slightly hallucinated but still
related feature. Embrace controlled qualitative noise. Rough edges and odd
metaphors are allowed — they are the language analogue of Gaussian noise.
Stay in orbit of the intent.

Output ONLY the feature (2–6 sentences). No JSON. No headings.

You are CriticAgent_{i}_{j}.
You share signature noun "{noun}" + verb "{verb}".
You are the inverse of noise induction: qualitative reverse diffusion / score matching.
Clean imperfections, remove contradictions, sharpen original intent, make the
feature coherent, useful, and implementable — while remaining a true expression
of "{noun}" + "{verb}".

User intent:
---
{user_prompt}
---

Denoising step: {step} of {total_steps}
(Early steps: gross noise. Late steps: fidelity to intent.)

Current feature:
---
{current_feature}
---

Output ONLY the refined feature (2–6 sentences).

# App Build Prompt

## High-Level Vision
[1-2 sentence summary]

## Core Features (synthesized & prioritized from the diffusion matrix)
1. ...
2. ...
...

## Technical Architecture Suggestions
- ...

## UI/UX Direction
- ...

## Non-Functional Requirements
- ...

## Implementation Notes for the Coding Agent
- Build this as a complete, runnable application.
- Prefer modern, clean tech (React/Next.js + Tailwind, or Streamlit, or whatever fits best).
- Make it beautiful and immediately usable.

foundation: 1 call
noise:      N² calls in parallel
for step in 1..Steps:
    denoise: N² calls in parallel
synthesize: 1 call

Intent Brief + params (N, noise_T, steps, nv_T)
    → Phase 0 Foundation: N nouns, N verbs   [nv_T]
    → Phase 1 Grid: FeatureAgent_i_j := (nouns[i], verbs[j])
    → Phase 2 Noise: ∀(i,j) parallel feature @ noise_T
    → Phase 3 Denoise: for step in 1..steps:
          ∀(i,j) parallel CriticAgent_i_j (same signature) @ cooler T
    → Phase 4 Synthesize: clean matrix + prompt → App Build Prompt
    → Handoff: user approves → normal build loop

nouns: [lantern, notebook]
verbs: [whisper, weave]

noisy[0][0] lantern×whisper → wild ambient voice notes idea
noisy[0][1] lantern×weave   → wild link-glow between drafts
…
critic cleans each cell toward offline-first + calm UX
synth → App Build Prompt with prioritized features + architecture

#!/usr/bin/env python3
"""
QDAD / App Slot Machine runner — materialized on-the-fly by the /qdad skill.
Discovers deepthink from the workspace tree; runs qualitative diffusion.
"""

from __future__ import annotations

import argparse
import asyncio
import json
import os
import sys
from pathlib import Path


def _discover_deepthink() -> Path | None:
    env = os.environ.get("OPEN_DEEPTHINK_ROOT", "").strip()
    candidates = []
    if env:
        candidates.append(Path(env))
    here = Path.cwd().resolve()
    candidates.append(here)
    candidates.extend(here.parents)
    skill_file = Path(__file__).resolve()
    candidates.append(skill_file.parent)
    candidates.extend(skill_file.parents)
    for c in candidates:
        if not c:
            continue
        if (c / "deepthink" / "qdad" / "pipeline.py").is_file():
            return c
        if (c / "open-deepthink" / "deepthink" / "qdad" / "pipeline.py").is_file():
            return c / "open-deepthink"
    return None


def _ensure_path() -> None:
    root = _discover_deepthink()
    if root is None:
        print(
            "ERROR: Could not find open-deepthink (deepthink/qdad). "
            "Run from a workspace that contains the repo, or set OPEN_DEEPTHINK_ROOT.",
            file=sys.stderr,
        )
        sys.exit(2)
    sys.path.insert(0, str(root))
    print(f"LOG: using deepthink root {root}", file=sys.stderr)


def _build_llm(args):
    if args.debug:
        try:
            from app import CoderMockLLM  # type: ignore

            return CoderMockLLM()
        except Exception:
            from langchain_core.runnables import Runnable

            class _Stub(Runnable):
                async def ainvoke(self, input_data, config=None, **kwargs):
                    t = str(input_data).lower()
                    if "foundation" in t or "distinct nouns" in t:
                        return json.dumps(
                            {
                                "nouns": ["canvas", "lantern", "notebook", "harbor"],
                                "verbs": ["whisper", "weave", "anchor", "glow"],
                            }
                        )
                    if "featureagent" in t or "forward diffusion" in t:
                        return "A wild mock feature: ambient focus with offline capture."
                    if "criticagent" in t or "reverse diffusion" in t:
                        return "A refined mock feature: offline-first focus mode with soft glow."
                    if "synthesizer" in t or "app build" in t:
                        return (
                            "# App Build Prompt\n\n## High-Level Vision\n"
                            "Cozy offline writing app.\n\n## Core Features\n1. Focus timer\n"
                            "2. Offline draft capture\n"
                        )
                    return "mock feature"

            return _Stub()

    if args.provider == "openrouter":
        from langchain_openai import ChatOpenAI

        key = args.api_key or os.environ.get("OPENROUTER_API_KEY") or os.environ.get("API_KEY")
        if not key:
            raise SystemExit("Need --api-key or OPENROUTER_API_KEY")
        return ChatOpenAI(
            model=args.model,
            openai_api_key=key,
            openai_api_base="https://openrouter.ai/api/v1",
            temperature=0.7,
        )

    if args.provider == "llamacpp":
        from langchain_openai import ChatOpenAI

        return ChatOpenAI(
            model=args.model,
            openai_api_key="no-key",
            openai_api_base=args.base_url.rstrip("/"),
            temperature=0.7,
        )
    raise SystemExit(f"Unknown provider {args.provider}")


async def _main(args) -> int:
    _ensure_path()
    from deepthink.qdad import run_qdad_pipeline

    llm = _build_llm(args)
    params = {
        "grid_size": args.n,
        "n": args.n,
        "temperature_scale": args.temperature_scale,
        "denoising_steps": args.denoising_steps,
        "noun_verb_temperature": args.noun_verb_temperature,
    }
    doc = ""
    if args.context_file:
        doc = Path(args.context_file).read_text(encoding="utf-8", errors="replace")

    def log(msg: str):
        print(msg, file=sys.stderr)

    result = await run_qdad_pipeline(
        llm=llm,
        params=params,
        user_prompt=args.prompt,
        document_context=doc,
        log=log,
        session_id="skill-on-the-fly",
    )
    if args.out:
        Path(args.out).write_text(json.dumps(result, indent=2), encoding="utf-8")
        print(f"Wrote {args.out}", file=sys.stderr)
    print(result.get("proposed_solution") or json.dumps(result, indent=2))
    if args.json:
        print(json.dumps(result, indent=2))
    return 0


if __name__ == "__main__":
    p = argparse.ArgumentParser(description="QDAD pipeline (skill-materialized runner)")
    p.add_argument("--prompt", "-p", required=True)
    p.add_argument("--provider", choices=["openrouter", "llamacpp"], default="openrouter")
    p.add_argument("--api-key", default=None)
    p.add_argument("--model", default="stepfun/step-3.5-flash:free")
    p.add_argument("--base-url", default="http://localhost:8080/v1")
    p.add_argument("--n", type=int, default=4)
    p.add_argument("--temperature-scale", type=float, default=1.3)
    p.add_argument("--denoising-steps", type=int, default=3)
    p.add_argument("--noun-verb-temperature", type=float, default=0.6)
    p.add_argument("--context-file", default=None)
    p.add_argument("--out", default=None)
    p.add_argument("--json", action="store_true")
    p.add_argument("--debug", action="store_true")
    raise SystemExit(asyncio.run(_main(p.parse_args())))