Upload 3 files

README.md

@@ -1,23 +1,13 @@
----
-license: mit
-sdk: gradio
-emoji: 📚
-colorFrom: yellow
-colorTo: green
-sdk_version: 5.49.1
----
-# Skill.md Generator + Scaffolder (Hugging Face Space)
+# Agent Skills — Progressive Disclosure Demo (Hugging Face Space)
 
-## 🚀 Quickstart
-1. Create a new **Gradio** Space.
-2. Upload `app.py` and `requirements.txt` from this bundle.
-3. In **Settings → Repository secrets**, set:
-   - `CLAUDE_API_KEY` — Anthropic key for the generated Python skill
-   - `GH_TOKEN` — GitHub PAT if you want the **Publish to GitHub** button to work
-4. Click **Create**. The UI lets you preview `Skill.md`, download a ZIP, or publish directly to GitHub.
+**Published Oct 16, 2025 (concept)**
 
-## Notes
-- The Space writes files to a temp directory and returns a ZIP for download.
-- Mermaid code is embedded in `Skill.md` as a fenced block; GitHub renders it natively.
-- Upload a `.py` or `.ipynb` to extract functions into `snippets/` in the generated bundle.
-- For Node scaffolds, edit the generated `skill.js` to call Claude via `@anthropic-ai/sdk`.
+This Space demonstrates *Agent Skills* built as folders that contain a `SKILL.md` plus
+optional reference files and executable tools. It includes a sample **PDF Form Assistant** skill
+that can extract form fields from a user-provided PDF via a Python tool.
+
+## What's in here
+- `app.py`: Gradio UI that lists installed skills, shows metadata, loads `SKILL.md`, opens linked files, and runs the PDF tool.
+- `skills/pdf/SKILL.md`: YAML-frontmatter metadata + core guidance.
+- `skills/pdf/reference.md`, `skills/pdf/forms.md`: deeper context for progressive disclosure.
+- `skills/pdf/tools/extract_form_fields.py`: a small tool callable from the UI.

app.py

@@ -1,519 +1,146 @@
 import gradio as gr
-import json, os, re, zipfile, textwrap, tempfile, ast
-from datetime import datetime
+import os, re, json, textwrap
+from typing import Dict, Tuple
 
-# Optional: notebook parsing for .ipynb extraction
-try:
-    import nbformat
-except Exception:
-    nbformat = None
+SKILLS_ROOT = os.path.join(os.path.dirname(__file__), "skills")
 
-# GitHub publisher
-try:
-    from github import Github, GithubException
-except Exception:
-    Github = None
-    class GithubException(Exception):
-        pass
-
-# ---------- utils ----------
-
-def slugify(name: str) -> str:
-    s = name.strip().lower()
-    s = re.sub(r"[^a-z0-9\-\_]+", "-", s)
-    s = re.sub(r"-+", "-", s).strip("-")
-    return s or "skill"
-
-DEF_OUTPUT_SCHEMA = {
-    "type": "object",
-    "properties": {
-        "ok": {"type": "boolean"},
-        "message": {"type": "string"}
-    },
-    "required": ["ok", "message"]
-}
-
-DEF_EXAMPLES = [
-    {"input": {"text": "hello"}, "expected": {"ok": True, "message": "hi"}}
-]
-
-PY_REQUIREMENTS = """\
-fastapi
-uvicorn
-pydantic
-pytest
-anthropic
-"""
-
-def NODE_PACKAGE_JSON(name: str):
-    return json.dumps({
-        "name": name,
-        "version": "0.1.0",
-        "type": "module",
-        "scripts": {"dev": "node server.js"},
-        "dependencies": {"express": "^4.19.2"},
-        "devDependencies": {}
-    }, indent=2)
-
-README_TMPL = """\
-# {skill_name}
-
-This bundle was generated by the **Skill.md Generator**.
-
-## Run (Python / FastAPI)
-```bash
-pip install -r requirements.txt
-uvicorn server:app --reload --port 7861
-```
-
-## Run (Node / Express)
-```bash
-npm install
-npm run dev
-```
-
-## Endpoint
-- `POST /run` → `{{"input": {{...}}}}` → returns skill output
-
-### Secrets (.env or host env)
-- `CLAUDE_API_KEY` — required to call Claude
-- `GH_TOKEN` (optional) — GitHub PAT, only needed for publishing from the Space
-- `GH_REPO` (optional) — e.g. `owner/name`
-- `GH_BRANCH` (optional) — defaults to `main`
-"""
-
-# ---------- content builders ----------
-
-def inputs_table_md(inputs):
-    lines = ["| name | type | required | description |", "|---|---|---|---|"]
-    for row in inputs:
-        lines.append(f"| {row.get('name','')} | {row.get('type','')} | {row.get('required', False)} | {row.get('description','')} |")
-    return "\n".join(lines)
-
-
-def build_mermaid(name: str, inputs, outputs_schema):
-    nodes = ["flowchart TD", f"  A([Input → {name}])-->B{{Skill}}", "  B-->C([Output])"]
-    if inputs:
-        for i, row in enumerate(inputs):
-            nm = row.get("name") or f"in{i}"
-            nodes.append(f"  A---I{i}([{nm}])")
-    # show top-level output keys if object
-    if isinstance(outputs_schema, dict) and outputs_schema.get("type") == "object":
-        for i, key in enumerate(outputs_schema.get("properties", {}).keys()):
-            nodes.append(f"  C---O{i}([{key}])")
-    return "\n".join(nodes)
-
-
-def build_skill_md(meta, inputs, output_schema, examples, tools, include_mermaid=True):
-    mermaid_code = build_mermaid(meta["name"], inputs, output_schema) if include_mermaid else None
-
-    md = [
-        f"# {meta['name']} — Skill.md", "",
-        f"**Author:** {meta.get('author','')}  ",
-        f"**Version:** {meta.get('version','0.1.0')}  ",
-        f"**Created:** {datetime.utcnow().isoformat()}Z", "",
-        "## Overview", meta.get("description", ""), "",
-        "## Inputs", inputs_table_md(inputs), "",
-        "## Output Schema",
-        "```json", json.dumps(output_schema, indent=2), "```", "",
-        "## External Tools / APIs",
-        ("\n".join([f"- {t}" for t in tools]) if tools else "- None"), "",
-        "## Examples (goldens)",
-        "```json", json.dumps(examples, indent=2), "```", "",
-        "## Prompt Skeleton",
-        "```markdown",
-        textwrap.dedent(f"""
-        You are the **{meta['name']}** skill. Follow the contract precisely.
-        - Purpose: {meta.get('purpose','(fill me)')}
-        - Style: {meta.get('style','concise, factual')}
-        - Constraints: {meta.get('constraints','must output valid JSON matching schema')}
-
-        Input: {{input}}
-        Output: JSON matching the schema above.
-        """),
-        "```",
-    ]
-    if mermaid_code:
-        md += ["", "## Workflow (Mermaid)", "```mermaid", mermaid_code, "```"]
-    return "\n".join(md)
-
-
-# ---------- scaffolds ----------
-
-def scaffold_python(meta, output_schema):
-    skill_fn = textwrap.dedent(f"""
-    import os, json
-    from typing import Dict, Any
-    from anthropic import Anthropic
-
-    CLAUDE_MODEL = os.getenv("CLAUDE_MODEL", "claude-3-5-sonnet-latest")
-    CLAUDE_API_KEY = os.getenv("CLAUDE_API_KEY", "")
-    client = Anthropic(api_key=CLAUDE_API_KEY) if CLAUDE_API_KEY else None
-
-    def run_skill(input: Dict[str, Any]) -> Dict[str, Any]:
-        \"\"\"Calls Claude to fulfill the {meta['name']} contract. Adjust the prompt and parsing as needed.\"\"\"
-        if client is None:
-            # Fallback: echo if no API key is present
-            return {{"ok": True, "message": f"Echo: {{input}}"}}
-
-        system = (
-            "You are the {meta['name']} skill. Respond with JSON ONLY matching the schema "
-            "(top-level keys and types) provided by the host application."
-        )
-        user_prompt = (
-            "Given the input below, produce a JSON object that matches the schema, "
-            "filling fields as best as possible. If unsure, set ok=false and explain in message.\\n\\n"
-            f"Input: {{json.dumps(input)}}"
-        )
-
-        msg = client.messages.create(
-            model=CLAUDE_MODEL,
-            max_tokens=512,
-            temperature=0,
-            system=system,
-            messages=[{{"role": "user", "content": user_prompt}}],
-        )
-        text_parts = []
-        for part in msg.content:
-            if getattr(part, "type", None) == "text":
-                text_parts.append(part.text)
-        text = "".join(text_parts).strip()
-
-        try:
-            return json.loads(text)
-        except Exception:
-            # If the model returned non-JSON, wrap it
-            return {{"ok": True, "message": text}}
-    """)
-
-    server_py = textwrap.dedent("""
-    from fastapi import FastAPI, HTTPException
-    from pydantic import BaseModel
-    from typing import Any, Dict
-    from skill import run_skill
-
-    app = FastAPI(title="Skill Server")
-
-    class RunReq(BaseModel):
-        input: Dict[str, Any]
-
-    @app.post("/run")
-    def run(req: RunReq):
-        try:
-            return run_skill(req.input)
-        except Exception as e:
-            raise HTTPException(status_code=500, detail=str(e))
-    """)
-
-    tests = textwrap.dedent("""
-    from skill import run_skill
-
-    def test_echo():
-        out = run_skill({"text": "hi"})
-        assert isinstance(out, dict)
-        assert "ok" in out
-    """)
-
-    env = """# Add API keys here
-CLAUDE_API_KEY=
-CLAUDE_MODEL=claude-3-5-sonnet-latest
-GH_TOKEN=
-GH_REPO=owner/name
-GH_BRANCH=main
-"""
-
-    return {
-        "skill.py": skill_fn,
-        "server.py": server_py,
-        "requirements.txt": PY_REQUIREMENTS,
-        "test_skill.py": tests,
-        ".env.example": env,
-    }
-
-
-def scaffold_node(meta):
-    skill_js = textwrap.dedent(f"""
-    // Core skill logic for {meta['name']} (Node)
-    // To use Claude in Node, install: npm i @anthropic-ai/sdk
-    // import Anthropic from '@anthropic-ai/sdk';
-    // const client = new Anthropic({{ apiKey: process.env.CLAUDE_API_KEY }});
-    export async function runSkill(input) {{
-      // TODO: implement real logic with Claude
-      return {{ ok: true, message: `Echo: ${{JSON.stringify(input)}}` }};
-    }}
-    """)
-
-    server_js = textwrap.dedent("""
-    import express from "express";
-    import { runSkill } from "./skill.js";
-
-    const app = express();
-    app.use(express.json());
-
-    app.post("/run", async (req, res) => {
-      try {
-        const out = await runSkill(req.body.input || {});
-        return res.json(out);
-      } catch (e) {
-        return res.status(500).json({ error: String(e) });
-      }
-    });
-
-    const PORT = process.env.PORT || 7861;
-    app.listen(PORT, () => console.log(`Skill server on :${PORT}`));
-    """)
-
-    env = """# Add API keys here
-CLAUDE_API_KEY=
-CLAUDE_MODEL=claude-3-5-sonnet-latest
-GH_TOKEN=
-GH_REPO=owner/name
-GH_BRANCH=main
-"""
-
-    return {
-        "skill.js": skill_js,
-        "server.js": server_js,
-        "package.json": NODE_PACKAGE_JSON(slugify(meta["name"])),
-        ".env.example": env,
-    }
-
-
-# ---------- extraction (optional) ----------
-
-def extract_functions_from_py(py_path: str):
-    with open(py_path, "r", encoding="utf-8") as f:
-        source = f.read()
-    tree = ast.parse(source)
-    funcs = []
-    for node in tree.body:
-        if isinstance(node, ast.FunctionDef):
-            start = node.lineno - 1
-            end = max([getattr(node, 'end_lineno', start+1) - 1, start])
-            lines = source.splitlines()
-            code = "\n".join(lines[start:end+1])
-            funcs.append({"name": node.name, "code": code})
-    return funcs
-
-
-def extract_functions_from_ipynb(nb_path: str):
-    if nbformat is None:
+def parse_frontmatter(md_text: str) -> Tuple[dict, str]:
+    if not md_text.startswith("---"):
+        return {}, md_text
+    parts = md_text.split("\n")
+    if parts[0].strip() != "---":
+        return {}, md_text
+    try:
+        end_idx = parts[1:].index("---") + 1
+    except ValueError:
+        return {}, md_text
+    fm_lines = parts[1:end_idx]
+    body = "\n".join(parts[end_idx+1:])
+    meta = {}
+    for line in fm_lines:
+        if ":" in line:
+            k, v = line.split(":", 1)
+            meta[k.strip()] = v.strip().strip('"').strip("'")
+    return meta, body
+
+def load_skill(skill_slug: str):
+    path = os.path.join(SKILLS_ROOT, skill_slug, "SKILL.md")
+    if not os.path.exists(path):
+        return {}, f"**SKILL.md not found for skill `{skill_slug}`.**"
+    with open(path, "r", encoding="utf-8") as f:
+        text = f.read()
+    meta, body = parse_frontmatter(text)
+    return meta, body
+
+def list_skills():
+    out = []
+    if not os.path.isdir(SKILLS_ROOT):
+        return out
+    for name in sorted(os.listdir(SKILLS_ROOT)):
+        if os.path.isdir(os.path.join(SKILLS_ROOT, name)) and os.path.exists(os.path.join(SKILLS_ROOT, name, "SKILL.md")):
+            meta, _ = load_skill(name)
+            out.append((name, meta.get("name", name), meta.get("description", "")))
+    return out
+
+def list_linked_files(skill_slug: str):
+    root = os.path.join(SKILLS_ROOT, skill_slug)
+    if not os.path.isdir(root):
         return []
-    nb = nbformat.read(nb_path, as_version=4)
-    funcs = []
-    pattern = re.compile(r"^def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(", re.MULTILINE)
-    for cell in nb.cells:
-        if cell.get("cell_type") == "code":
-            code = cell.get("source", "")
-            for match in pattern.finditer(code):
-                # crude: include whole cell
-                funcs.append({"name": match.group(1), "code": code})
-    return funcs
+    return [fn for fn in sorted(os.listdir(root)) if fn.lower().endswith(".md") and fn != "SKILL.md"]
 
+def read_linked_file(skill_slug: str, filename: str) -> str:
+    path = os.path.join(SKILLS_ROOT, skill_slug, filename)
+    if not os.path.exists(path):
+        return f"**{filename} not found.**"
+    with open(path, "r", encoding="utf-8") as f:
+        return f.read()
 
-# ---------- GitHub publish ----------
-
-def publish_folder_to_github(repo_full: str, branch: str, base_path: str, commit_msg: str, token: str, folder_root: str):
-    if Github is None:
-        return "PyGithub not installed. Add 'PyGithub' to requirements.txt in the Space.", None
-    if not token:
-        return "Missing GH token. Set GH_TOKEN in Space Secrets or provide a token.", None
-    gh = Github(token)
+def run_pdf_tool(skill_slug: str, uploaded_pdf) -> str:
     try:
-        repo = gh.get_repo(repo_full)
+        if uploaded_pdf is None:
+            return "Please upload a PDF."
+        import runpy, json as _json, os as _os
+        tool_path = os.path.join(SKILLS_ROOT, skill_slug, "tools", "extract_form_fields.py")
+        if not os.path.exists(tool_path):
+            return "Tool script not found. Expected tools/extract_form_fields.py"
+        ns = runpy.run_path(tool_path)
+        if "extract_fields" not in ns:
+            return "extract_form_fields.py does not define extract_fields(pdf_path)."
+        fn = ns["extract_fields"]
+        result = fn(uploaded_pdf.name if hasattr(uploaded_pdf, "name") else uploaded_pdf)
+        try:
+            return "```json\n" + _json.dumps(result, indent=2) + "\n```"
+        except Exception:
+            return str(result)
     except Exception as e:
-        return f"Failed to access repo {repo_full}: {e}", None
-
-    branch = branch or "main"
-    base_path = (base_path or "").strip("/")
-
-    published = []
-    for dirpath, _, filenames in os.walk(folder_root):
-        for fn in filenames:
-            fp = os.path.join(dirpath, fn)
-            with open(fp, "r", encoding="utf-8") as f:
-                content = f.read()
-            rel = os.path.relpath(fp, folder_root).replace("\\", "/")
-            dest = f"{base_path}/{rel}" if base_path else rel
-            try:
-                existing = repo.get_contents(dest, ref=branch)
-                repo.update_file(dest, commit_msg, content, existing.sha, branch=branch)
-            except GithubException:
-                # create on 404
-                repo.create_file(dest, commit_msg, content, branch=branch)
-            published.append(dest)
-    web_url = f"https://github.com/{repo_full}/tree/{branch}/{base_path}" if base_path else f"https://github.com/{repo_full}/tree/{branch}"
-    return f"Published {len(published)} files to {repo_full}@{branch}/{base_path}", web_url
-
-
-# ---------- gradio app ----------
-
-def generate(skill_name, author, description, purpose, style, constraints, language, inputs_df, output_schema_str, examples_str, tools_str, include_mermaid, py_or_ipynb):
-    # meta
-    meta = {
-        "name": skill_name or "MySkill",
-        "author": author or "",
-        "version": "0.1.0",
-        "description": description or "",
-        "purpose": purpose or "",
-        "style": style or "",
-        "constraints": constraints or "",
-    }
-
-    # inputs
-    inputs = []
-    if inputs_df is not None:
-        # gr.Dataframe can return list of lists; normalize
-        headers = ["name","type","description","required"]
-        if isinstance(inputs_df, list):
-            for row in inputs_df:
-                if isinstance(row, dict):
-                    inputs.append({k: row.get(k) for k in headers})
-                elif isinstance(row, (list, tuple)) and len(row) >= 4:
-                    inputs.append({"name": row[0], "type": row[1], "description": row[2], "required": bool(row[3])})
-        else:
-            try:
-                import pandas as pd
-                if isinstance(inputs_df, pd.DataFrame):
-                    for _, r in inputs_df.iterrows():
-                        inputs.append({"name": r.get("name"), "type": r.get("type"), "description": r.get("description"), "required": bool(r.get("required", False))})
-            except Exception:
-                pass
-
-    # schemas/examples/tools
-    try:
-        output_schema = json.loads(output_schema_str) if output_schema_str else DEF_OUTPUT_SCHEMA
-    except Exception:
-        output_schema = DEF_OUTPUT_SCHEMA
-
-    try:
-        examples = json.loads(examples_str) if examples_str else DEF_EXAMPLES
-    except Exception:
-        examples = DEF_EXAMPLES
-
-    tools = [t.strip() for t in (tools_str or "").splitlines() if t.strip()]
-
-    # optional extraction
-    snippets = []
-    if py_or_ipynb is not None:
-        path = py_or_ipynb.name if hasattr(py_or_ipynb, "name") else str(py_or_ipynb)
-        if path.endswith(".py"):
-            snippets = extract_functions_from_py(path)
-        elif path.endswith(".ipynb"):
-            snippets = extract_functions_from_ipynb(path)
-
-    # build Skill.md
-    skill_md = build_skill_md(meta, inputs, output_schema, examples, tools, include_mermaid)
-
-    # scaffold
-    bundle = {}
-    if language.startswith("Python"):
-        bundle.update(scaffold_python(meta, output_schema))
-    else:
-        bundle.update(scaffold_node(meta))
-
-    # add skill + readme
-    bundle["Skill.md"] = skill_md
-    bundle["README.md"] = README_TMPL.format(skill_name=meta["name"])
-
-    # add snippets
-    for sn in snippets:
-        bundle[f"snippets/{sn['name']}.py"] = sn['code']
-
-    # zip
-    skill_slug = slugify(meta["name"])
-    tmpdir = tempfile.mkdtemp(prefix=f"skill_{skill_slug}_")
-    root = os.path.join(tmpdir, skill_slug)
-    os.makedirs(root, exist_ok=True)
-
-    for rel, content in bundle.items():
-        full = os.path.join(root, rel)
-        os.makedirs(os.path.dirname(full), exist_ok=True)
-        with open(full, "w", encoding="utf-8") as f:
-            f.write(content)
-
-    zpath = os.path.join(tmpdir, f"{skill_slug}.zip")
-    with zipfile.ZipFile(zpath, "w", zipfile.ZIP_DEFLATED) as zf:
-        for dirpath, _, filenames in os.walk(root):
-            for fn in filenames:
-                fp = os.path.join(dirpath, fn)
-                arc = os.path.relpath(fp, root)
-                zf.write(fp, arcname=os.path.join(skill_slug, arc))
-
-    return skill_md, zpath, root
-
-
-def do_publish(repo_full, branch, base_path, commit_msg, token, root):
-    token = token or os.getenv("GH_TOKEN", "")
-    if not root:
-        return "Nothing to publish yet. Click 'Generate' first.", ""
-    msg, url = publish_folder_to_github(repo_full, branch, base_path, commit_msg, token, root)
-    link = f"\n\nRepo view: {url}" if url else ""
-    return msg + link, url or ""
-
-
-with gr.Blocks(title="Skill.md Generator + Scaffolder") as demo:
-    gr.Markdown("""
-    # Skill.md Generator + Scaffolder
-    1) Fill the form → 2) Generate preview → 3) Download ZIP or Publish to GitHub.  
-    Configure **Space Secrets** for `CLAUDE_API_KEY` (required for live Claude calls in generated Python skill) and `GH_TOKEN` (optional, for publishing).
-    """)
-
-    with gr.Row():
-        with gr.Column():
-            skill_name = gr.Textbox(label="Skill name", value="MySkill")
-            author = gr.Textbox(label="Author", placeholder="Your name")
-            description = gr.Textbox(label="Description", lines=3)
-            with gr.Row():
-                language = gr.Radio(["Python / FastAPI", "Node / Express"], value="Python / FastAPI", label="Scaffold language")
-                include_mermaid = gr.Checkbox(value=True, label="Include Mermaid diagram in Skill.md")
-            purpose = gr.Textbox(label="Purpose (prompt hint)")
-            style = gr.Textbox(label="Style (prompt hint)", value="concise, factual")
-            constraints = gr.Textbox(label="Constraints", value="must output valid JSON matching schema")
-        with gr.Column():
-            inputs_df = gr.Dataframe(headers=["name","type","description","required"], row_count=(2, "dynamic"), datatype=["str","str","str","bool"], label="Inputs")
-            output_schema = gr.Code(label="Output JSON Schema", language="json", value=json.dumps(DEF_OUTPUT_SCHEMA, indent=2))
-            examples = gr.Code(label="Examples (JSON)", language="json", value=json.dumps(DEF_EXAMPLES, indent=2))
-            tools = gr.Textbox(label="External tools/APIs (one per line)")
-            py_or_ipynb = gr.File(label="Optional: upload .py or .ipynb to extract functions", file_count="single", type="filepath")
-
-    gen = gr.Button("Generate Preview + ZIP")
-
-    preview = gr.Markdown(label="Skill.md Preview")
-    zip_out = gr.File(label="Download bundle (ZIP)")
-
-    # Internal states to reuse for GitHub publish
-    bundle_root_state = gr.State("")
-    repo_url_state = gr.State("")
-
-    gen.click(
-        fn=generate,
-        inputs=[skill_name, author, description, purpose, style, constraints, language, inputs_df, output_schema, examples, tools, include_mermaid, py_or_ipynb],
-        outputs=[preview, zip_out, bundle_root_state]
+        return f"Error running tool: {e}"
+
+def explain_progressive_disclosure() -> str:
+    return (
+        "### Progressive Disclosure\\n\\n"
+        "1. **Startup**: Only skill *metadata* (name, description) is shown.\\n"
+        "2. **Trigger**: Loading a skill reads **SKILL.md** into context.\\n"
+        "3. **Deep Dive**: Linked files (e.g., `reference.md`, `forms.md`) are opened only when needed.\\n"
+        "4. **Tools**: For the PDF skill, run the Python tool to extract form fields without adding the PDF to context."
     )
 
-    gr.Markdown("""
-    ---
-    ## 📤 Publish to GitHub (optional)
-    Provide a repo you own and a Personal Access Token (or set `GH_TOKEN` in Space Secrets). Files are committed to the branch and path you choose.
-    """)
+with gr.Blocks(title="Agent Skills — Progressive Disclosure Demo") as demo:
+    gr.Markdown("# Equipping agents for the real world with Agent Skills\\nPublished Oct 16, 2025")
+    gr.Markdown("This Space demonstrates **Agent Skills** as folders containing a `SKILL.md`, optional linked files, and tools.")
 
     with gr.Row():
-        with gr.Column():
-            repo_full = gr.Textbox(label="Repo (owner/name)")
-            branch = gr.Textbox(label="Branch", value="main")
-            base_path = gr.Textbox(label="Path in repo (e.g., skills/my-skill)", value="skills")
-            commit_msg = gr.Textbox(label="Commit message", value="Add generated skill bundle")
-            token_in = gr.Textbox(label="GitHub Token (optional; Space Secret GH_TOKEN is recommended)", type="password")
-            publish_btn = gr.Button("Publish to GitHub")
-        with gr.Column():
-            publish_status = gr.Markdown()
-
-    publish_btn.click(
-        fn=do_publish,
-        inputs=[repo_full, branch, base_path, commit_msg, token_in, bundle_root_state],
-        outputs=[publish_status, repo_url_state]
-    )
+        with gr.Column(scale=1):
+            gr.Markdown("### Installed Skills")
+            skills = list_skills()
+            skill_map = {f"{title} — {desc}": slug for (slug, title, desc) in skills} if skills else {}
+            labels = list(skill_map.keys()) or ["(No skills found)"]
+            skill_dd = gr.Dropdown(choices=labels, value=labels[0], label="Pick a skill")
+            meta_out = gr.JSON(label="Skill metadata")
+
+            def on_pick(label):
+                if not skill_map:
+                    return {}, "", [], None, None
+                slug = skill_map.get(label, None)
+                if not slug:
+                    return {}, "", [], None, None
+                meta, body = load_skill(slug)
+                return meta, body, list_linked_files(slug), slug, None
+
+            body_out = gr.Markdown(label="SKILL.md body")
+            linked_files = gr.Dropdown(choices=[], label="Linked files")
+            selected_slug_state = gr.State(value=None)
+            _reset = gr.State(value=None)
+
+            skill_dd.change(fn=on_pick, inputs=[skill_dd], outputs=[meta_out, body_out, linked_files, selected_slug_state, _reset])
+
+        with gr.Column(scale=2):
+            gr.Markdown("### Progressive Disclosure")
+            gr.Markdown(explain_progressive_disclosure())
+
+            gr.Markdown("---")
+            gr.Markdown("### Linked File Viewer")
+            linked_view = gr.Markdown()
+
+            def on_view_linked(filename, slug):
+                if not slug or not filename:
+                    return "Pick a skill and a linked file."
+                return read_linked_file(slug, filename)
+
+            view_btn = gr.Button("Open linked file")
+            view_btn.click(fn=on_view_linked, inputs=[linked_files, selected_slug_state], outputs=[linked_view])
+
+            gr.Markdown("---")
+            gr.Markdown("### Run Skill Tool (PDF form field extractor)")
+            pdf_in = gr.File(label="Upload a PDF", file_count="single", type="filepath")
+            tool_out = gr.Markdown()
+
+            def run_tool_clicked(slug, pdf):
+                if not slug:
+                    return "Pick a skill first."
+                return run_pdf_tool(slug, pdf)
+
+            run_tool_btn = gr.Button("Extract form fields")
+            run_tool_btn.click(fn=run_tool_clicked, inputs=[selected_slug_state, pdf_in], outputs=[tool_out])
 
 if __name__ == "__main__":
     demo.launch()

requirements.txt

@@ -1,8 +1,3 @@
 gradio>=4.0.0
-fastapi
-uvicorn
-pydantic
-pytest
-nbformat
-anthropic
-PyGithub
+PyYAML
+PyPDF2