tesserakit-app 0.3.1__tar.gz

tesserakit_app-0.3.1/.gitignore

@@ -0,0 +1,8 @@
+.venv/
+__pycache__/
+*.pyc
+dist/
+build/
+*.egg-info/
+out/
+.DS_Store

tesserakit_app-0.3.1/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: tesserakit-app
+Version: 0.3.1
+Summary: Tessera app: orchestrate the job packs over a project and build a self-contained HTML dashboard.
+Author: Tessera
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Requires-Dist: rich>=13.7
+Requires-Dist: tesserakit-core>=0.1.0
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# tesserakit-app
+
+The Tessera app: run the whole hub over a project and get one browsable dashboard.
+
+`tessera-app` is the unifying surface over the job packs. It detects which packs apply to a project, runs them, and renders all their artifacts into a single self-contained HTML dashboard. No server, no build step, no extra dependencies.
+
+It is a **CLI-only plugin**: it registers commands under `tessera.commands` and orchestrates JobPacks, but is not itself a JobPack. (This is the first real use of the deliberate split between the `tessera.commands` and `tessera.jobpacks` entry-point groups.)
+
+## Commands
+
+```bash
+tessera detect --input .              # show which packs apply, without running
+tessera run --input . --output run    # run applicable packs + build dashboard
+tessera dashboard --input run         # (re)build the HTML dashboard from a run
+```
+
+## What `run` does
+
+1. **Detects** applicable packs by inspecting the project:
+   - `.prompt.md` / `PROMPT.md` → prompts
+   - `SKILL.md` → skills
+   - `.recipe.md` / `RECIPE.md` → recipes
+   - `.curl` / curl `.sh` → api
+   - `corpus/` + a `queries.*` file → rag
+   - any `.csv` → evals (task `generic`)
+   - source files or a dependency manifest → repo
+2. **Runs** each applicable pack into `output/<pack>/`, continuing past any pack that fails.
+3. **Writes** `run_manifest.json` summarizing record/finding counts and artifacts.
+4. **Builds** `output/index.html`: a dashboard with headline cards and every pack's reports, rendered from Markdown to HTML in the browser-ready file.
+
+## Notes
+
+- The orchestrator never raises on a single pack's failure; it records the error and moves on, so one bad input does not sink the whole run.
+- The dashboard is fully self-contained (inline CSS, no JS, no external assets) so it can be committed, emailed, or served as a static file.
+- For full control over a single pack (e.g. a specific eval task type or column overrides), use that pack's own command (`tessera evals compile ...`).

tesserakit_app-0.3.1/README.md

@@ -0,0 +1,35 @@
+# tesserakit-app
+
+The Tessera app: run the whole hub over a project and get one browsable dashboard.
+
+`tessera-app` is the unifying surface over the job packs. It detects which packs apply to a project, runs them, and renders all their artifacts into a single self-contained HTML dashboard. No server, no build step, no extra dependencies.
+
+It is a **CLI-only plugin**: it registers commands under `tessera.commands` and orchestrates JobPacks, but is not itself a JobPack. (This is the first real use of the deliberate split between the `tessera.commands` and `tessera.jobpacks` entry-point groups.)
+
+## Commands
+
+```bash
+tessera detect --input .              # show which packs apply, without running
+tessera run --input . --output run    # run applicable packs + build dashboard
+tessera dashboard --input run         # (re)build the HTML dashboard from a run
+```
+
+## What `run` does
+
+1. **Detects** applicable packs by inspecting the project:
+   - `.prompt.md` / `PROMPT.md` → prompts
+   - `SKILL.md` → skills
+   - `.recipe.md` / `RECIPE.md` → recipes
+   - `.curl` / curl `.sh` → api
+   - `corpus/` + a `queries.*` file → rag
+   - any `.csv` → evals (task `generic`)
+   - source files or a dependency manifest → repo
+2. **Runs** each applicable pack into `output/<pack>/`, continuing past any pack that fails.
+3. **Writes** `run_manifest.json` summarizing record/finding counts and artifacts.
+4. **Builds** `output/index.html`: a dashboard with headline cards and every pack's reports, rendered from Markdown to HTML in the browser-ready file.
+
+## Notes
+
+- The orchestrator never raises on a single pack's failure; it records the error and moves on, so one bad input does not sink the whole run.
+- The dashboard is fully self-contained (inline CSS, no JS, no external assets) so it can be committed, emailed, or served as a static file.
+- For full control over a single pack (e.g. a specific eval task type or column overrides), use that pack's own command (`tessera evals compile ...`).

tesserakit_app-0.3.1/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["hatchling>=1.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tesserakit-app"
+version = "0.3.1"
+description = "Tessera app: orchestrate the job packs over a project and build a self-contained HTML dashboard."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "Tessera" }]
+dependencies = [
+  "tesserakit-core>=0.1.0",
+  "typer>=0.12",
+  "rich>=13.7",
+]
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Environment :: Console",
+  "Intended Audience :: Developers",
+  "Programming Language :: Python :: 3",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=8.0"]
+
+[project.entry-points."tessera.commands"]
+app = "tessera_app.cli:register"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/tessera_app"]

tesserakit_app-0.3.1/src/tessera_app/__init__.py

@@ -0,0 +1,3 @@
+"""Tessera app: orchestrator + dashboard over the job packs."""
+
+__version__ = "0.3.1"

tesserakit_app-0.3.1/src/tessera_app/cli.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from tessera_app.dashboard import build_dashboard
+from tessera_app.detect import detect_packs
+from tessera_app.orchestrator import run_project
+
+console = Console()
+app = typer.Typer(help="Run the whole Tessera hub over a project and build a dashboard.")
+
+
+@app.command("detect")
+def detect_cmd(
+    input: Path = typer.Option(Path("."), "--input", "-i", exists=True, help="Project directory."),
+) -> None:
+    """Show which packs apply to a project, without running them."""
+    detections = detect_packs(input)
+    table = Table(title="Applicable Packs")
+    table.add_column("Pack")
+    table.add_column("Why")
+    for d in detections:
+        table.add_row(d.pack, d.reason)
+    if not detections:
+        console.print("[yellow]No packs detected for this project.[/yellow]")
+        return
+    console.print(table)
+
+
+@app.command("run")
+def run_cmd(
+    input: Path = typer.Option(Path("."), "--input", "-i", exists=True, help="Project directory."),
+    output: Path = typer.Option(Path("tessera_run"), "--output", "-o", help="Output directory."),
+    only: str = typer.Option("", "--only", help="Comma-separated pack names to limit the run."),
+    dashboard: bool = typer.Option(True, "--dashboard/--no-dashboard", help="Build an HTML dashboard after the run."),
+) -> None:
+    """Detect applicable packs, run them, and (by default) build a dashboard."""
+    only_list = [s.strip() for s in only.split(",") if s.strip()] or None
+    results = run_project(input, output, only=only_list)
+
+    table = Table(title="Tessera Run")
+    table.add_column("Pack")
+    table.add_column("Status")
+    table.add_column("Records", justify="right")
+    table.add_column("Findings", justify="right")
+    table.add_column("Errors", justify="right")
+    for r in results:
+        status = "ok" if r.ok else "FAILED"
+        table.add_row(r.pack, status, str(r.record_count), str(r.finding_count), str(r.error_count))
+    console.print(table)
+
+    if not results:
+        console.print("[yellow]No packs were applicable.[/yellow]")
+        return
+
+    if dashboard:
+        html_path = build_dashboard(output)
+        console.print(f"[green]Dashboard:[/green] {html_path}")
+
+
+@app.command("dashboard")
+def dashboard_cmd(
+    input: Path = typer.Option(..., "--input", "-i", exists=True, help="A tessera run output directory (contains run_manifest.json)."),
+    output: Path = typer.Option(None, "--output", "-o", help="HTML path (default: <input>/index.html)."),
+) -> None:
+    """Build (or rebuild) the HTML dashboard from a run output directory."""
+    html_path = build_dashboard(input, output)
+    console.print(f"[green]Dashboard:[/green] {html_path}")
+
+
+def register(root_app: typer.Typer) -> None:
+    # tessera-app contributes top-level commands rather than a subgroup.
+    root_app.command("run")(run_cmd)
+    root_app.command("detect")(detect_cmd)
+    root_app.command("dashboard")(dashboard_cmd)

tesserakit_app-0.3.1/src/tessera_app/dashboard.py

@@ -0,0 +1,124 @@
+"""Build a self-contained HTML dashboard from a run output directory."""
+
+from __future__ import annotations
+
+import html
+import json
+from pathlib import Path
+
+from tessera_app.markdown import render_markdown
+
+_CSS = """
+:root{--bg:#0f1115;--panel:#171a21;--ink:#e6e8eb;--muted:#9aa3af;--line:#262b35;--accent:#6ea8fe;--ok:#3fb950;--warn:#d29922;--err:#f85149}
+*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--ink);font:15px/1.55 ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+header{padding:28px 32px;border-bottom:1px solid var(--line)}
+h1{margin:0;font-size:22px}h2{margin:28px 0 10px;font-size:18px}h3{margin:18px 0 8px;font-size:15px;color:var(--muted)}
+.sub{color:var(--muted);margin-top:6px}
+.wrap{display:flex;gap:0;min-height:calc(100vh - 86px)}
+nav{width:200px;flex:none;border-right:1px solid var(--line);padding:18px 0}
+nav a{display:block;padding:8px 24px;color:var(--ink);text-decoration:none;border-left:2px solid transparent}
+nav a:hover{background:var(--panel);border-left-color:var(--accent)}
+main{flex:1;padding:24px 32px;max-width:980px}
+.cards{display:flex;flex-wrap:wrap;gap:12px;margin:12px 0 4px}
+.card{background:var(--panel);border:1px solid var(--line);border-radius:10px;padding:14px 16px;min-width:120px}
+.card .k{color:var(--muted);font-size:12px;text-transform:uppercase;letter-spacing:.04em}
+.card .v{font-size:22px;font-weight:600;margin-top:4px}
+.badge{display:inline-block;padding:2px 8px;border-radius:999px;font-size:12px;font-weight:600}
+.b-ok{background:rgba(63,185,80,.15);color:var(--ok)}.b-err{background:rgba(248,81,73,.15);color:var(--err)}
+section.pack{background:var(--panel);border:1px solid var(--line);border-radius:12px;padding:8px 20px 18px;margin:18px 0}
+table{border-collapse:collapse;width:100%;margin:8px 0;font-size:13px}
+th,td{border:1px solid var(--line);padding:6px 10px;text-align:left}th{background:#1d2230;color:var(--muted)}
+code{background:#1d2230;padding:1px 5px;border-radius:4px;font-size:13px}
+pre.code{background:#0b0d11;border:1px solid var(--line);border-radius:8px;padding:12px;overflow:auto;font-size:12.5px}
+ul{margin:6px 0 6px 18px}details{margin:8px 0}summary{cursor:pointer;color:var(--accent)}
+.report{border-top:1px solid var(--line);margin-top:14px;padding-top:6px}
+footer{color:var(--muted);padding:24px 32px;border-top:1px solid var(--line);font-size:13px}
+"""
+
+_REPORT_ORDER = [
+    "index.md", "validation_report.md", "coverage_report.md",
+    "data_quality_report.md", "dependencies_report.md",
+    "execution_plans.md", "redactions_report.md", "retrieval_targets.md",
+]
+
+
+def build_dashboard(run_dir: Path, output_html: Path | None = None) -> Path:
+    """Render run_dir into a single self-contained index.html. Returns its path."""
+    run_dir = Path(run_dir)
+    manifest_path = run_dir / "run_manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8")) if manifest_path.exists() else {"project": str(run_dir), "packs": []}
+    packs = manifest.get("packs", [])
+
+    nav = "".join(f"<a href='#{p['pack']}'>{html.escape(p['pack'])}</a>" for p in packs)
+
+    total_records = sum(p.get("record_count", 0) for p in packs)
+    total_findings = sum(p.get("finding_count", 0) for p in packs)
+    total_errors = sum(p.get("error_count", 0) for p in packs)
+
+    cards = _cards({
+        "Packs run": len([p for p in packs if p.get("ok")]),
+        "Records": total_records,
+        "Findings": total_findings,
+        "Errors": total_errors,
+    })
+
+    sections = "".join(_pack_section(run_dir, p) for p in packs)
+    if not packs:
+        sections = "<p class='sub'>No packs were applicable to this project.</p>"
+
+    doc = f"""<!doctype html>
+<html lang="en"><head><meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Tessera Dashboard</title><style>{_CSS}</style></head>
+<body>
+<header><h1>Tessera Dashboard</h1>
+<div class="sub">Project: <code>{html.escape(str(manifest.get('project','')))}</code></div>
+{cards}</header>
+<div class="wrap"><nav>{nav}</nav><main>{sections}</main></div>
+<footer>Generated by tessera-app. Self-contained; no server required.</footer>
+</body></html>"""
+
+    out = output_html or (run_dir / "index.html")
+    out.write_text(doc, encoding="utf-8")
+    return out
+
+
+def _cards(metrics: dict[str, int]) -> str:
+    items = "".join(f"<div class='card'><div class='k'>{html.escape(k)}</div><div class='v'>{v}</div></div>"
+                    for k, v in metrics.items())
+    return f"<div class='cards'>{items}</div>"
+
+
+def _pack_section(run_dir: Path, p: dict) -> str:
+    name = p.get("pack", "")
+    status = ("<span class='badge b-ok'>ok</span>" if p.get("ok")
+              else f"<span class='badge b-err'>failed</span>")
+    head = (f"<section class='pack' id='{html.escape(name)}'>"
+            f"<h2>{html.escape(name)} {status}</h2>"
+            f"<div class='sub'>{html.escape(p.get('reason',''))}</div>")
+
+    if not p.get("ok"):
+        return head + f"<p class='b-err'>{html.escape(p.get('error',''))}</p></section>"
+
+    head += _cards({
+        "Records": p.get("record_count", 0),
+        "Findings": p.get("finding_count", 0),
+        "Errors": p.get("error_count", 0),
+    })
+
+    pack_dir = Path(p.get("output_dir", "")) if p.get("output_dir") else run_dir / name
+    reports = sorted(
+        (a for a in p.get("artifacts", []) if a.endswith(".md")),
+        key=lambda a: _REPORT_ORDER.index(a) if a in _REPORT_ORDER else 99,
+    )
+    body = ""
+    for fname in reports:
+        fpath = pack_dir / fname
+        if not fpath.exists():
+            continue
+        rendered = render_markdown(fpath.read_text(encoding="utf-8"))
+        open_attr = " open" if fname in ("index.md", "validation_report.md") else ""
+        body += (f"<details{open_attr}><summary>{html.escape(fname)}</summary>"
+                 f"<div class='report'>{rendered}</div></details>")
+
+    return head + body + "</section>"

tesserakit_app-0.3.1/src/tessera_app/detect.py

@@ -0,0 +1,157 @@
+"""Detect which job packs apply to a project directory."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+_IGNORE = {
+    ".git", ".venv", "venv", "node_modules", "__pycache__", ".pytest_cache",
+    "dist", "build", ".tox", "target", ".mypy_cache", ".ruff_cache",
+}
+
+
+@dataclass
+class Detection:
+    pack: str
+    reason: str
+    input_path: Path
+    options: dict[str, Any] = field(default_factory=dict)
+
+
+def _walk(root: Path):
+    for p in root.rglob("*"):
+        if any(part in _IGNORE for part in p.relative_to(root).parts):
+            continue
+        yield p
+
+
+def detect_packs(project: Path) -> list[Detection]:
+    """Return the detections that apply to ``project`` (a directory)."""
+    project = project if project.is_dir() else project.parent
+    files = [p for p in _walk(project) if p.is_file()]
+    names = {p.name.lower() for p in files}
+    detections: list[Detection] = []
+
+    def any_suffix(*suffixes: str) -> bool:
+        return any(p.suffix.lower() in suffixes for p in files)
+
+    def any_named(predicate) -> bool:
+        return any(predicate(p) for p in files)
+
+    # prompts
+    if any_named(lambda p: p.name.endswith(".prompt.md") or p.name.lower() == "prompt.md"):
+        detections.append(Detection("prompts", "found .prompt.md / PROMPT.md files", project))
+
+    # skills
+    if "skill.md" in names:
+        detections.append(Detection("skills", "found SKILL.md files", project))
+
+    # recipes
+    if any_named(lambda p: p.name.endswith(".recipe.md") or p.name.lower() == "recipe.md"):
+        detections.append(Detection("recipes", "found .recipe.md / RECIPE.md files", project))
+
+    # api (curl files)
+    if any_suffix(".curl") or any_named(lambda p: p.suffix.lower() == ".sh" and "curl" in _safe_head(p)):
+        detections.append(Detection("api", "found curl/.sh files", project))
+
+    # rag (corpus/ + queries.*)
+    corpus = project / "corpus"
+    has_queries = any(p.name.lower() in ("queries.jsonl", "queries.yaml", "queries.yml") for p in files)
+    if corpus.is_dir() and has_queries:
+        detections.append(Detection("rag", "found corpus/ and a queries file", project))
+
+    # evals (first CSV)
+    csvs = sorted(p for p in files if p.suffix.lower() == ".csv")
+    if csvs:
+        detections.append(Detection("evals", f"found CSV: {csvs[0].name}", csvs[0], {"task_type": "generic"}))
+
+    # repo (a manifest or any source file => treat as a repository)
+    manifest_names = {"pyproject.toml", "package.json", "cargo.toml", "go.mod", "requirements.txt"}
+    source_suffixes = {".py", ".js", ".ts", ".go", ".rs", ".java", ".rb"}
+    if names & manifest_names or any_suffix(*source_suffixes):
+        detections.append(Detection("repo", "found source files / a dependency manifest", project))
+
+    # deps (a dependency manifest => audit pinning/duplicates)
+    if names & manifest_names or any_named(lambda p: p.name.lower().startswith("requirements") and p.name.lower().endswith(".txt")):
+        detections.append(Detection("deps", "found a dependency manifest", project))
+
+    # i18n (a locales/ or i18n/ directory of JSON files)
+    if (project / "locales").is_dir() or (project / "i18n").is_dir():
+        detections.append(Detection("i18n", "found a locales/ or i18n/ directory", project))
+
+    # config (any .env-style file present)
+    if any_named(lambda p: p.name.lower() == ".env" or p.name.lower().startswith(".env.") or p.name.lower().endswith(".env")):
+        detections.append(Detection("config", "found .env / .env.example files", project))
+
+    # schema (a *.schema.json or a json mentioning $schema/properties)
+    schema_file = next(
+        (p for p in files
+         if p.name.lower().endswith(".schema.json")
+         or (p.suffix.lower() == ".json" and '"$schema"' in _safe_head(p) and "openapi" not in _safe_head(p))),
+        None,
+    )
+    if schema_file is not None:
+        detections.append(Detection("schema", "found JSON Schema document(s)", project))
+
+    # openapi (a yaml/json spec mentioning openapi/swagger)
+    spec = next(
+        (p for p in files
+         if p.suffix.lower() in (".yaml", ".yml", ".json")
+         and ("openapi" in _safe_head(p) or "swagger" in _safe_head(p))),
+        None,
+    )
+    if spec is not None:
+        detections.append(Detection("openapi", f"found an OpenAPI/Swagger spec: {spec.name}", spec))
+
+    # docs (any Python source -> docstring coverage)
+    if any_suffix(".py"):
+        detections.append(Detection("docs", "found Python source for docstring coverage", project))
+
+    # links (any markdown files -> link check)
+    if any_suffix(".md", ".markdown"):
+        detections.append(Detection("links", "found markdown files", project))
+
+    # glossary (any source or docs -> vocabulary extraction)
+    if any_suffix(".py", ".js", ".ts", ".go", ".rs", ".java", ".rb", ".md"):
+        detections.append(Detection("glossary", "found source/docs for vocabulary analysis", project))
+
+    # tests (python test files present)
+    if any_named(lambda p: p.suffix == ".py" and (p.name.startswith("test_") or p.name.endswith("_test.py"))):
+        detections.append(Detection("tests", "found Python test files", project))
+
+    # sql (any .sql files)
+    if any_suffix(".sql"):
+        detections.append(Detection("sql", "found .sql files", project))
+
+    # dockerfile (any Dockerfile / *.dockerfile)
+    if any_named(lambda p: p.name.lower() == "dockerfile" or p.name.lower().startswith("dockerfile.") or p.name.lower().endswith(".dockerfile")):
+        detections.append(Detection("dockerfile", "found a Dockerfile", project))
+
+    # todo (any common source/doc files -> marker backlog)
+    if any_suffix(".py", ".js", ".ts", ".go", ".rs", ".java", ".rb", ".md", ".sql", ".sh"):
+        detections.append(Detection("todo", "found source/doc files to scan for markers", project))
+
+    # license (a LICENSE file or a manifest that may declare one)
+    if any_named(lambda p: p.name.lower().startswith(("license", "licence")) or p.name.lower() == "copying") or (names & manifest_names):
+        detections.append(Detection("license", "found a LICENSE file or a manifest", project))
+
+    # gha (GitHub Actions workflows)
+    if (project / ".github" / "workflows").is_dir():
+        detections.append(Detection("gha", "found .github/workflows", project))
+
+    # changelog (a git repo, or a commits.jsonl)
+    if (project / ".git").exists():
+        detections.append(Detection("changelog", "found a git repository", project))
+    elif any(p.name.lower() == "commits.jsonl" for p in files):
+        detections.append(Detection("changelog", "found commits.jsonl", project))
+
+    return detections
+
+
+def _safe_head(path: Path, n: int = 400) -> str:
+    try:
+        return path.read_text(encoding="utf-8")[:n]
+    except (OSError, UnicodeDecodeError):
+        return ""

tesserakit_app-0.3.1/src/tessera_app/markdown.py

@@ -0,0 +1,91 @@
+"""A small, dependency-free Markdown-to-HTML renderer.
+
+Handles the subset Tessera reports use: ATX headings, pipe tables, bullet
+lists, fenced code blocks, bold, and inline code. Not a general Markdown
+implementation; it is tuned to the artifacts this hub produces.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+
+_BOLD = re.compile(r"\*\*(.+?)\*\*")
+_CODE = re.compile(r"`([^`]+)`")
+
+
+def _inline(text: str) -> str:
+    text = html.escape(text)
+    text = _BOLD.sub(r"<strong>\1</strong>", text)
+    text = _CODE.sub(r"<code>\1</code>", text)
+    return text
+
+
+def _is_table_sep(line: str) -> bool:
+    s = line.strip()
+    return bool(s) and set(s) <= set("|:- ") and "-" in s
+
+
+def render_markdown(md: str) -> str:
+    lines = md.splitlines()
+    out: list[str] = []
+    i = 0
+    n = len(lines)
+
+    while i < n:
+        line = lines[i]
+        stripped = line.strip()
+
+        # fenced code
+        if stripped.startswith("```"):
+            i += 1
+            code: list[str] = []
+            while i < n and not lines[i].strip().startswith("```"):
+                code.append(html.escape(lines[i]))
+                i += 1
+            i += 1  # skip closing fence
+            out.append("<pre class='code'>" + "\n".join(code) + "</pre>")
+            continue
+
+        # headings
+        m = re.match(r"^(#{1,6})\s+(.*)$", line)
+        if m:
+            level = len(m.group(1))
+            out.append(f"<h{level}>{_inline(m.group(2).strip())}</h{level}>")
+            i += 1
+            continue
+
+        # tables: a header row followed by a separator row
+        if stripped.startswith("|") and i + 1 < n and _is_table_sep(lines[i + 1]):
+            header = [c.strip() for c in stripped.strip("|").split("|")]
+            i += 2
+            rows: list[list[str]] = []
+            while i < n and lines[i].strip().startswith("|"):
+                rows.append([c.strip() for c in lines[i].strip().strip("|").split("|")])
+                i += 1
+            thead = "".join(f"<th>{_inline(h)}</th>" for h in header)
+            body = ""
+            for r in rows:
+                body += "<tr>" + "".join(f"<td>{_inline(c)}</td>" for c in r) + "</tr>"
+            out.append(f"<table><thead><tr>{thead}</tr></thead><tbody>{body}</tbody></table>")
+            continue
+
+        # bullet list
+        if re.match(r"^\s*[-*]\s+", line):
+            items: list[str] = []
+            while i < n and re.match(r"^\s*[-*]\s+", lines[i]):
+                items.append("<li>" + _inline(re.sub(r"^\s*[-*]\s+", "", lines[i])) + "</li>")
+                i += 1
+            out.append("<ul>" + "".join(items) + "</ul>")
+            continue
+
+        # blank line
+        if not stripped:
+            i += 1
+            continue
+
+        # paragraph
+        out.append(f"<p>{_inline(stripped)}</p>")
+        i += 1
+
+    return "\n".join(out)

tesserakit_app-0.3.1/src/tessera_app/orchestrator.py

@@ -0,0 +1,87 @@
+"""Run the applicable job packs over a project and summarize the run."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+from tessera_core.models import RunContext
+from tessera_core.plugins import load_jobpacks
+from tessera_core.workspace import write_json
+
+from tessera_app.detect import Detection, detect_packs
+
+
+@dataclass
+class PackResult:
+    pack: str
+    reason: str
+    ok: bool
+    record_count: int = 0
+    finding_count: int = 0
+    error_count: int = 0
+    artifacts: list[str] = field(default_factory=list)
+    output_dir: str = ""
+    error: str = ""
+
+
+def run_project(project: Path, output_dir: Path, only: list[str] | None = None) -> list[PackResult]:
+    """Detect applicable packs, run each into output_dir/<pack>/, and summarize."""
+    detections = detect_packs(project)
+    if only:
+        detections = [d for d in detections if d.pack in only]
+
+    packs = load_jobpacks()
+    results: list[PackResult] = []
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    for det in detections:
+        pack = packs.get(det.pack)
+        if pack is None:
+            results.append(PackResult(det.pack, det.reason, ok=False, error="pack not installed"))
+            continue
+        pack_out = output_dir / det.pack
+        ctx = RunContext(job_name=det.pack, output_dir=pack_out)
+        try:
+            artifacts = pack.run(input_path=det.input_path, ctx=ctx, options=dict(det.options))
+            findings = ctx.metadata.get("findings", []) or []
+            errors = sum(1 for f in findings if getattr(f, "severity", "") == "error")
+            results.append(
+                PackResult(
+                    pack=det.pack,
+                    reason=det.reason,
+                    ok=True,
+                    record_count=ctx.metadata.get("record_count", 0),
+                    finding_count=ctx.metadata.get("finding_count", len(findings)),
+                    error_count=errors,
+                    artifacts=[a.name for a in artifacts],
+                    output_dir=str(pack_out),
+                )
+            )
+        except Exception as exc:  # keep the run going; record the failure
+            results.append(PackResult(det.pack, det.reason, ok=False, error=str(exc), output_dir=str(pack_out)))
+
+    _write_manifest(project, output_dir, results)
+    return results
+
+
+def _write_manifest(project: Path, output_dir: Path, results: list[PackResult]) -> None:
+    manifest: dict[str, Any] = {
+        "project": str(project),
+        "packs": [
+            {
+                "pack": r.pack,
+                "reason": r.reason,
+                "ok": r.ok,
+                "record_count": r.record_count,
+                "finding_count": r.finding_count,
+                "error_count": r.error_count,
+                "artifacts": r.artifacts,
+                "output_dir": r.output_dir,
+                "error": r.error,
+            }
+            for r in results
+        ],
+    }
+    write_json(output_dir / "run_manifest.json", manifest)

tesserakit_app-0.3.1/tests/test_app.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from tessera_app.dashboard import build_dashboard
+from tessera_app.detect import detect_packs
+from tessera_app.markdown import render_markdown
+from tessera_app.orchestrator import run_project
+
+# The app orchestrates the other packs; skip cleanly if they aren't installed.
+pytest.importorskip("tessera_repo.pack", reason="job packs not installed")
+pytest.importorskip("tessera_prompts.pack", reason="job packs not installed")
+
+
+def _make_project(root: Path) -> Path:
+    """A small project that triggers several packs at once."""
+    root.mkdir(parents=True, exist_ok=True)
+    (root / "README.md").write_text("# demo\n", encoding="utf-8")
+    (root / "pyproject.toml").write_text(
+        '[project]\nname = "demo"\nversion = "0.3.1"\ndependencies = ["rich"]\n', encoding="utf-8"
+    )
+    (root / "src").mkdir()
+    (root / "src" / "main.py").write_text("def f():\n    return 1\n", encoding="utf-8")
+    # a prompt
+    (root / "hello.prompt.md").write_text(
+        "---\nname: hello\ndescription: Say hello to the user by name.\nversion: 1.0.0\n"
+        "variables:\n  - name: who\n---\nHi {{who}}.\n",
+        encoding="utf-8",
+    )
+    # a CSV for evals
+    (root / "data.csv").write_text(
+        "question,answer\nWhat is 2+2?,4\nCapital of France?,Paris\n", encoding="utf-8"
+    )
+    return root
+
+
+# ---------- markdown renderer ----------
+
+
+def test_markdown_headings_tables_lists_code():
+    md = "# Title\n\n| A | B |\n|---|---|\n| 1 | 2 |\n\n- one\n- two\n\n```\ncode\n```\n\n**bold** and `c`."
+    html = render_markdown(md)
+    assert "<h1>Title</h1>" in html
+    assert "<table>" in html and "<th>A</th>" in html and "<td>1</td>" in html
+    assert "<ul><li>one</li><li>two</li></ul>" in html
+    assert "<pre class='code'>code</pre>" in html
+    assert "<strong>bold</strong>" in html and "<code>c</code>" in html
+
+
+def test_markdown_escapes_html():
+    assert "&lt;script&gt;" in render_markdown("a <script> tag")
+
+
+# ---------- detection ----------
+
+
+def test_detect_multiple_packs(tmp_path: Path):
+    project = _make_project(tmp_path)
+    names = {d.pack for d in detect_packs(project)}
+    assert {"prompts", "evals", "repo"} <= names
+
+
+# ---------- orchestrator ----------
+
+
+def test_run_project_runs_applicable_and_writes_manifest(tmp_path: Path):
+    project = _make_project(tmp_path / "proj")
+    out = tmp_path / "run"
+    results = run_project(project, out)
+
+    packs_run = {r.pack for r in results if r.ok}
+    assert {"prompts", "evals", "repo"} <= packs_run
+
+    manifest = json.loads((out / "run_manifest.json").read_text())
+    assert manifest["packs"]
+    # each ok pack wrote its own subdir with artifacts
+    for r in results:
+        if r.ok:
+            assert (out / r.pack).is_dir()
+
+
+def test_run_then_dashboard_is_self_contained(tmp_path: Path):
+    project = _make_project(tmp_path / "proj")
+    out = tmp_path / "run"
+    run_project(project, out)
+    html_path = build_dashboard(out)
+
+    assert html_path.exists()
+    doc = html_path.read_text(encoding="utf-8")
+    assert "<title>Tessera Dashboard</title>" in doc
+    assert "Tessera Dashboard" in doc
+    # references the packs that ran
+    assert "repo" in doc and "prompts" in doc
+    # self-contained: no external script/style links
+    assert "http://" not in doc and "https://" not in doc
+    assert "<script" not in doc
+
+
+def test_only_filter_limits_run(tmp_path: Path):
+    project = _make_project(tmp_path / "proj")
+    out = tmp_path / "run"
+    results = run_project(project, out, only=["repo"])
+    assert {r.pack for r in results} == {"repo"}