jac-coder 0.1.0__py3-none-any.whl

jac_coder/nodes.jac

@@ -0,0 +1,306 @@
+import os;
+
+import from uuid { uuid4 }
+import from datetime { datetime }
+import from jac_coder.config { llm, get_config, get_data_dir }
+
+# MainAgent tools — full orchestrator set
+import from jac_coder.tool.think { think }
+import from jac_coder.tool.delegation { spawn_agent }
+import from jac_coder.tool.todo { update_todos }
+import from jac_coder.tool.jac_docs { jac_docs }
+import from jac_coder.tool.question { ask_question }
+import from jac_coder.tool.scaffold { scaffold_project }
+import from jac_coder.tool.web { web_fetch, web_search }
+import from jac_coder.tool.guarded { run_command }
+import from jac_coder.tool.jac_tools { jac_check, jac_run }
+import from jac_coder.tool.search { grep_search, find_files }
+import from jac_coder.tool.filesystem { read_file, list_files }
+import from jac_coder.tool.git { git_status, git_diff, git_commit, git_log }
+import from jac_coder.tool.checked { write_code, edit_code }
+import from jac_coder.tool.jac_analyzer { analyze_project, find_symbol }
+import from jac_coder.tool.validate { validate_project }
+import from jac_coder.tool.preview { capture_preview, evaluate_preview }
+import from jac_coder.tool.mcp { mcp_call }
+
+
+def load_subagent_rules() -> dict {
+    data_dir = get_data_dir();
+    rules: dict = {};
+    rules_dir = os.path.join(data_dir, "rules");
+    # Load all rule files from rules/ directory
+    for (key, filename) in [
+        ("core_jac_rules", "core_jac.md"),
+        ("fullstack_rules", "fullstack.md"),
+        ("workflow_rules", "workflow.md")
+    ] {
+        filepath = os.path.join(rules_dir, filename);
+        try {
+            with open(filepath, "r") as f {
+                rules[key] = f.read();
+            }
+        } except (FileNotFoundError, OSError) {
+            rules[key] = "";
+        }
+    }
+    # Build TOC of available docs for jac_docs() tool
+    toc_lines: list = ["Call jac_docs(query) to look up Jac syntax. Available topics:"];
+    for subdir in ["reference", "examples"] {
+        search_dir = os.path.join(data_dir, subdir);
+        if not os.path.isdir(search_dir) {
+            continue;
+        }
+        for fname in sorted(os.listdir(search_dir)) {
+            if not fname.endswith(".md") {
+                continue;
+            }
+            filepath = os.path.join(search_dir, fname);
+            try {
+                with open(filepath, "r") as f {
+                    content = f.read();
+                }
+                headings = [
+                    line.replace("## ", "").strip()
+                    for line in content.split("\n")
+                    if line.startswith("## ")
+                ];
+                label = subdir + "/" + fname.replace(".md", "");
+                toc_lines.append(f"  {label}: {', '.join(headings)}");
+            } except (FileNotFoundError, OSError) { }
+        }
+    }
+    rules["available_docs"] = "\n".join(toc_lines);
+    return rules;
+}
+
+# ---------------------------------------------------------------------------
+# Response objects
+# ---------------------------------------------------------------------------
+obj AgentResponse {
+    has content: str;
+    has agent_mode: str;
+    has tools_used: list[str];
+    has files_modified: list[str];
+    has has_errors: bool;
+    has next_steps: list[str];
+}
+
+sem AgentResponse.content = "Main response text to display to user";
+sem AgentResponse.agent_mode = "Always 'main' for MainAgent responses";
+sem AgentResponse.tools_used = "List of tool names that were called during execution";
+sem AgentResponse.files_modified = "List of file paths that were written or edited";
+sem AgentResponse.has_errors = "TRUE if any tool execution failed, FALSE otherwise";
+sem AgentResponse.next_steps = "Suggested follow-up actions for the user (empty list if none)";
+
+
+obj SubAgentResult {
+    has content: str;
+    has files_modified: list[str];
+    has errors: list[str];
+    has tools_used: list[str];
+    has iterations_used: int;
+}
+
+sem SubAgentResult.content = "The SubAgent's response to the task";
+sem SubAgentResult.files_modified = "Files written or edited during execution";
+sem SubAgentResult.errors = "Errors encountered (jac_check failures, tool errors)";
+sem SubAgentResult.tools_used = "Tools called during execution";
+sem SubAgentResult.iterations_used = "Number of ReAct iterations consumed";
+
+
+obj ProjectScan {
+    has architecture: str;
+    has file_map: dict[str, str];
+    has conventions: list[str];
+}
+
+
+obj SessionLearnings {
+    has new_files: dict[str, str];
+    has new_conventions: list[str];
+    has new_decisions: list[str];
+    has known_issues: list[str];
+}
+
+
+# ---------------------------------------------------------------------------
+# McpRegistry — persists MCP server configs in the graph
+# ---------------------------------------------------------------------------
+node McpRegistry {
+    has servers: dict[str, dict] = {};
+}
+
+
+# ---------------------------------------------------------------------------
+# ProjectMemory — persists codebase knowledge across sessions
+# ---------------------------------------------------------------------------
+node ProjectMemory {
+    has project_dir: str = "",
+        architecture: str = "",
+        file_map: dict[str, str] = {},
+        conventions: list[str] = [],
+        past_decisions: list[str] = [],
+        known_issues: list[str] = [],
+        graph_topology: str = "",
+        node_details: str = "",
+        walker_details: str = "",
+        import_map: str = "",
+        scan_attempted: bool = False,
+        last_updated: str = "";
+
+    def profile_project(file_tree: str, key_files: str) -> ProjectScan by llm(
+        temperature=0.1
+    );
+
+    def collect_learnings(
+        files_modified: list[str], session_summary: str
+    ) -> SessionLearnings by llm(temperature=0.1);
+
+    def summarize() -> str;
+}
+
+
+# ---------------------------------------------------------------------------
+# Session — persistent chat state
+# ---------------------------------------------------------------------------
+node Session {
+    has id: str = "",
+        title: str = "New Session",
+        directory: str = "",
+        agent: str = "main",
+        status: str = "active",
+        created_at: str = "",
+        updated_at: str = "",
+        chat_history: list[dict] = [],
+        last_agent: str = "",
+        active_files: list[str] = [],
+        pending_errors: list[str] = [],
+        project_summary: str = "";
+
+    def postinit;
+}
+
+
+# ---------------------------------------------------------------------------
+# MainAgent — the orchestrator node
+# ---------------------------------------------------------------------------
+node MainAgent {
+    def respond(message: str, chat_history: list[dict]) -> str by llm(
+        tools=[
+            # Think — explicit reasoning before acting or delegating
+            think,
+            # Understand — read, search, analyze the codebase
+            read_file,
+            grep_search,
+            find_files,
+            list_files,
+            analyze_project,
+            find_symbol,
+            jac_docs,
+            # Act — handle simple tasks directly
+            edit_code,
+            write_code,
+            run_command,
+            jac_run,
+            validate_project,
+            scaffold_project,
+            # Git — first-class version control
+            git_status,
+            git_diff,
+            git_log,
+            git_commit,
+            # Web — search and fetch external resources
+            web_fetch,
+            web_search,
+            # Visual — screenshot and evaluate live preview UI
+            capture_preview,
+            evaluate_preview,
+            # Delegate — spawn SubAgent walkers for complex tasks
+            spawn_agent,
+            # Interact — ask user questions, track todos
+            ask_question,
+            update_todos,
+            # MCP — call tools from connected MCP servers
+            mcp_call
+        ],
+        incl_info=_subagent_rules,
+        max_react_iterations=40,
+        temperature=0.2,
+        stream=True,
+        logging=True
+    );
+}
+
+
+# ---------------------------------------------------------------------------
+# SubAgent walkers — spawned on MainAgent node for task delegation
+# ---------------------------------------------------------------------------
+glob _subagent_rules: dict = load_subagent_rules();
+
+walker WorkerAgent {
+    has task: str;
+    has result_content: str = "";
+    has result_tools: list[str] = [];
+    has result_files: list[str] = [];
+
+    def do_work(task_str: str) -> str by llm(
+        tools=[
+            jac_docs,
+            analyze_project,
+            find_symbol,
+            read_file,
+            list_files,
+            grep_search,
+            find_files,
+            write_code,
+            edit_code,
+            run_command,
+            jac_run,
+            validate_project,
+            scaffold_project,
+            git_status,
+            git_diff,
+            git_commit,
+            git_log,
+            web_fetch,
+            web_search,
+            capture_preview,
+            evaluate_preview,
+            mcp_call
+        ],
+        incl_info=_subagent_rules,
+        max_react_iterations=30,
+        temperature=0.2,
+        stream=True,
+        logging=True
+    );
+    can execute with MainAgent entry;
+}
+
+walker ExplorerAgent {
+    has task: str;
+    has result_content: str = "";
+    has result_tools: list[str] = [];
+    has result_files: list[str] = [];
+
+    def do_work(task_str: str) -> str by llm(
+        tools=[
+            jac_docs,
+            analyze_project,
+            find_symbol,
+            read_file,
+            list_files,
+            grep_search,
+            find_files,
+            git_log,
+            web_search,
+            web_fetch
+        ],
+        incl_info=_subagent_rules,
+        max_react_iterations=30,
+        temperature=0.2,
+        stream=True,
+        logging=True
+    );
+    can execute with MainAgent entry;
+}

jac_coder/permission.jac

@@ -0,0 +1,19 @@
+import fnmatch;
+
+obj PermissionRule {
+    has tool: str = "*",
+        pattern: str = "*",
+        action: str = "ask";  # "allow" | "deny" | "ask"
+}
+
+obj PermissionEngine {
+    has rules: list = [],
+        always_allowed: dict = {};
+
+    def init_defaults() -> None;
+    def check(tool_id: str, resource: str = "") -> str;
+    def remember_allow(tool_id: str, pattern: str = "*") -> None;
+    def enable_web_mode() -> None;
+}
+
+glob permission_engine: PermissionEngine = PermissionEngine();

jac_coder/serve_entry.jac

@@ -0,0 +1,30 @@
+"""Entry point for `jac-coder-server` command.
+
+Mirrors the jaseci cli_boot.jac pattern — jaclang's import hook allows this
+.jac file to be referenced directly from pyproject.toml [project.scripts]:
+
+    jac-coder-server = "jac_coder.serve_entry:main"
+
+Finds server.jac inside the installed jac_coder package and runs it with
+`jac run`. Works both in dev (editable install) and after pip install.
+"""
+
+import os;
+import sys;
+import subprocess;
+import from pathlib { Path }
+
+
+"""Start the JacCoder stdio server."""
+def main -> None {
+    # __file__ is jac_coder/serve_entry.jac — server.jac lives next to it.
+    pkg_dir = Path(__file__).parent;
+    server_jac = pkg_dir / "server.jac";
+
+    if not server_jac.exists() {
+        print(f"Error: server.jac not found at {server_jac}", file=sys.stderr);
+        sys.exit(1);
+    }
+
+    sys.exit(subprocess.call(["jac", "run", str(server_jac)] + sys.argv[1:]));
+}

jac_coder/server.jac

@@ -0,0 +1,324 @@
+"""JacCoder stdio server.
+
+This is the bridge between the VS Code extension (TypeScript) and the
+JacCoder AI agent (Jac). The extension spawns this file as a subprocess
+and they talk to each other through stdin/stdout using JSON messages.
+
+How it works:
+  Extension  -->  sends a JSON request  -->  stdin  -->  this server
+  This server --> does the work         -->  stdout -->  extension
+
+Message format (JSON-RPC 2.0):
+  Request  (extension asks something, has an "id"):
+    health          → check if server is alive
+    session.create  → start a new chat session
+    session.list    → get all sessions
+    session.get     → get one session by id
+    session.close   → close a session
+    chat            → send a message to the AI agent
+    mcp.add         → register an MCP tool server
+    mcp.remove      → remove an MCP tool server
+    mcp.list        → list all MCP tool servers
+
+  Notification (fire-and-forget, no "id"):
+    chat.cancel     → stop the currently running agent (sent by extension)
+    server.ready    → server started successfully (sent by us, once)
+    chat.event      → live updates while agent is thinking/running tools
+"""
+
+import sys;
+import os;
+import json;
+import asyncio;
+import logging;
+import threading;
+import from typing { Any }
+
+import from jac_coder.api {
+    initialize,
+    chat as _api_chat,
+    create_session as _api_create_session,
+    list_sessions as _api_list_sessions,
+    get_session as _api_get_session,
+    close_session as _api_close_session,
+    api_mcp_add as _api_mcp_add,
+    api_mcp_remove as _api_mcp_remove,
+    api_mcp_list as _api_mcp_list
+}
+
+
+# Debug logs — goes to stderr, not stdout, so JSON messages stay clean.
+glob logger = logging.getLogger("jaccoder.stdio");
+
+# Save a private copy of stdout before we redirect it to stderr.
+# All JSON writes use this — so accidental print() calls never reach the extension.
+glob _real_stdout: Any = os.fdopen(os.dup(1), 'w', 1);
+
+# Prevents two threads writing JSON at the same time and mixing the output.
+glob _stdout_lock: Any = threading.Lock();
+
+# Tracks cancelled sessions — set to True when user hits cancel.
+glob _stop_flags: dict = {};
+
+# Holds the running thread per session — used to force-stop it on cancel.
+glob _chat_threads: dict = {};
+
+
+# ---------------------------------------------------------------------------
+# JSON-RPC 2.0 message builders
+# These just build the correct dict shape — nothing else.
+# ---------------------------------------------------------------------------
+
+"""Build a success response for a request."""
+def _ok(req_id: Any, result: Any) -> dict {
+    return {"jsonrpc": "2.0", "id": req_id, "result": result};
+}
+
+"""Build an error response for a request."""
+def _err(req_id: Any, code: int, message: str) -> dict {
+    return {"jsonrpc": "2.0", "id": req_id, "error": {"code": code, "message": message}};
+}
+
+"""Build a server-push notification (no id — no reply expected)."""
+def _notify(method: str, params: dict) -> dict {
+    return {"jsonrpc": "2.0", "method": method, "params": params};
+}
+
+"""Build a cancelled response — sent when the user aborts a chat turn."""
+def _cancelled(req_id: Any) -> dict {
+    return _ok(req_id, {"response": "", "agent": "cancelled", "cancelled": True});
+}
+
+
+# ---------------------------------------------------------------------------
+# Writes one JSON message to the extension — one at a time, thread-safe.
+# ---------------------------------------------------------------------------
+
+"""Write one JSON message to stdout (thread-safe)."""
+def _write(msg: dict) -> None {
+    global _stdout_lock, _real_stdout;
+    line = json.dumps(msg, ensure_ascii=False);
+    with _stdout_lock {
+        _real_stdout.write(line + "\n");
+        _real_stdout.flush();
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Chat handler
+#
+# Each chat turn runs in its own thread because the LLM call is blocking
+# (can take seconds or minutes). We can't block the main asyncio loop or
+# we'd never be able to receive a chat.cancel notification while waiting.
+#
+# Flow:
+#   1. Thread starts, calls the AI agent (_api_chat)
+#   2. Agent fires on_event() for every tool it runs → we stream those back
+#   3. When agent finishes → we send the final response
+#   4. If user cancelled → we send a cancelled frame instead
+# ---------------------------------------------------------------------------
+
+"""Run one chat turn in a background thread and stream results back."""
+def _handle_chat(req_id: Any, params: dict) -> None {
+    session_id: str = params.get("session_id", "");
+    message: str = params.get("message", "");
+    agent_context: str = params.get("agent_context", "") or "";
+
+    _stop_flags[session_id] = False;
+
+    # Called by the agent each time it does something (reads a file, calls a tool, etc.)
+    # We forward these as chat.event notifications so the UI can show live progress.
+    def on_event(event_type: str, data: dict) -> None {
+        if _stop_flags.get(session_id) {
+            raise KeyboardInterrupt("cancelled");  # unwinds the agent immediately
+        }
+        _write(_notify("chat.event", {"type": event_type, **data}));
+    }
+
+    try {
+        result = _api_chat(
+            session_id=session_id,
+            message=message,
+            on_event=on_event,
+            agent_context=agent_context
+        );
+        if _stop_flags.get(session_id) {
+            _write(_cancelled(req_id));
+        } else {
+            _write(_ok(req_id, result));
+        }
+    } except (KeyboardInterrupt, InterruptedError) {
+        _write(_cancelled(req_id));
+    } except Exception as e {
+        logger.error("chat error: %s", e);
+        _write(_err(req_id, -32000, str(e)));
+    } finally {
+        _stop_flags.pop(session_id, None);
+        _chat_threads.pop(session_id, None);
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Request dispatcher
+#
+# Routes each incoming request to the right API call and sends back the result.
+# Runs inside the asyncio event loop so Jac graph operations (root, spawn, -->)
+# are always available.
+# ---------------------------------------------------------------------------
+
+"""Route one JSON-RPC request to the correct API function."""
+async def _dispatch(req_id: Any, method: str, params: dict) -> None {
+    try {
+        if method == "health" {
+            _write(_ok(req_id, {"status": "ok", "service": "jac-coder"}));
+
+        } elif method == "session.create" {
+            _write(_ok(req_id, _api_create_session(
+                directory=params.get("directory", ""),
+                title=params.get("title", "New Session")
+            )));
+
+        } elif method == "session.list" {
+            _write(_ok(req_id, {"sessions": _api_list_sessions()}));
+
+        } elif method == "session.get" {
+            _write(_ok(req_id, _api_get_session(session_id=params["session_id"])));
+
+        } elif method == "session.close" {
+            _write(_ok(req_id, _api_close_session(session_id=params["session_id"])));
+
+        } elif method == "chat" {
+            # Chat runs in a thread — LLM calls are blocking and can take a long time.
+            # The thread writes events and the final response directly via _write().
+            sid: str = params.get("session_id", "");
+            chat_thread = threading.Thread(
+                target=_handle_chat,
+                args=(req_id, params),
+                daemon=True,
+                name=f"chat-{sid[:8]}"
+            );
+            _chat_threads[sid] = chat_thread;
+            chat_thread.start();
+
+        } elif method == "mcp.add" {
+            _write(_ok(req_id, _api_mcp_add(
+                name=params["name"],
+                config=params["config"]
+            )));
+
+        } elif method == "mcp.remove" {
+            _write(_ok(req_id, _api_mcp_remove(name=params["name"])));
+
+        } elif method == "mcp.list" {
+            _write(_ok(req_id, {"servers": _api_mcp_list()}));
+
+        } else {
+            _write(_err(req_id, -32601, f"Method not found: {method}"));
+        }
+
+    } except KeyError as exc {
+        _write(_err(req_id, -32602, f"Missing required param: {exc}"));
+    } except BaseException as exc {
+        logger.error("dispatch [%s]: %s", method, exc);
+        _write(_err(req_id, -32000, str(exc)));
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Main loop
+#
+# Reads one JSON message per line from stdin.
+# - If the message has an "id" → it's a request, dispatch it.
+# - If no "id" → it's a notification (currently only chat.cancel).
+# - Empty line → EOF → extension closed, exit cleanly.
+# ---------------------------------------------------------------------------
+
+"""Read stdin forever and dispatch each incoming message."""
+async def _main() -> None {
+    loop = asyncio.get_event_loop();
+
+    # Tell the extension we are ready to receive requests.
+    _write(_notify("server.ready", {"service": "jac-coder"}));
+
+    while True {
+        try {
+            # run_in_executor keeps stdin reading off the async loop
+            # so the loop stays free to handle other tasks while waiting.
+            line = await loop.run_in_executor(None, sys.stdin.readline);
+        } except Exception as e {
+            logger.error("stdin read error: %s", e);
+            break;
+        }
+
+        if not line {
+            # Empty string = EOF = extension disconnected. Exit cleanly.
+            break;
+        }
+
+        line = line.strip();
+        if not line {
+            continue;  # blank line, skip
+        }
+
+        try {
+            msg: dict = json.loads(line);
+        } except Exception {
+            _write(_err(None, -32700, "Invalid JSON"));
+            continue;
+        }
+
+        method: str = msg.get("method", "");
+        params: dict = msg.get("params") or {};
+        req_id: Any = msg.get("id");
+
+        if "id" not in msg {
+            # Notification (no reply needed) — only chat.cancel is handled.
+            if method == "chat.cancel" {
+                sid: str = params.get("session_id", "");
+                if sid {
+                    _stop_flags[sid] = True;
+                    # Force-stop the thread even if it's stuck in a blocking LLM call.
+                    running_thread = _chat_threads.get(sid);
+                    if running_thread and running_thread.is_alive() {
+                        import ctypes;
+                        ctypes.pythonapi.PyThreadState_SetAsyncExc(
+                            ctypes.c_ulong(running_thread.ident),
+                            ctypes.py_object(KeyboardInterrupt)
+                        );
+                    }
+                }
+            }
+            continue;
+        }
+
+        # It's a request — schedule it on the event loop and keep reading.
+        asyncio.ensure_future(_dispatch(req_id, method, params));
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Entry point — runs when: jac run server.jac
+# ---------------------------------------------------------------------------
+
+with entry {
+    # Log warnings and above to stderr (safe — won't touch the JSON channel).
+    logging.basicConfig(
+        level=logging.WARNING,
+        format="[jaccoder] %(levelname)s %(name)s: %(message)s",
+        stream=sys.stderr
+    );
+
+    # Redirect stdout → stderr so accidental print() calls never corrupt the JSON pipe.
+    os.dup2(2, 1);
+    sys.stdout = sys.stderr;
+
+    # Boot the Jac agent (loads config, connects LLM, sets up the graph).
+    initialize("web");
+
+    # Start the async event loop — runs forever until stdin closes.
+    asyncio.run(_main());
+}

jac_coder/tool/__init__.jac

@@ -0,0 +1,17 @@
+import from jac_coder.tool.shell { bash_exec }
+import from jac_coder.tool.think { think }
+import from jac_coder.tool.delegation { spawn_agent }
+import from jac_coder.tool.jac_docs { jac_docs }
+import from jac_coder.tool.question { ask_question }
+import from jac_coder.tool.web { web_fetch, web_search }
+import from jac_coder.tool.scaffold { scaffold_project }
+import from jac_coder.tool.search { grep_search, find_files }
+import from jac_coder.tool.todo { update_todos, get_todos }
+import from jac_coder.tool.jac_tools { jac_check, jac_run }
+import from jac_coder.tool.validate { validate_project }
+import from jac_coder.tool.git { git_status, git_diff, git_commit, git_log }
+import from jac_coder.tool.checked { write_code, edit_code }
+import from jac_coder.tool.guarded { write_file_guarded, edit_file_guarded, run_command }
+import from jac_coder.tool.filesystem { read_file, write_file, edit_file, list_files }
+import from jac_coder.tool.jac_analyzer { analyze_project, find_symbol }
+import from jac_coder.tool.preview { capture_preview, evaluate_preview }