jac-coder 0.1.0__py3-none-any.whl

jac_coder/impl/nodes.impl.jac

@@ -0,0 +1,259 @@
+# ---------------------------------------------------------------------------
+# Session
+# ---------------------------------------------------------------------------
+impl Session.postinit{
+    if not self.id {
+        self.id = str(uuid4());
+    }
+    if not self.created_at {
+        self.created_at = datetime.now().isoformat();
+    }
+    if not self.updated_at {
+        self.updated_at = datetime.now().isoformat();
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# ProjectMemory
+# ---------------------------------------------------------------------------
+sem ProjectMemory.profile_project = """Analyze a Jac project and extract structured memory.
+Given the file tree and key file contents, return:
+- architecture: 1-2 sentences describing the project purpose, tech stack, and node/walker structure
+- file_map: dict mapping up to 15 important file paths (relative) to 1-line descriptions of their role
+- conventions: list of coding conventions observed (naming style, file organization, patterns)
+Be concise and factual. This context will help future coding sessions start smart.""";
+
+sem ProjectMemory.collect_learnings = """Extract learnings from a completed coding session.
+Given the files modified and a session summary, return only NEW information:
+- new_files: dict of newly created or significantly changed file paths to 1-line descriptions
+- new_conventions: new coding patterns or conventions established (empty list if none)
+- new_decisions: architectural or design decisions made (empty list if none)
+- known_issues: bugs or issues discovered but not yet fixed (empty list if none)
+Be selective — only include genuinely new information.""";
+
+sem ProjectScan.architecture = "1-2 sentences: project purpose, tech stack, and overall node/walker structure";
+sem ProjectScan.file_map = "dict mapping relative file paths to 1-line role descriptions (max 15 files)";
+sem ProjectScan.conventions = "list of coding conventions: naming style, file organization, patterns used";
+
+sem SessionLearnings.new_files = "dict of new/modified file paths to 1-line descriptions of their content";
+sem SessionLearnings.new_conventions = "new coding conventions established this session (empty list if none)";
+sem SessionLearnings.new_decisions = "architectural decisions made this session (empty list if none)";
+sem SessionLearnings.known_issues = "bugs or issues discovered but not yet fixed (empty list if none)";
+
+impl ProjectMemory.summarize() -> str {
+    parts = [];
+    if self.architecture {
+        parts.append("Architecture: " + self.architecture);
+    }
+    if self.node_details {
+        parts.append(self.node_details);
+    }
+    if self.walker_details {
+        parts.append(self.walker_details);
+    }
+    if self.graph_topology {
+        parts.append("Graph: " + self.graph_topology);
+    }
+    if self.import_map {
+        parts.append(self.import_map);
+    }
+    if self.file_map {
+        items = list(self.file_map.items())[:10];
+        file_lines = [f"  {k}: {v}" for (k, v) in items];
+        parts.append("Key files:\n" + "\n".join(file_lines));
+    }
+    if self.conventions {
+        parts.append("Conventions: " + ", ".join(self.conventions[:5]));
+    }
+    if self.past_decisions {
+        parts.append("Past decisions: " + "; ".join(self.past_decisions[:3]));
+    }
+    if self.known_issues {
+        parts.append("Known issues: " + "; ".join(self.known_issues[:3]));
+    }
+    return "\n".join(parts);
+}
+
+
+# ---------------------------------------------------------------------------
+# MainAgent — the orchestrator
+# ---------------------------------------------------------------------------
+sem MainAgent.respond = """
+# JacCoder — AI Coding Agent for the Jaseci Stack
+
+You are a Jac coding agent. Be CONCISE in your final response. Use think() to narrate your reasoning in real-time.
+
+## Narration with think()
+Call think() before key actions to explain your reasoning to the user in real-time:
+- Before reading files: think("Let me check jac.toml for dependencies...")
+- After analyzing: think("I found Mantine components. I'll update the theme in global.css...")
+- Before editing: think("The issue is in the router. I'll fix the path matching...")
+- Before delegating: think("This needs a worker SubAgent for the frontend components...")
+- After validation: think("Validation passed with 2 warnings. Let me fix the import paths...")
+Don't over-narrate — skip think() for routine/obvious actions (e.g., simple reads in sequence).
+The user sees tool calls in real-time, so focus on WHY and WHAT YOU FOUND, not WHAT tool you're calling.
+
+## CRITICAL: Intent detection — check BEFORE calling ANY tool
+
+**QUESTION** (answer with text only, call NO tools, write NO files):
+- "how can I build X", "how do I create X", "what is X", "explain X", "is it possible to X", "what would X look like", "tell me about X"
+- These ask for information. Respond with a brief explanation only.
+
+**EXECUTION** (use tools):
+- "create X", "build X for me", "make X", "implement X", "write X", "scaffold X"
+- These are direct instructions to do work.
+
+**AMBIGUOUS** (call `ask_question` first):
+- Short phrases like "todo app", "lms site" with no clear verb → ask: "Would you like me to build this, or would you like an explanation of how to approach it?"
+
+Examples:
+- "how can I build a LMS?" → text explanation only, no tools
+- "build me a LMS" → use tools to build it
+- "how do I add auth?" → text explanation only
+- "add auth to my app" → use tools
+
+## Response rules (READ FIRST)
+- "hi" → "Hi! What would you like to build?" (ONE line)
+- After writing code → "Done. Created X, Y, Z." (list files, nothing else)
+- After fixing a bug → "Fixed. The issue was X." (one sentence)
+- After exploring → report findings briefly with file paths
+- Keep final responses brief — the user already saw your reasoning via think() calls
+- Don't repeat what you narrated during the build
+- The user ALREADY sees every tool call in real-time — don't repeat them in your response
+- If the user says "cool" or "nice" or "thanks" → acknowledge in ONE line, don't summarize the whole session
+
+## When to handle directly
+- Simple questions, file reads, searches, git operations, greetings.
+- Small code edits (1-2 files): call `jac_docs(query)` first, then `edit_code`/`write_code`.
+
+## When to delegate to SubAgent
+- **Code generation** (building features, creating components, multi-file changes): `spawn_agent(task, mode="worker")`.
+- **Deep exploration** (analyzing multiple directories, comparing architectures, reading 10+ files): `spawn_agent(task, mode="explorer")`.
+- **Multiple independent tasks** (e.g. "explore 3 projects"): spawn one SubAgent PER task — each gets a focused, isolated context.
+- **Complex builds** (full app): think → spawn worker for backend → review → spawn worker for frontend → review → spawn worker for integration.
+
+## How to delegate well
+1. Call `think()` to plan what SubAgents are needed.
+2. Gather context first — read key files, run `analyze_project()`.
+3. Write a DETAILED instruction for each SubAgent including: what to do, file paths, existing code context, build order, constraints.
+4. Review each SubAgent's result before spawning the next.
+
+## Key rules for code writing
+- ALWAYS call `jac_docs(query)` before writing Jac code.
+- Jac is NOT Python or TypeScript — check syntax first.
+- `write_code`/`edit_code` catch SYNTAX errors instantly. Type errors are NOT checked per-file.
+- After writing ALL files, call `validate_project(directory)` to batch type-check and auto-fix.
+- Use ABSOLUTE file paths for all operations.
+
+## Validation workflow
+1. Write all files freely (syntax checked per-file, type errors deferred).
+2. Call `validate_project(directory)` — auto-fixes root()→root(), (?:)→[?:], returns all type errors with hints.
+3. Read the report, batch-fix all remaining errors.
+4. Call `validate_project()` again to confirm clean.
+
+## Tools
+- `think(thought)` — narrate your reasoning to the user in real-time. Use before key decisions, after discoveries, and when planning next steps.
+- `spawn_agent(task, mode)` — delegate. mode="worker" (read+write) or "explorer" (read-only).
+- `read_file`, `find_files`, `grep_search`, `list_files` — explore codebase.
+- `analyze_project(dir)`, `find_symbol(name)` — compiler-level Jac analysis.
+- `jac_docs(query)` — look up Jac syntax before coding.
+- `edit_code`, `write_code` — code changes (syntax-checked per-file).
+- `validate_project(dir)` — batch type-check + auto-fix after writing all files.
+- `git_status`, `git_diff`, `git_log`, `git_commit` — version control.
+- `run_command(cmd)` — shell commands.
+- `ask_question(q)` — clarify with user.
+- `update_todos(todos)` — track progress on multi-step work.
+- `capture_preview(viewport)` — quick screenshot + brief AI description of the rendered UI. Use for a quick look only. Does NOT evaluate against intent.
+- `evaluate_preview(intent, viewport)` — screenshot + PASS/PARTIAL/FAIL evaluation against intent. This is the PRIMARY preview tool. Do NOT call capture_preview before evaluate_preview (it takes its own screenshot).
+
+## Visual feedback workflow (when preview is available)
+Use preview tools INTELLIGENTLY — not after every single .cl.jac edit:
+- **When to check**: After completing a MEANINGFUL set of related UI changes (e.g., finished a component, done with layout restructuring, completed a styling pass).
+- **When to SKIP**: Minor tweaks (renaming a variable, fixing a typo), intermediate edits when you plan more changes to the same component, backend-only changes (.jac files, not .cl.jac).
+- **Goal**: Give the user a good experience — verify at natural checkpoints, not after every file save.
+
+Tools:
+- **Default**: `evaluate_preview(intent)` — takes screenshot, evaluates against intent, returns verdict. Use this.
+- **Quick look only**: `capture_preview()` — just describes what's on screen (no evaluation). Rarely needed.
+RULES:
+- NEVER call both tools for the same change — evaluate_preview already screenshots.
+- NEVER call the same preview tool twice in a row — one call is enough.
+- Skip preview tools entirely for backend-only changes (.jac files, not .cl.jac).
+""";
+
+
+# ---------------------------------------------------------------------------
+# SubAgent walkers — sem annotations and entry ability implementations
+# ---------------------------------------------------------------------------
+sem WorkerAgent.do_work = "You are an expert Jac/Jaseci stack coding agent. CRITICAL: Jac is NOT Python or TypeScript — you MUST look up syntax continuously. WORKFLOW: 1) Call jac_docs(query) BEFORE writing ANY code. 2) Call jac_docs AGAIN before EACH new file type (.cl.jac vs .jac have different syntax). 3) If working on existing project, call analyze_project(directory) first. 4) Build BOTTOM-UP: dependencies before importers. 5) Write ALL files freely — write_code/edit_code catch syntax errors. Do NOT call jac_check manually. 6) After ALL files written, call validate_project(directory) ONCE. 7) Build until ENTIRE task is complete. DOCS RULE: If you are UNSURE about ANY Jac syntax — imports, state, effects, rendering, types — call jac_docs(query) IMMEDIATELY. Do NOT guess. Call jac_docs at least once every 3-4 tool calls. KEY RULES: .cl.jac: has x: str auto-generates x and setX — NEVER define set<Var>. NEVER use lambda in .cl.jac — use def handle_something() and pass by name. Use Reflect.construct(Date, []) for JS built-ins. Use list comprehension for rendering — NEVER .map(). Backend: def:pub/def:priv endpoints in main.jac. Imports: DOTS for path separators NEVER slashes. sv import has NO quotes. Use ABSOLUTE file paths. PREVIEW TOOLS: Use evaluate_preview(intent) to verify UI at NATURAL CHECKPOINTS — after completing a meaningful set of related .cl.jac changes (finished a component, done with layout, completed styling). Do NOT evaluate after every single edit. Do NOT call capture_preview before evaluate_preview. Do NOT call preview tools twice in a row. Skip for backend-only changes.";
+
+sem ExplorerAgent.do_work = "You are a Jac codebase analyst. Read files, search code, and analyze project structure to answer questions thoroughly. Use analyze_project(directory) for full AST-level project overview. Use find_symbol(name) to locate specific nodes, walkers, or types. Use jac_docs(query) to look up Jac language syntax and patterns. Be thorough — read all relevant files before forming conclusions. Report findings with file paths and line numbers.";
+
+
+"""Consume a SubAgent's by llm() stream, forward events, and return results."""
+def _consume_subagent_stream(event_stream: Any, prefix: str, track_files: bool = False) -> dict {
+    import sys;
+    import from jac_coder.events { set_agent_prefix, emit_event }
+    ;
+
+    set_agent_prefix(prefix);
+    sys.stderr.write("\n");
+    sys.stderr.flush();
+
+    content = "";
+    used_tools: list = [];
+    fmod: list = [];
+
+    for event in event_stream {
+        if event.event_type == "thought" {
+            emit_event("llm_thought", dict(event.data));
+        } elif event.event_type == "tool_call" {
+            tool_name = event.data.get("tool", "");
+            if tool_name and tool_name != "finish_tool" {
+                used_tools.append(tool_name);
+                if track_files {
+                    args = event.data.get("args", {});
+                    if tool_name in ["write_code", "edit_code", "write_file", "edit_file"] {
+                        fp = args.get("file_path", "");
+                        if fp and fp not in fmod {
+                            fmod.append(fp);
+                        }
+                    }
+                }
+            }
+            emit_event("llm_tool_call", dict(event.data));
+        } elif event.event_type == "tool_result" {
+            emit_event("llm_tool_result", dict(event.data));
+        } elif event.event_type == "steps_done" {
+            emit_event("llm_steps_done", dict(event.data));
+        } elif event.event_type == "chunk" {
+            content += event.data.get("content", "");
+        } elif event.event_type == "usage" {
+            emit_event("llm_usage", dict(event.data));
+        }
+    }
+
+    set_agent_prefix("");
+    return {"content": content, "tools_used": used_tools, "files_modified": fmod};
+}
+
+
+impl WorkerAgent.execute with MainAgent entry {
+    result = _consume_subagent_stream(
+        self.do_work(task_str=self.task), "sub:worker", track_files=True
+    );
+    self.result_content = result["content"];
+    self.result_tools = result["tools_used"];
+    self.result_files = result["files_modified"];
+}
+
+
+impl ExplorerAgent.execute with MainAgent entry {
+    result = _consume_subagent_stream(
+        self.do_work(task_str=self.task), "sub:explorer"
+    );
+    self.result_content = result["content"];
+    self.result_tools = result["tools_used"];
+    self.result_files = [];
+}

jac_coder/impl/permission.impl.jac

@@ -0,0 +1,62 @@
+impl PermissionEngine.init_defaults() -> None {
+    for tool in [
+        "read_file",
+        "list_files",
+        "grep_search",
+        "find_files",
+        "web_fetch",
+        "web_search",
+        "ask_question",
+        "update_todos",
+        "jac_check",
+        "jac_run",
+        "spawn_task"
+    ] {
+        self.rules.append(PermissionRule(tool=tool, action="allow"));
+    }
+    for tool in ["write_file", "edit_file", "bash_exec"] {
+        self.rules.append(PermissionRule(tool=tool, action="ask"));
+    }
+}
+
+
+impl PermissionEngine.check(tool_id: str, resource: str = "") -> str {
+    if tool_id in self.always_allowed {
+        for pattern in self.always_allowed[tool_id] {
+            if pattern == "*" or fnmatch.fnmatch(resource, pattern) {
+                return "allow";
+            }
+        }
+    }
+
+    matched_rule: PermissionRule | None = None;
+    for rule in self.rules {
+        if rule.tool == "*" or rule.tool == tool_id {
+            if rule.pattern == "*" or fnmatch.fnmatch(resource, rule.pattern) {
+                matched_rule = rule;
+            }
+        }
+    }
+
+    if matched_rule is None {
+        return "ask";
+    }
+    return matched_rule.action;
+}
+
+
+impl PermissionEngine.remember_allow(tool_id: str, pattern: str = "*") -> None {
+    if tool_id not in self.always_allowed {
+        self.always_allowed[tool_id] = [];
+    }
+    if pattern not in self.always_allowed[tool_id] {
+        self.always_allowed[tool_id].append(pattern);
+    }
+}
+
+
+impl PermissionEngine.enable_web_mode() -> None {
+    self.remember_allow("write_file", "*");
+    self.remember_allow("edit_file", "*");
+    self.remember_allow("bash_exec", "*");
+}

jac_coder/impl/walkers.impl.jac

@@ -0,0 +1,298 @@
+impl ensure_main_agent() -> MainAgent {
+    agents = [root()-->][?:MainAgent];
+    if agents {
+        return agents[0];
+    }
+    agent = MainAgent();
+    root() ++> agent;
+    return agent;
+}
+
+
+impl new_session.create with Root entry {
+    session = Session(title=self.title, directory=self.directory);
+    here ++> session;
+    agent = ensure_main_agent();
+    session ++> agent;
+    report {"session_id": session.id, "title": session.title, "status": "created"};
+}
+
+
+impl list_sessions.list with Root entry {
+    active = [-->][?:Session][?status=="active"];
+    result = [];
+    for s in active {
+        user_msgs = len(
+            [
+                m
+                for m in s.chat_history
+                if m["role"] == "user"
+            ]
+        );
+        result.append(
+            {
+                "id": s.id,
+                "title": s.title,
+                "message_count": user_msgs,
+                "updated_at": s.updated_at
+            }
+        );
+    }
+    result.sort(key=lambda x : x["updated_at"], reverse=True);
+    report {"sessions": result};
+}
+
+
+impl get_session.fetch with Root entry {
+    matches = [-->][?:Session][?id==self.session_id];
+    if matches {
+        session = matches[0];
+        report {
+            "id": session.id,
+            "title": session.title,
+            "status": session.status,
+            "directory": session.directory,
+            "chat_history": session.chat_history,
+            "created_at": session.created_at,
+            "updated_at": session.updated_at
+        };
+    } else {
+        report {"error": "Session not found"};
+    }
+}
+
+
+impl close_session.close with Root entry {
+    matches = [-->][?:Session][?id==self.session_id];
+    if matches {
+        matches[0].status = "closed";
+        matches[0].updated_at = datetime.now().isoformat();
+        report {"status": "closed", "id": matches[0].id};
+    } else {
+        report {"error": "Session not found"};
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Step 1: init_session @ Root — find or create session, visit it
+# ---------------------------------------------------------------------------
+impl interact.init_session with Root entry {
+    agent = ensure_main_agent();
+    matches = [-->][?:Session][?id==self.session_id];
+    if matches {
+        session = matches[0];
+        if not [session-->[?:MainAgent]] {
+            session ++> agent;
+        }
+        visit session;
+    } else {
+        now = datetime.now().isoformat();
+        session_node = here ++> Session(
+            id=self.session_id, chat_history=[], created_at=now, updated_at=now
+        );
+        session_node ++> agent;
+        visit session_node;
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Step 2: enter_session @ Session — load memory, append message, visit agent
+# ---------------------------------------------------------------------------
+impl interact.enter_session with Session entry {
+    tool_end();
+    reset_steps();
+    start_turn();
+
+    # Sandbox only enforced in web/API mode (JacBuilder sets it via api.chat).
+    # CLI mode leaves sandbox open so the agent can access any path.
+
+    # Initialize project memory on first visit
+    if here.directory and not here.project_summary {
+        import os as _os;
+        memory = find_or_create_memory(here.directory);
+        if memory {
+            has_project = (
+                _os.path.exists(_os.path.join(here.directory, "jac.toml"))
+                or _os.path.exists(_os.path.join(here.directory, "main.jac"))
+            );
+            if not memory.architecture and not memory.scan_attempted and has_project {
+                _init_memory(memory, here.directory);
+            }
+            summary = memory.summarize();
+            if summary {
+                here.project_summary = summary;
+            }
+        }
+    }
+
+    # Append user message and update
+    here.chat_history.append({"role": "user", "content": self.message});
+    here.updated_at = datetime.now().isoformat();
+    self.chat_history = here.chat_history;
+
+    # Visit MainAgent
+    visit [-->][?:MainAgent] else {
+        agent = ensure_main_agent();
+        here ++> agent;
+        visit agent;
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Step 3: respond @ MainAgent — the agent handles everything
+# ---------------------------------------------------------------------------
+impl interact.respond with MainAgent entry {
+    _respond_and_persist(here, self);
+}
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+impl _find_session(session_id: str) -> Session | None {
+    matches = [root()-->][?:Session][?id==session_id];
+    return matches[0] if matches else None;
+}
+
+
+impl _persist_response(
+    session_id: str,
+    response: str,
+    agent_mode: str,
+    tools_used: list[str] = [],
+    files_modified: list[str] = []
+) -> None {
+    session = _find_session(session_id);
+    if session {
+        record: dict = {"role": "assistant", "content": response, "agent": agent_mode};
+        if tools_used {
+            record["tools_used"] = tools_used;
+        }
+        if files_modified {
+            record["files_modified"] = files_modified;
+        }
+        session.chat_history.append(record);
+        session.last_agent = agent_mode;
+        session.updated_at = datetime.now().isoformat();
+    }
+}
+
+
+impl _consume_llm_stream(event_stream: Any) -> dict {
+    response_text = "";
+    tools_used: list = [];
+
+    for event in event_stream {
+        if event.event_type == "thought" {
+            emit_event("llm_thought", dict(event.data));
+        } elif event.event_type == "tool_call" {
+            tool_name = event.data.get("tool", "");
+            if tool_name and tool_name != "finish_tool" {
+                tools_used.append(tool_name);
+            }
+            emit_event("llm_tool_call", dict(event.data));
+        } elif event.event_type == "tool_result" {
+            emit_event("llm_tool_result", dict(event.data));
+        } elif event.event_type == "steps_done" {
+            emit_event("llm_steps_done", dict(event.data));
+        } elif event.event_type == "chunk" {
+            response_text += event.data.get("content", "");
+        } elif event.event_type == "usage" {
+            emit_event("llm_usage", dict(event.data));
+        }
+    }
+
+    return {
+        "content": response_text,
+        "tools_used": tools_used
+    };
+}
+
+
+impl _respond_and_persist(agent: MainAgent, ctx: interact) -> None {
+    session = _find_session(ctx.session_id);
+    active_files = session.active_files if session else [];
+    pending_errors = session.pending_errors if session else [];
+    project_summary = session.project_summary if session else "";
+
+    # Build compacted context
+    ctx_history = build_context(
+        ctx.chat_history, active_files, pending_errors, project_summary=project_summary
+    );
+
+    # If agent_context was provided (e.g. from JacBuilder), inject it
+    if ctx.agent_context {
+        ctx_history.insert(0, {"role": "system", "content": ctx.agent_context});
+    }
+
+    # Initialize shared budget for SubAgents
+    import from jac_coder.tool.delegation { init_budget }
+    config = get_config();
+    init_budget(config.max_react_iterations * 3);
+
+    # Call MainAgent — returns StreamEvent generator with logging enabled
+    event_stream = agent.respond(message=ctx.message, chat_history=ctx_history);
+    stream_result = _consume_llm_stream(event_stream);
+
+    response_text = stream_result["content"];
+    tools_used = stream_result["tools_used"];
+
+    # Finalize turn — get accumulated file/error data from tool internals
+    tool_end();
+    summary = emit_turn_summary();
+
+    files_modified = summary.get("files_modified", []);
+    has_errors = summary.get("errors", 0) > 0;
+
+    # Post-process: update session state
+    if session {
+        if files_modified {
+            for f in files_modified {
+                if f not in session.active_files {
+                    session.active_files.append(f);
+                }
+            }
+            if len(session.active_files) > 10 {
+                session.active_files = session.active_files[-10:];
+            }
+        }
+        if has_errors {
+            files_str = ", ".join(files_modified)
+                if files_modified
+                else "unknown";
+            session.pending_errors = [f"Errors in previous turn (files: {files_str})"];
+        } else {
+            session.pending_errors = [];
+        }
+        if files_modified and session.directory {
+            memory = find_or_create_memory(session.directory);
+            if memory {
+                update_memory_from_session(
+                    memory, files_modified, response_text[:500]
+                );
+                session.project_summary = memory.summarize();
+            }
+        }
+    }
+
+    _persist_response(
+        ctx.session_id,
+        response_text,
+        "main",
+        tools_used,
+        files_modified
+    );
+
+    report {
+        "response": response_text,
+        "agent": "main",
+        "tools_used": tools_used,
+        "files_modified": files_modified,
+        "has_errors": has_errors,
+        "next_steps": [],
+        "turn_summary": summary
+    };
+}

jac_coder/mcp_manager.jac

@@ -0,0 +1,35 @@
+"""MCP server registry for jac-coder.
+
+Manages connections to external MCP servers so the agent can call their tools.
+Server configs are stored in the Jac graph (McpRegistry node) and persisted
+automatically by jaclang's TieredMemory (SQLite).
+
+Supported transport types:
+  stdio  — spawn a local subprocess (command + args)
+  http   — streamable-http remote server (url)
+  sse    — SSE remote server (url)
+"""
+
+import os;
+import json;
+
+
+"""Add or update an MCP server. Returns status dict."""
+def mcp_add_server(name: str, config: dict) -> dict;
+
+"""Remove an MCP server by name. Returns status dict."""
+def mcp_remove_server(name: str) -> dict;
+
+"""List all configured MCP servers with their tool counts."""
+def mcp_list_servers() -> list;
+
+"""Return all tools from all configured MCP servers as a flat list."""
+def mcp_get_tools() -> list;
+
+"""Call a specific tool on a specific MCP server."""
+def mcp_call_tool(server_name: str, tool_name: str, arguments: dict) -> str;
+
+"""Register a built-in server without checking connection.
+Saves now and tries it on first real tool call.
+"""
+def mcp_register_builtin(name: str, config: dict) -> None;

jac_coder/memory.jac

@@ -0,0 +1,15 @@
+import os;
+import sys;
+
+import from datetime { datetime }
+import from jac_coder.nodes { ProjectMemory }
+import from jac_coder.tool.jac_analyzer { _analyze_project, _find_jac_files }
+
+
+def find_or_create_memory(project_dir: str) -> ProjectMemory | None;
+
+def _init_memory(memory: ProjectMemory, project_dir: str) -> None;
+
+def update_memory_from_session(
+    memory: ProjectMemory, files_modified: list[str], session_summary: str
+) -> None;