jac-coder 0.1.0__py3-none-any.whl

jac_coder/tool/checked.jac

@@ -0,0 +1,10 @@
+import from jac_coder.tool.guarded { write_file_guarded, edit_file_guarded }
+
+
+"""Write a file with auto-validation."""
+def write_code(file_path: str, content: str) -> str;
+
+"""Find-and-replace with auto-validation."""
+def edit_code(
+    file_path: str, old_string: str, new_string: str, replace_all: bool = False
+) -> str;

jac_coder/tool/delegation.jac

@@ -0,0 +1,23 @@
+import threading;
+
+import from jac_coder.config { get_config }
+import from jac_coder.util.tool_output { tool_status, tool_end }
+import from jac_coder.events { track_file, track_error, emit_event }
+
+
+glob _tl: Any = threading.local();
+
+
+def init_budget(total: int = 90) -> None;
+def get_remaining_budget() -> int;
+def consume_budget(used: int) -> None;
+def get_recent_results_summary() -> str;
+def get_project_summary_for_subagent() -> str;
+
+
+"""Spawn a SubAgent for a task."""
+def spawn_agent(task: str, mode: str = "worker") -> str;
+
+sem spawn_agent = "Delegate a task to a focused SubAgent. mode='worker' for code changes (read+write), 'explorer' for investigation (read-only). Write a detailed instruction string including file paths, patterns to follow, and what success looks like.";
+sem spawn_agent.task = "Detailed instruction for the SubAgent — include file paths, context, and success criteria";
+sem spawn_agent.mode = "Capability scope: 'worker' (can modify files) or 'explorer' (read-only)";

jac_coder/tool/filesystem.jac

@@ -0,0 +1,25 @@
+import os;
+import re;
+import time;
+import subprocess;
+import mimetypes;
+
+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 }
+
+
+"""Read a file with line numbers."""
+def read_file(file_path: str, offset: int = 0, limit: int = 2000) -> str;
+
+"""Write content to a file."""
+def write_file(file_path: str, content: str) -> str;
+
+"""Find-and-replace in a file."""
+def edit_file(
+    file_path: str, old_string: str, new_string: str, replace_all: bool = False
+) -> str;
+
+"""List files matching a glob pattern."""
+def list_files(directory: str = ".", pattern: str = "**/*") -> str;

jac_coder/tool/git.jac

@@ -0,0 +1,18 @@
+import os;
+import subprocess;
+
+import from jac_coder.util.tool_output { truncate_output, tool_status, tool_end }
+import from jac_coder.util.sandbox { sandbox_path }
+
+
+"""Show working tree status."""
+def git_status() -> str;
+
+"""Show diff of changes."""
+def git_diff(ref: str = "HEAD") -> str;
+
+"""Stage files and create a commit."""
+def git_commit(message: str, files: list[str] = []) -> str;
+
+"""Show recent commit history."""
+def git_log(count: int = 10) -> str;

jac_coder/tool/guarded.jac

@@ -0,0 +1,23 @@
+import os;
+
+import from jac_coder.tool.shell { bash_exec }
+import from jac_coder.util.colors { YELLOW, DIM, RESET }
+import from jac_coder.permission { permission_engine }
+import from jac_coder.tool.filesystem { write_file, edit_file }
+
+
+def _check_permission(tool_id: str, resource: str) -> str;
+def _ask_user(tool_id: str, resource: str) -> str;
+
+"""Write a file with permission check."""
+def write_file_guarded(file_path: str, content: str) -> str;
+
+"""Find-and-replace with permission check."""
+def edit_file_guarded(
+    file_path: str, old_string: str, new_string: str, replace_all: bool = False
+) -> str;
+
+"""Run a shell command with permission check."""
+def run_command(
+    command: str, workdir: str = ".", timeout: int = 120, background: bool = False
+) -> str;

jac_coder/tool/impl/checked.impl.jac

@@ -0,0 +1,38 @@
+def _enforce_check(result: str, file_path: str) -> str {
+    if "Error:" in result
+    and (
+        "Permission denied" in result
+        or "File not found" in result
+        or "old_string not found" in result
+    ) {
+        return result;
+    }
+
+    if not file_path.endswith(".jac") {
+        return result;
+    }
+
+    if "VALIDATION ERRORS" in result {
+        return result + "\n\n[ACTION REQUIRED: Call jac_docs(query) to look up the correct Jac syntax BEFORE attempting to fix. Do NOT guess — look it up first, then fix.]";
+    }
+
+    if "RUNTIME ERRORS" in result {
+        return result + "\n\n[ACTION REQUIRED: Call jac_docs(query) to look up the correct Jac syntax BEFORE attempting to fix. Do NOT guess — look it up first, then fix.]";
+    }
+
+    return result;
+}
+
+
+impl write_code(file_path: str, content: str) -> str {
+    result = write_file_guarded(file_path, content);
+    return _enforce_check(result, file_path);
+}
+
+
+impl edit_code(
+    file_path: str, old_string: str, new_string: str, replace_all: bool = False
+) -> str {
+    result = edit_file_guarded(file_path, old_string, new_string, replace_all);
+    return _enforce_check(result, file_path);
+}

jac_coder/tool/impl/delegation.impl.jac

@@ -0,0 +1,157 @@
+impl init_budget(total: int = 90) -> None {
+    _tl.budget = total;
+    _tl.budget_initialized = True;
+    _tl.recent_results = [];
+}
+
+
+impl get_remaining_budget() -> int {
+    return getattr(_tl, "budget", 0);
+}
+
+
+impl consume_budget(used: int) -> None {
+    _tl.budget = max(0, getattr(_tl, "budget", 0) - used);
+}
+
+
+impl get_recent_results_summary() -> str {
+    results = getattr(_tl, "recent_results", []);
+    if not results {
+        return "";
+    }
+    parts: list = [];
+    for r in results[-3:] {
+        line = f"- [{r.get('mode', 'worker')}] {r.get('task_preview', '')[:100]}";
+        fmod = r.get("files_modified", []);
+        if fmod {
+            line += f" -> modified: {', '.join(fmod)}";
+        }
+        errs = r.get("errors", []);
+        if errs {
+            line += f" -> errors: {', '.join(errs[:2])}";
+        }
+        parts.append(line);
+    }
+    return "Previous SubAgent results:\n" + "\n".join(parts);
+}
+
+
+impl get_project_summary_for_subagent() -> str {
+    try {
+        import jac_coder.nodes as _nodes;
+        sessions = [root()-->(?:(_nodes.Session))](?status=="active");
+        if sessions {
+            sessions.sort(key=lambda s : s.updated_at, reverse=True);
+            proj_summary = sessions[0].project_summary;
+            if proj_summary {
+                return proj_summary;
+            }
+        }
+    } except Exception { }
+    return "";
+}
+
+
+impl spawn_agent(task: str, mode: str = "worker") -> str {
+    tool_status("spawn_agent", f"[{mode}] {task[:80]}...");
+
+    if not task {
+        tool_end("-> no task", error=True);
+        return "Error: task description is required.";
+    }
+
+    if mode not in ["worker", "explorer"] {
+        mode = "worker";
+    }
+
+    # Initialize per-thread budget on first SubAgent call in this chat() turn
+    if not getattr(_tl, "budget_initialized", False) {
+        cfg = get_config();
+        init_budget(cfg.max_react_iterations * 3);
+    }
+    remaining = get_remaining_budget();
+    if remaining <= 0 {
+        tool_end("-> budget exhausted", error=True);
+        return "Error: Iteration budget exhausted. Cannot spawn more SubAgents.";
+    }
+
+    # Enrich task with session context
+    project_ctx = get_project_summary_for_subagent();
+    recent_work = get_recent_results_summary();
+
+    enriched_parts: list = [task];
+    if project_ctx {
+        enriched_parts.append(f"\n\n--- Project Context ---\n{project_ctx}");
+    }
+    if recent_work {
+        enriched_parts.append(f"\n\n--- Recent SubAgent Work ---\n{recent_work}");
+    }
+    enriched_task = "".join(enriched_parts);
+
+    # Spawn SubAgent walker on the MainAgent node
+    import from jac_coder.nodes { WorkerAgent, ExplorerAgent }
+    import from jac_coder.walkers { ensure_main_agent }
+    ;
+
+    try {
+        main_agent = ensure_main_agent();
+
+        # Spawn the walker on MainAgent — entry ability handles streaming + event forwarding
+        if mode == "worker" {
+            result = main_agent spawn WorkerAgent(task=enriched_task);
+        } else {
+            result = main_agent spawn ExplorerAgent(task=enriched_task);
+        }
+
+        # Extract result from walker's has fields
+        content = result.result_content;
+        used_tools = result.result_tools;
+        fmod = result.result_files;
+
+        has_errs = False;
+        iters_used = len(used_tools) if used_tools else 5;
+
+        # Track budget and state
+        consume_budget(iters_used);
+        for fp in fmod {
+            track_file(fp);
+        }
+        if has_errs {
+            track_error();
+        }
+
+        # Record result for subsequent SubAgents in this turn
+        _tl.recent_results.append(
+            {
+                "mode": mode,
+                "task_preview": task[:200],
+                "files_modified": fmod,
+                "errors": ["error"] if has_errs else [],
+                "content_preview": content[:300] if content else ""
+            }
+        );
+
+        # Build result string
+        result_parts: list = [];
+        if content {
+            result_parts.append(content);
+        }
+        if fmod {
+            result_parts.append(f"\nFiles modified: {', '.join(fmod)}");
+        }
+        if has_errs {
+            result_parts.append(
+                "\nNote: Some errors were encountered during execution."
+            );
+        }
+
+        tool_end(f"-> {mode} done, {len(fmod)} files");
+        return "\n".join(result_parts) if result_parts else "SubAgent completed.";
+    } except Exception as e {
+        consume_budget(5);
+        tool_end(f"-> error: {e}", error=True);
+        track_error();
+        return f"Error: SubAgent failed - {str(e)}";
+    }
+}