jac-coder 0.1.0__py3-none-any.whl

jac_coder/tool/impl/jac_docs.impl.jac

@@ -0,0 +1,136 @@
+glob _docs_index: list = [];
+
+
+def _build_docs_index() -> list {
+    index: list = [];
+    data_dir = get_data_dir();
+
+    sources: list = [];
+    # Reference docs (split by topic)
+    ref_dir = os.path.join(data_dir, "reference");
+    if os.path.isdir(ref_dir) {
+        for fname in sorted(os.listdir(ref_dir)) {
+            if fname.endswith(".md") {
+                label = fname.replace(".md", "");
+                sources.append((label, os.path.join(ref_dir, fname)));
+            }
+        }
+    }
+    # Example docs (split by project)
+    ex_dir = os.path.join(data_dir, "examples");
+    if os.path.isdir(ex_dir) {
+        for fname in sorted(os.listdir(ex_dir)) {
+            if fname.endswith(".md") {
+                label = "example:" + fname.replace(".md", "");
+                sources.append((label, os.path.join(ex_dir, fname)));
+            }
+        }
+    }
+    if not sources {
+        import sys;
+        sys.stderr.write(f"[jac_docs] WARNING: no docs found in {data_dir}\n");
+    }
+    for (source_name, filepath) in sources {
+        try {
+            with open(filepath, "r") as f {
+                content = f.read();
+            }
+        } except (FileNotFoundError, OSError) {
+            continue;
+        }
+        sections = re.split(r'\n(?=## )', content);
+        section_num = 0;
+        for section in sections {
+            section = section.strip();
+            if not section.startswith("## ") {
+                continue;
+            }
+            section_num += 1;
+            lines = section.split("\n", 1);
+            title = lines[0].replace("## ", "", 1).strip();
+            body = lines[1].strip() if len(lines) > 1 else "";
+            raw_text = (title + " " + body).lower();
+            keyword_set = set(re.findall(r'[a-z0-9_]+', raw_text));
+            index.append(
+                {
+                    "title": title,
+                    "source": source_name,
+                    "section_num": section_num,
+                    "body": body,
+                    "keywords": keyword_set
+                }
+            );
+        }
+    }
+    return index;
+}
+
+
+def _ensure_index() -> list {
+    if not _docs_index {
+        idx = _build_docs_index();
+        # Mutate in place since glob reassignment may not work in impl
+        _docs_index.clear();
+        _docs_index.extend(idx);
+    }
+    return _docs_index;
+}
+
+
+impl jac_docs(query: str, max_results: int = 3) -> str {
+    tool_status("jac_docs", query);
+    if not query or not query.strip() {
+        return "Error: query is required. Example: jac_docs('imports') or jac_docs('frontend effects lifecycle').";
+    }
+
+    index = _ensure_index();
+    if not index {
+        return "Error: Jac documentation index is empty — data files not found.";
+    }
+
+    query_terms = set(re.findall(r'[a-z0-9_]+', query.lower()));
+    if not query_terms {
+        return "Error: no searchable terms in query.";
+    }
+
+    scored: list = [];
+    for section in index {
+        title_lower = section["title"].lower();
+        title_hits = 0;
+        body_hits = 0;
+        for term in query_terms {
+            if term in title_lower {
+                title_hits += 1;
+            }
+            if term in section["keywords"] {
+                body_hits += 1;
+            }
+        }
+        score = (title_hits * 3) + body_hits;
+        if score > 0 {
+            scored.append({"section": section, "score": score});
+        }
+    }
+
+    if not scored {
+        return f"No matching sections found for: '{query}'. Try broader terms like 'syntax', 'walker', 'frontend', 'imports', 'llm', 'api'.";
+    }
+
+    scored.sort(key=lambda x : x["score"], reverse=True);
+    top = scored[:max_results];
+
+    parts: list = [];
+    matched_titles: list = [];
+    for entry in top {
+        s = entry["section"];
+        parts.append(f"## {s['title']} (from {s['source']})\n\n{s['body']}");
+        matched_titles.append(s["title"]);
+    }
+
+    titles_str = ", ".join(matched_titles);
+    tool_end(f"-> {titles_str}");
+
+    result = "\n\n---\n\n".join(parts);
+    (result, _) = truncate_output(result);
+    return result;
+}

jac_coder/tool/impl/jac_tools.impl.jac

@@ -0,0 +1,79 @@
+impl jac_check(file: str) -> str {
+    (file, err) = sandbox_path(file);
+    if err {
+        return err;
+    }
+    tool_status("jac_check", file);
+    if not file {
+        return "Error: file path is required";
+    }
+
+    try {
+        result = subprocess.run(
+            ["jac", "check", file], capture_output=True, text=True, timeout=30
+        );
+        output = ((result.stdout or "") + (result.stderr or "")).strip();
+        if not output {
+            tool_end("-> clean");
+            return f"No errors found in {file}";
+        }
+        err_count = len(
+            [
+                l
+                for l in output.splitlines()
+                if "error" in l.lower()
+            ]
+        );
+        tool_end(
+            f"-> {err_count} errors" if err_count > 0 else "-> clean",
+            error=err_count > 0
+        );
+        (output, _) = truncate_output(output);
+        return output;
+    } except subprocess.TimeoutExpired {
+        tool_end("-> timeout", error=True);
+        return "Error: jac check timed out after 30 seconds";
+    } except Exception as e {
+        tool_end("-> error", error=True);
+        return f"Error: {str(e)}";
+    }
+}
+
+
+impl jac_run(file: str, args: str = "") -> str {
+    (file, err) = sandbox_path(file);
+    if err {
+        return err;
+    }
+    tool_status("jac_run", file);
+    if not file {
+        return "Error: file path is required";
+    }
+
+    cmd = ["jac", "run", file];
+    if args {
+        cmd += args.split();
+    }
+
+    try {
+        result = subprocess.run(cmd, capture_output=True, text=True, timeout=60);
+        output = ((result.stdout or "") + (result.stderr or "")).strip();
+        if not output {
+            return "(no output)";
+        }
+        if result.returncode != 0 {
+            output = f"Exit code: {result.returncode}\n{output}";
+            tool_end(f"-> exit {result.returncode}", error=True);
+        } else {
+            tool_end("-> ok");
+        }
+        (output, _) = truncate_output(output);
+        return output;
+    } except subprocess.TimeoutExpired {
+        tool_end("-> timeout", error=True);
+        return "Error: jac run timed out after 60 seconds";
+    } except Exception as e {
+        tool_end("-> error", error=True);
+        return f"Error: {str(e)}";
+    }
+}

jac_coder/tool/impl/mcp.impl.jac

@@ -0,0 +1,32 @@
+"""Implementation of the mcp_call agent tool."""
+
+
+impl mcp_call(server_name: str, tool_name: str, arguments_json: str = "{}") -> str {
+    tool_status("mcp_call", f"{server_name}.{tool_name}");
+
+    if not server_name or not tool_name {
+        tool_end("-> error: missing server_name or tool_name", error=True);
+        return "Error: server_name and tool_name are required.";
+    }
+
+    import json as _json;
+    try {
+        args: dict = _json.loads(arguments_json) if arguments_json else {};
+    } except Exception as e {
+        tool_end(f"-> error: invalid JSON — {e}", error=True);
+        return f"Error: arguments_json is invalid JSON — {e}";
+    }
+
+    try {
+        result: str = str(mcp_call_tool(server_name, tool_name, args));
+    } except Exception as e {
+        tool_end(f"-> error: {e}", error=True);
+        return f"Error: MCP call failed — {e}";
+    }
+
+    preview = result[:80].replace("\n", " ");
+    tool_end(f"-> {preview}");
+
+    (output, _) = truncate_output(result);
+    return output;
+}

jac_coder/tool/impl/preview.impl.jac

@@ -0,0 +1,233 @@
+import os;
+import json;
+import base64;
+import threading;
+import httpx;
+import from byllm.lib { Image }
+import from jac_coder.tool.vision { analyze_screenshot, compare_screenshots }
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+# Thread-local storage for per-request state (preview URL, last screenshot).
+# Avoids process-global os.environ which is unsafe with concurrent users.
+glob _tl = threading.local();
+
+
+"""Get the preview URL from thread-local (set at turn start), falling back to env var.
+The env var fallback is a convenience for local single-user dev only;
+in production, set_preview_url() is called per-thread by jaccoder_adapter."""
+def _get_preview_url() -> str {
+    return getattr(_tl, "preview_url", "") or os.environ.get("JACCODER_PREVIEW_URL", "");
+}
+
+
+"""Set the preview URL for the current thread/request."""
+impl set_preview_url(url: str) -> None {
+    _tl.preview_url = url;
+}
+
+
+"""Call the MCP screenshot tool and return a dict with image data.
+Returns {"success": True, "image_b64": ..., "mime_type": ...} on success,
+or {"success": False, "error": ...} on failure.
+delay is in SECONDS (converted to ms for MCP).
+"""
+def _take_screenshot(url: str, viewport: str, delay: int) -> dict {
+
+    mcp_url = os.environ.get("JAC_MCP_SERVER_URL", "https://mcp.jaseci.org");
+
+    # Localhost preview can't be reached by a remote MCP server
+    if "localhost" in url and "localhost" not in mcp_url {
+        return {
+            "success": False,
+            "error": (
+                "Cannot screenshot localhost URL from remote MCP server. "
+                "Either: (1) set JAC_MCP_SERVER_URL to a local MCP server, "
+                "or (2) set JAC_IDE_PREVIEW_PUBLIC_URL_TEMPLATE so the preview "
+                "gets a public URL the remote MCP can reach."
+            )
+        };
+    }
+
+    # Convert delay from seconds to milliseconds for MCP
+    delay_ms = min(delay * 1000, 5000);
+
+    try {
+        with httpx.Client(timeout=60.0) as client {
+            resp = client.post(
+                f"{mcp_url}/mcp",
+                json={
+                    "jsonrpc": "2.0",
+                    "id": 1,
+                    "method": "tools/call",
+                    "params": {
+                        "name": "take_screenshot",
+                        "arguments": {
+                            "url": url,
+                            "viewport": viewport,
+                            "format": "jpeg",
+                            "full_page": False,
+                            "delay": delay_ms
+                        }
+                    }
+                }
+            );
+            data = resp.json();
+        }
+    } except Exception as e {
+        return {"success": False, "error": f"MCP request failed: {e}"};
+    }
+
+    result = data.get("result", {});
+    if result.get("isError") {
+        error_text = result.get("content", [{}])[0].get("text", "Unknown MCP error");
+        return {"success": False, "error": error_text};
+    }
+
+    content_list = result.get("content", []);
+    if not content_list {
+        return {"success": False, "error": "Empty response from MCP"};
+    }
+
+    content = content_list[0];
+    if content.get("type") == "image" {
+        return {
+            "success": True,
+            "image_b64": content["data"],
+            "mime_type": content.get("mimeType", "image/jpeg")
+        };
+    }
+
+    return {"success": False, "error": content.get("text", "Unexpected response type")};
+}
+
+
+impl capture_preview(
+    viewport: str = "desktop",
+    delay: int = 2
+) -> str {
+    tool_status("capture_preview", f"viewport={viewport}");
+
+    preview_url = _get_preview_url();
+    if not preview_url {
+        tool_end("-> no preview URL", error=True);
+        return (
+            "Error: No live preview URL available. "
+            "The preview must be running in JacBuilder for this tool to work. "
+            "Set JACCODER_PREVIEW_URL environment variable or start the preview."
+        );
+    }
+
+    # Take screenshot via MCP
+    result = _take_screenshot(preview_url, viewport, delay);
+    if not result["success"] {
+        tool_end(f"-> screenshot failed: {str(result['error'])}", error=True);
+        return f"Error: Screenshot failed — {str(result['error'])}";
+    }
+
+    image_b64: str = str(result["image_b64"]);
+    mime_type: str = str(result["mime_type"]);
+    data_url = f"data:{mime_type};base64,{image_b64}";
+
+    # Store for before/after comparison in evaluate_preview (thread-local, not env)
+    _tl.last_screenshot = data_url;
+
+    # Brief vision analysis via byllm — keep it light (300 tokens) to save cost.
+    # The detailed evaluation belongs in evaluate_preview.
+    analysis = analyze_screenshot(
+        Image(data_url),
+        "Briefly describe this web app UI screenshot in 3-5 sentences. "
+        "Cover: layout structure, key visible elements, colors/theme, "
+        "and any obvious visual issues (broken layout, blank areas, overflow). "
+        "Be concise."
+    );
+
+    (output, _) = truncate_output(analysis);
+    tool_end(f"-> analyzed {viewport} view");
+    return f"Preview Screenshot Analysis ({viewport} viewport, URL: {preview_url}):\n\n{output}";
+}
+
+
+impl evaluate_preview(
+    intent: str,
+    viewport: str = "desktop",
+    delay: int = 2
+) -> str {
+    tool_status("evaluate_preview", intent[:80] + "..." if len(intent) > 80 else intent);
+
+    if not intent {
+        tool_end("-> no intent", error=True);
+        return "Error: intent description is required. Describe what the UI should look like.";
+    }
+
+    preview_url = _get_preview_url();
+    if not preview_url {
+        tool_end("-> no preview URL", error=True);
+        return (
+            "Error: No live preview URL available. "
+            "The preview must be running in JacBuilder for this tool to work."
+        );
+    }
+
+    # Take screenshot via MCP
+    result = _take_screenshot(preview_url, viewport, delay);
+    if not result["success"] {
+        tool_end(f"-> screenshot failed: {str(result['error'])}", error=True);
+        return f"Error: Screenshot failed — {str(result['error'])}";
+    }
+
+    current_b64: str = str(result["image_b64"]);
+    mime_type: str = str(result["mime_type"]);
+    current_data_url = f"data:{mime_type};base64,{current_b64}";
+
+    # Check for a previous screenshot for before/after comparison (thread-local)
+    before_data_url = getattr(_tl, "last_screenshot", "");
+
+    # Update stored screenshot (thread-local)
+    _tl.last_screenshot = current_data_url;
+
+    if before_data_url and before_data_url != current_data_url {
+        # Before/after comparison mode via byllm
+        prompt = (
+            f"Compare these TWO UI screenshots. The first image is BEFORE changes, "
+            f"the second image is AFTER changes.\n\n"
+            f"User's intended design: {intent}\n\n"
+            f"Evaluate:\n"
+            f"1. VERDICT: Does the AFTER screenshot match the user's intent? (PASS / PARTIAL / FAIL)\n"
+            f"2. SCORE: Rate the match 0-100\n"
+            f"3. MATCHES: What parts correctly match the intended design?\n"
+            f"4. MISMATCHES: What differs from the intended design?\n"
+            f"5. REGRESSIONS: Did any previously working elements break?\n"
+            f"6. FIXES: If not PASS, list specific CSS/layout changes needed in the .cl.jac code\n\n"
+            f"Be specific with element names, colors, and positions."
+        );
+
+        analysis = compare_screenshots(
+            Image(before_data_url),
+            Image(current_data_url),
+            prompt
+        );
+
+        (output, _) = truncate_output(analysis);
+        tool_end(f"-> compared before/after");
+        return f"Preview Evaluation — Before/After Comparison ({viewport}):\n\n{output}";
+    } else {
+        # Single-image evaluation mode via byllm
+        analysis = analyze_screenshot(
+            Image(current_data_url),
+            f"Evaluate this UI screenshot against the following intended design:\n\n"
+            f"INTENDED DESIGN: {intent}\n\n"
+            f"Evaluate:\n"
+            f"1. VERDICT: Does this UI match the intent? (PASS / PARTIAL / FAIL)\n"
+            f"2. SCORE: Rate the match 0-100\n"
+            f"3. MATCHES: What parts correctly match the intended design?\n"
+            f"4. MISMATCHES: What differs from the intended design?\n"
+            f"5. ISSUES: Any visual bugs (broken layout, overflow, missing elements)?\n"
+            f"6. FIXES: If not PASS, list specific CSS/layout changes needed in the .cl.jac code\n\n"
+            f"Be specific with element names, colors, and positions."
+        );
+
+        (output, _) = truncate_output(analysis);
+        tool_end(f"-> evaluated against intent");
+        return f"Preview Evaluation ({viewport}):\n\n{output}";
+    }
+}

jac_coder/tool/impl/question.impl.jac

@@ -0,0 +1,29 @@
+impl ask_question(question: str, options: str = "") -> str {
+    if not question {
+        return "Error: question is required";
+    }
+
+    if os.environ.get("JACCODER_WEB_MODE", "") {
+        return "Cannot ask user interactively in web mode. Proceed with your best judgment.";
+    }
+
+    print(f"\n{YELLOW}[Question]{RESET} {question}");
+
+    if options {
+        choices = [o.strip() for o in options.split(",")];
+        for (i, opt) in enumerate(choices) {
+            print(f"  {i + 1}. {opt}");
+        }
+        answer = input("Your choice (number or text): ").strip();
+        try {
+            idx = int(answer) - 1;
+            if 0 <= idx < len(choices) {
+                answer = choices[idx];
+            }
+        } except ValueError { }
+    } else {
+        answer = input("Your answer: ").strip();
+    }
+
+    return f"User answered: {answer}";
+}