Upload 9 files

app.py

@@ -0,0 +1,48 @@
+import gradio as gr
+from phases.phase1_ingest import ingest
+from phases.phase2_rules import load_rules
+from phases.phase3_static import static_scan
+from phases.phase4_runtime import runtime_risks
+
+with gr.Blocks(title="SpecGuard AI Lab", theme=gr.themes.Soft()) as app:
+
+    gr.Markdown("## 🧠 SpecGuard AI Lab")
+    gr.Markdown("Rulebook ↔ Code Deep Research & Verification System")
+
+    with gr.Sidebar():
+        rulebook_input = gr.Textbox(
+            label="📘 Rulebook (paste)",
+            lines=12,
+            placeholder="Paste specification or rulebook text here"
+        )
+        code_zip = gr.File(label="📦 Source Code (ZIP)")
+        run_btn = gr.Button("🚀 Start Deep Research", variant="primary")
+
+    status = gr.Markdown()
+    output = gr.Markdown()
+
+    def run_all(rulebook, zipfile):
+        s1 = ingest(rulebook, zipfile)
+        rules = load_rules()
+        findings = static_scan()
+        risks = runtime_risks()
+
+        report = f"""
+### ✅ Research Complete
+
+**Rules Loaded:** {len(rules.get("rules", []))}  
+**Static Findings:** {len(findings)}  
+**Runtime Risks Identified:** {len(risks)}
+
+Artifacts saved in `/artifacts/`
+"""
+        return "Done", report
+
+    run_btn.click(
+        run_all,
+        inputs=[rulebook_input, code_zip],
+        outputs=[status, output]
+    )
+
+if __name__ == "__main__":
+    app.launch()

phases/phase1_ingest.py

@@ -0,0 +1,13 @@
+import os, zipfile, json
+
+def ingest(rulebook_text, code_zip):
+    os.makedirs("artifacts", exist_ok=True)
+
+    with open("artifacts/rulebook_raw.txt", "w", encoding="utf-8") as f:
+        f.write(rulebook_text)
+
+    if code_zip:
+        with zipfile.ZipFile(code_zip, "r") as z:
+            z.extractall("artifacts/code")
+
+    return "Ingestion complete"

phases/phase2_rules.py

@@ -0,0 +1,10 @@
+import yaml, json
+
+def load_rules(path="RULEBOOK.yaml"):
+    with open(path, "r", encoding="utf-8") as f:
+        rules = yaml.safe_load(f)
+
+    with open("artifacts/normalized_rules.json", "w") as out:
+        json.dump(rules, out, indent=2)
+
+    return rules

phases/phase3_static.py

@@ -0,0 +1,27 @@
+import ast, os, json
+
+def static_scan(root="artifacts/code"):
+    findings = []
+
+    for dirpath, _, files in os.walk(root):
+        for f in files:
+            if f.endswith(".py"):
+                path = os.path.join(dirpath, f)
+                try:
+                    tree = ast.parse(open(path, "r", encoding="utf-8").read())
+                    for node in ast.walk(tree):
+                        if isinstance(node, ast.Assign):
+                            src = ast.unparse(node)
+                            if "socket_timeout" in src:
+                                findings.append({
+                                    "file": path,
+                                    "issue": "socket_timeout_detected",
+                                    "line": node.lineno
+                                })
+                except Exception as e:
+                    findings.append({"file": path, "error": str(e)})
+
+    with open("artifacts/static_findings.json", "w") as f:
+        json.dump(findings, f, indent=2)
+
+    return findings

phases/phase4_runtime.py

@@ -0,0 +1,9 @@
+def runtime_risks():
+    risks = [
+        "Python threads cannot be force-killed safely",
+        "yt-dlp may block despite socket_timeout",
+        "HF Spaces may restart and kill background tasks"
+    ]
+    with open("artifacts/environment_risks.md", "w") as f:
+        f.write("\n".join(f"- {r}" for r in risks))
+    return risks

phases/phase5_ai_review.py

@@ -0,0 +1,2 @@
+def summarize():
+    return "Artifacts ready for AI reasoning (external or local LLM)"

prompts/fix_planner.txt

@@ -0,0 +1,14 @@
+You are a senior systems engineer.
+
+INPUT:
+- Rule–Code gap report
+
+TASK:
+- Generate minimal patches (not rewrites)
+- Suggest rulebook corrections if rule is unrealistic
+- Maintain architectural philosophy
+
+CONSTRAINTS:
+- No new features
+- No scope expansion
+- No speculative optimizations

prompts/gap_detector.txt

@@ -0,0 +1,19 @@
+You are a rule–code auditor.
+
+INPUTS:
+- RULEBOOK.yaml
+- Static code findings
+- Environment constraints
+- Source code excerpts
+
+TASK:
+For EACH rule ID:
+- Classify as COMPLIANT, VIOLATED, PARTIAL, or UNKNOWN
+- Cite exact file and line numbers
+- Explain mismatch logically
+- Do NOT rewrite code
+- Propose minimal fixes only
+
+IMPORTANT:
+- Never guess intent
+- If Python or runtime prevents enforcement, say so clearly

prompts/rule_normalizer.txt

@@ -0,0 +1,18 @@
+You are a specification engineer.
+
+INPUT:
+- Human-written rulebook text
+
+TASK:
+1. Extract atomic rules.
+2. Assign unique rule IDs.
+3. Convert vague intent into verifiable constraints.
+4. If a rule cannot be enforced by code, mark it as "environment-limited".
+
+STRICT RULES:
+- Do not invent rules.
+- Do not assume behavior.
+- If evidence is missing, mark as UNKNOWN.
+
+OUTPUT:
+Structured JSON only.