jac-coder 0.1.0__py3-none-any.whl

jac_coder/tool/impl/validate.impl.jac

@@ -0,0 +1,236 @@
+impl validate_project(directory: str = "") -> str {
+    tool_status("validate_project", directory or os.getcwd());
+
+    project_dir = directory if directory else os.getcwd();
+    if not os.path.isdir(project_dir) {
+        tool_end("-> not found", error=True);
+        return f"Error: directory not found: {project_dir}";
+    }
+
+    # Find all .jac files (skip .cl.jac for now — jac check doesn't support them)
+    jac_files: list = [];
+    for (dirpath, dirnames, filenames) in os.walk(project_dir) {
+        # Skip hidden dirs, node_modules, __pycache__
+        dirnames[:] = [d for d in dirnames if not d.startswith(".") and d not in ["node_modules", "__pycache__", "venv"]];
+        for fname in filenames {
+            if fname.endswith(".jac") and not fname.endswith(".cl.jac") {
+                jac_files.append(os.path.join(dirpath, fname));
+            }
+        }
+    }
+
+    if not jac_files {
+        tool_end("-> no .jac files");
+        return "No .jac files found in " + project_dir;
+    }
+
+    # Phase 1: Auto-fix mechanical patterns before checking
+    auto_fixes_total = 0;
+    for fp in jac_files {
+        fixes = _auto_fix_mechanical(fp);
+        auto_fixes_total += fixes;
+    }
+
+    # Phase 2: Run full jac check on each file, collect ALL errors
+    all_errors: list = [];
+    files_checked = 0;
+    files_clean = 0;
+
+    for fp in jac_files {
+        rel_path = os.path.relpath(fp, project_dir);
+        try {
+            result = subprocess.run(
+                ["jac", "check", fp],
+                capture_output=True,
+                text=True,
+                timeout=30
+            );
+            files_checked += 1;
+
+            if result.returncode == 0 {
+                files_clean += 1;
+            } else {
+                output = (result.stderr or result.stdout or "").strip();
+                if output {
+                    # Parse individual errors
+                    for line in output.split("\n") {
+                        line = line.strip();
+                        if line.startswith("✖ Error:") or line.startswith("⚠ warning:") {
+                            all_errors.append(f"  {rel_path}: {line}");
+                        }
+                    }
+                }
+            }
+        } except subprocess.TimeoutExpired {
+            all_errors.append(f"  {rel_path}: TIMEOUT (>30s)");
+            files_checked += 1;
+        } except Exception as e {
+            all_errors.append(f"  {rel_path}: CHECK FAILED - {str(e)}");
+            files_checked += 1;
+        }
+    }
+
+    # Phase 3: Build structured report
+    parts: list = [];
+
+    if auto_fixes_total > 0 {
+        parts.append(f"Auto-fixed {auto_fixes_total} mechanical issues (root()->root(), deprecated syntax).");
+    }
+
+    parts.append(f"Checked {files_checked} files: {files_clean} clean, {files_checked - files_clean} with issues.");
+
+    if all_errors {
+        # Categorize errors vs warnings
+        errors = [e for e in all_errors if "Error:" in e];
+        warnings = [e for e in all_errors if "warning:" in e];
+
+        if errors {
+            parts.append(f"\nErrors ({len(errors)}):");
+            for e in errors[:30] {
+                parts.append(e);
+                # Add fix hint
+                hint = _get_error_hint(e);
+                if hint {
+                    parts.append(f"    → {hint}");
+                }
+            }
+            if len(errors) > 30 {
+                parts.append(f"  ... and {len(errors) - 30} more errors");
+            }
+        }
+
+        if warnings {
+            parts.append(f"\nWarnings ({len(warnings)}):");
+            for w in warnings[:10] {
+                parts.append(w);
+            }
+            if len(warnings) > 10 {
+                parts.append(f"  ... and {len(warnings) - 10} more warnings");
+            }
+        }
+
+        track_error();
+        tool_end(f"-> {len(errors)} errors, {len(warnings)} warnings", error=len(errors) > 0);
+    } else {
+        parts.append("\nAll files pass type-check.");
+        tool_end(f"-> all clean");
+    }
+
+    return "\n".join(parts);
+}
+
+
+def _auto_fix_mechanical(file_path: str) -> int {
+    try {
+        with open(file_path, "r") as f {
+            content = f.read();
+        }
+    } except Exception {
+        return 0;
+    }
+
+    original = content;
+    is_client = file_path.endswith(".cl.jac");
+
+    # Fix 1: bare root → root() (deprecated)
+    # Only match lowercase 'root' not followed by '(' — skip Root (type name)
+    content = re.sub(r'(?<!\w)root(?!\s*\()(?!\w)', 'root()', content);
+
+    # Fix 2: (?:Type) → [?:Type] (deprecated filter syntax)
+    content = re.sub(r'\(\?:(\w+)\)', r'[?:\1]', content);
+
+    # Fix 3: (?:Type, cond) → [?:Type, cond] (deprecated with condition)
+    content = re.sub(r'\(\?:(\w+),([^)]+)\)', r'[?:\1,\2]', content);
+
+    # Fix 4: def: pub → def:pub (no space after colon)
+    content = re.sub(r'\bdef:\s+pub\b', 'def:pub', content);
+    content = re.sub(r'\bdef:\s+priv\b', 'def:priv', content);
+
+    # Fix 5: for p: Type in → for p in (no type annotation on loop var)
+    content = re.sub(r'\bfor\s+(\w+)\s*:\s*\w+\s+in\b', r'for \1 in', content);
+
+    # Fix 6: import path slashes → dots (.cl.jac files)
+    if is_client {
+        def _fix_slashes(m: Any) -> str {
+            prefix = m.group(1);
+            path = m.group(2);
+            return prefix + path.replace("/", ".") + '"';
+        }
+        content = re.sub(
+            r'(import\s+from\s+")((?:[.]*)[^"]*)"',
+            _fix_slashes,
+            content
+        );
+    }
+
+    # Fix 7: className → class (in .cl.jac JSX)
+    if is_client {
+        content = re.sub(r'\bclassName\s*=', 'class=', content);
+    }
+
+    # Count fixes and write if changed
+    if content != original {
+        fix_count = 0;
+        # Count each type of change
+        for (old_pat, new_pat) in [
+            ("root()", "root()"), ("def:pub", "def:pub"),
+            ("[?:", "[?:"), ("class=", "class=")
+        ] {
+            fix_count += content.count(new_pat) - original.count(new_pat);
+        }
+        fix_count = max(fix_count, 1);
+        try {
+            with open(file_path, "w") as f {
+                f.write(content);
+            }
+        } except Exception {
+            return 0;
+        }
+        return fix_count;
+    }
+
+    return 0;
+}
+
+
+def _get_error_hint(error_line: str) -> str {
+    e = error_line.lower();
+
+    if "has no attribute" in e {
+        return "Field was removed or renamed. Check the object definition.";
+    }
+    if "type is unknown" in e and "cannot access" in e {
+        return "Add type annotation to the variable or cast with str()/int()/list().";
+    }
+    if "cannot return" in e and "expected" in e {
+        return "Return type doesn't match. Add explicit type annotation or cast.";
+    }
+    if "missing from nonetype" in e {
+        return "Variable might be None. Add null check: if var { var.field }";
+    }
+    if "cannot assign" in e and "unknown" in e {
+        return "Add type annotation: var: str = expression;";
+    }
+    if "bare 'root()'" in e {
+        return "Use root() instead of root (auto-fixable by validate_project).";
+    }
+    if "deprecated" in e and "(?:" in e {
+        return "Use [?:Type] instead of [?:Type] (auto-fixable by validate_project).";
+    }
+    if "parameter" in e and "type annotation" in e {
+        return "Add type annotation to parameter: param: Type.";
+    }
+    if "expected 'with'" in e and "can" in e {
+        return "Use 'def' for regular methods in obj. 'can' is only for walker/node abilities with 'with Type entry'.";
+    }
+    if "import:py" in e or "import: py" in e {
+        return "import:py is deprecated. Use 'import from module { name }' instead.";
+    }
+    if "self" in e and "missing" in e and "type" in e {
+        return "self is implicit in Jac — remove it from method parameters.";
+    }
+    if "pass" in e and "unexpected" in e {
+        return "'pass' is not a keyword in Jac. Use a no-op statement or empty block.";
+    }
+    return "";
+}

jac_coder/tool/impl/web.impl.jac

@@ -0,0 +1,91 @@
+impl web_fetch(url: str, format: str = "text") -> str {
+    tool_status("web_fetch", url);
+    if not url {
+        return "Error: url is required";
+    }
+
+    if url.startswith("http://") {
+        url = "https://" + url[7:];
+    }
+    if not url.startswith("https://") {
+        url = "https://" + url;
+    }
+
+    try {
+        import httpx;
+        client = httpx.Client(timeout=30.0, follow_redirects=True);
+        response = client.get(
+            url, headers={"User-Agent": "JacCoder/0.1 (AI Coding Agent)"}
+        );
+        response.raise_for_status();
+        content = response.text;
+    } except Exception as e {
+        tool_end("-> error", error=True);
+        return f"Error fetching URL: {e}";
+    }
+
+    if format == "html" {
+        (output, _) = truncate_output(content);
+        tool_end(f"-> {len(content)} chars");
+        return output;
+    }
+
+    try {
+        import markdownify;
+        output = markdownify.markdownify(content, strip=["img", "script", "style"]);
+    } except ImportError {
+        output = re.sub(r'<[^>]+>', '', content);
+        output = re.sub(r'\s+', ' ', output).strip();
+    }
+
+    (output, _) = truncate_output(output);
+    tool_end(f"-> {len(output)} chars");
+    return output;
+}
+
+
+impl web_search(query: str, num_results: int = 5) -> str {
+    tool_status("web_search", query);
+    if not query {
+        return "Error: query is required";
+    }
+
+    num_results = min(num_results, 10);
+
+    try {
+        import httpx;
+        client = httpx.Client(timeout=15.0, follow_redirects=True);
+        response = client.get(
+            "https://html.duckduckgo.com/html/",
+            params={"q": query},
+            headers={"User-Agent": "JacCoder/0.1"}
+        );
+        response.raise_for_status();
+
+        results = [];
+        result_pattern = r'<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>(.*?)</a>';
+        snippet_pattern = r'<a[^>]*class="result__snippet"[^>]*>(.*?)</a>';
+        urls = re.findall(result_pattern, response.text, re.DOTALL);
+        snippets = re.findall(snippet_pattern, response.text, re.DOTALL);
+
+        for i in range(min(len(urls), num_results)) {
+            (url, title) = urls[i];
+            title = re.sub(r'<[^>]+>', '', title).strip();
+            snippet = re.sub(r'<[^>]+>', '', snippets[i]).strip()
+                if i < len(snippets)
+                else "";
+            results.append(f"**{title}**\n{url}\n{snippet}");
+        }
+
+        if not results {
+            tool_end("-> 0 results");
+            return "No results found.";
+        }
+
+        tool_end(f"-> {len(results)} results");
+        return "\n\n---\n\n".join(results);
+    } except Exception as e {
+        tool_end("-> error", error=True);
+        return f"Search error: {e}";
+    }
+}

jac_coder/tool/jac_analyzer.jac

@@ -0,0 +1,21 @@
+import os;
+import sys;
+import time;
+
+import from jaclang.jac0core { unitree as uni }
+import from jaclang.jac0core.program { JacProgram }
+
+
+"""Analyze a Jac project via compiler AST."""
+def analyze_project(directory: str) -> str;
+
+sem analyze_project = "Compiler-level analysis of an entire Jac project. Returns all nodes (with fields and types), walkers (with entry points showing which nodes they visit), edges, client .cl.jac components (with state), objects, import map, and export map. Use this to understand a project before writing code — gives accurate structural knowledge in one call instead of reading files manually.";
+sem analyze_project.directory = "Root directory of the Jac project to analyze";
+
+
+"""Find a symbol's definition and usages."""
+def find_symbol(name: str, directory: str = "") -> str;
+
+sem find_symbol = "Look up any Jac symbol (node, walker, edge, obj, enum, component) by name. Returns: definition file and line, all fields with types, all abilities (including which use by llm()), every file that imports or references it, walker entry points that visit it, and the exact import statement to use. Use this when you need details about a specific type or need to know the correct import path.";
+sem find_symbol.name = "The symbol name to look up (e.g. 'User', 'create_post', 'LoginForm')";
+sem find_symbol.directory = "Root directory of the Jac project to search";

jac_coder/tool/jac_docs.jac

@@ -0,0 +1,9 @@
+import os;
+import re;
+
+import from jac_coder.config { get_data_dir }
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+
+"""Search Jac documentation by keyword."""
+def jac_docs(query: str, max_results: int = 3) -> str;

jac_coder/tool/jac_tools.jac

@@ -0,0 +1,11 @@
+import subprocess;
+
+import from jac_coder.util.sandbox { sandbox_path }
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+
+"""Type-check a .jac file."""
+def jac_check(file: str) -> str;
+
+"""Run a Jac file."""
+def jac_run(file: str, args: str = "") -> str;

jac_coder/tool/mcp.jac

@@ -0,0 +1,17 @@
+import from jac_coder.mcp_manager { mcp_call_tool }
+import from jac_coder.util.tool_output { tool_status, tool_end, truncate_output }
+
+
+"""Call a tool provided by a connected MCP server.
+
+Use this when the user's context includes available MCP tools.
+Check the 'Available MCP tools' section in your context first,
+then call the appropriate tool with the correct server_name and tool_name.
+
+Arguments:
+  server_name    — the MCP server name (from Available MCP tools list)
+  tool_name      — the tool to call (from Available MCP tools list)
+  arguments_json — JSON string of arguments matching the tool's input schema.
+                   Use \"{}\" if the tool takes no arguments.
+                   Example: \"{\\\"code\\\": \\\"glob x: int = 1;\\\"}\" """
+def mcp_call(server_name: str, tool_name: str, arguments_json: str = "{}") -> str;

jac_coder/tool/preview.jac

@@ -0,0 +1,31 @@
+import os;
+
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+
+"""Set the preview URL for the current thread/request."""
+def set_preview_url(url: str) -> None;
+
+
+"""Quick screenshot + brief AI description of the rendered UI.
+Use for a quick look at the preview — does NOT evaluate against intent.
+Prefer evaluate_preview() for verification after changes.
+Do NOT call this before evaluate_preview — it takes its own screenshot.
+Only use after writing or modifying .cl.jac (client-side) files.
+delay is in seconds (default 2s, max 5s)."""
+def capture_preview(
+    viewport: str = "desktop",
+    delay: int = 2
+) -> str;
+
+
+"""Screenshot + PASS/PARTIAL/FAIL evaluation of the live preview against the
+user's intended design. This is the PRIMARY preview verification tool.
+Takes its own screenshot — do NOT call capture_preview first.
+Call this ONCE after modifying .cl.jac files to verify the UI matches intent.
+delay is in seconds (default 2s, max 5s)."""
+def evaluate_preview(
+    intent: str,
+    viewport: str = "desktop",
+    delay: int = 2
+) -> str;

jac_coder/tool/question.jac

@@ -0,0 +1,7 @@
+import os;
+
+import from jac_coder.util.colors { YELLOW, RESET }
+
+
+"""Ask the user a question."""
+def ask_question(question: str, options: str = "") -> str;

jac_coder/tool/scaffold.jac

@@ -0,0 +1,10 @@
+import os;
+
+import from pathlib { Path }
+import from jac_coder.events { emit_event }
+import from jac_coder.util.sandbox { sandbox_path }
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+
+"""Scaffold a new Jac project."""
+def scaffold_project(project_type: str, name: str, directory: str) -> str;

jac_coder/tool/search.jac

@@ -0,0 +1,14 @@
+import subprocess;
+
+import from pathlib { Path }
+import from jac_coder.util.sandbox { sandbox_path }
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+
+"""Regex search across files."""
+def grep_search(
+    pattern: str, path: str = ".", file_pattern: str = "", max_results: int = 50
+) -> str;
+
+"""Find files by glob pattern."""
+def find_files(pattern: str, directory: str = ".") -> str;

jac_coder/tool/shell.jac

@@ -0,0 +1,12 @@
+import os;
+import signal;
+import subprocess;
+
+import from jac_coder.util.sandbox { sandbox_path, get_sandbox_root }
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+
+"""Execute a shell command."""
+def bash_exec(
+    command: str, workdir: str = ".", timeout: int = 120, background: bool = False
+) -> str;

jac_coder/tool/task.jac

@@ -0,0 +1,9 @@
+import os;
+import tempfile;
+import subprocess;
+
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+
+"""Spawn a sub-agent for a task."""
+def spawn_task(description: str, prompt: str, agent_type: str = "explore") -> str;

jac_coder/tool/think.jac

@@ -0,0 +1,5 @@
+import from jac_coder.util.tool_output { tool_status }
+
+
+"""Reason step-by-step before acting."""
+def think(thought: str) -> str;

jac_coder/tool/todo.jac

@@ -0,0 +1,12 @@
+import json;
+
+import from jac_coder.util.tool_output { tool_status, tool_end }
+
+glob _todos: dict = {};
+
+
+"""Create or update a todo list."""
+def update_todos(todos_json: str) -> str;
+
+"""Get current todos."""
+def get_todos(session_id: str = "default") -> list;

jac_coder/tool/validate.jac

@@ -0,0 +1,11 @@
+import os;
+import re;
+import subprocess;
+
+import from jac_coder.util.tool_output { tool_status, tool_end }
+import from jac_coder.events { track_file, track_error }
+
+"""Batch validate and auto-fix all modified .jac files in a project."""
+def validate_project(directory: str = "") -> str;
+sem validate_project = "Run full type-check on all modified .jac files, auto-fix mechanical patterns (root()->root(), deprecated syntax), and return a structured error report with fix hints. Call this AFTER writing all files — not during.";
+sem validate_project.directory = "Project directory to validate. If empty, uses current working directory.";

jac_coder/tool/vision.jac

@@ -0,0 +1,17 @@
+import os;
+
+import from byllm.lib { Model, Image }
+
+# Vision model for preview analysis — separate from the main coding LLM
+glob vision_model_name: str = os.environ.get("JAC_VISION_MODEL", "gpt-4o");
+glob vision_llm = Model(model_name=vision_model_name);
+
+
+"""Analyze a single UI screenshot and return a text description."""
+def analyze_screenshot(screenshot: Image, prompt: str) -> str
+    by vision_llm(temperature=0.1, max_tokens=300);
+
+
+"""Compare two UI screenshots (before/after) and return an evaluation."""
+def compare_screenshots(before: Image, after: Image, prompt: str) -> str
+    by vision_llm(temperature=0.1, max_tokens=1024);

jac_coder/tool/web.jac

@@ -0,0 +1,10 @@
+import re;
+
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+
+
+"""Fetch a URL as readable text."""
+def web_fetch(url: str, format: str = "text") -> str;
+
+"""Search the web."""
+def web_search(query: str, num_results: int = 5) -> str;

jac_coder/util/__init__.jac

@@ -0,0 +1,18 @@
+import from jac_coder.util.tool_output {
+    truncate_output,
+    tool_status,
+    tool_end,
+    smart_path
+}
+import from jac_coder.util.colors {
+    RESET,
+    BOLD,
+    DIM,
+    RED,
+    GREEN,
+    YELLOW,
+    MAGENTA,
+    CYAN,
+    WHITE,
+    AGENT_COLORS
+}

jac_coder/util/colors.jac

@@ -0,0 +1,20 @@
+glob RESET: str = "\033[0m";
+glob BOLD: str = "\033[1m";
+glob DIM: str = "\033[2m";
+
+glob RED: str = "\033[31m";
+glob GREEN: str = "\033[32m";
+glob YELLOW: str = "\033[33m";
+glob MAGENTA: str = "\033[35m";
+glob CYAN: str = "\033[36m";
+glob WHITE: str = "\033[97m";
+
+glob AGENT_COLORS: dict = {
+         "main": CYAN,
+         "build": GREEN,
+         "client": GREEN,
+         "server": YELLOW,
+         "integration": WHITE,
+         "plan": CYAN,
+         "explore": MAGENTA
+     };

jac_coder/util/impl/sandbox.impl.jac

@@ -0,0 +1,38 @@
+impl set_sandbox_root(sroot: str) -> None {
+    _tls.sandbox_root = os.path.realpath(sroot) if sroot else "";
+}
+
+
+impl get_sandbox_root() -> str {
+    return getattr(_tls, "sandbox_root", "");
+}
+
+
+impl sandbox_path(path: str) -> tuple {
+    sroot = get_sandbox_root();
+    if not sroot {
+        return (path, "");
+    }
+
+    if not path or path == "." {
+        return (sroot, "");
+    }
+
+    if not os.path.isabs(path) {
+        path = os.path.join(sroot, path);
+    }
+
+    real = os.path.realpath(path);
+
+    try {
+        common = os.path.commonpath([sroot, real]);
+    } except ValueError {
+        return ("", "Error: Access denied — path outside project directory.");
+    }
+
+    if common != sroot {
+        return ("", "Error: Access denied — path outside project directory.");
+    }
+
+    return (real, "");
+}