jac-coder 0.1.0__py3-none-any.whl

jac_coder/impl/api.impl.jac

@@ -0,0 +1,399 @@
+# ---------------------------------------------------------------------------
+# init
+# ---------------------------------------------------------------------------
+impl initialize(mode: str = "web") -> None {
+    if mode == "web" {
+        os.environ["JACCODER_WEB_MODE"] = "1";
+        permission_engine.init_defaults();
+        permission_engine.enable_web_mode();
+    } else {
+        permission_engine.init_defaults();
+    }
+    # Register jac-mcp using the current venv's python so it's always available.
+    import sys as _sys;
+    try {
+        jac_cmd = [_sys.executable, "-m", "jaclang", "mcp"];
+        mcp_register_builtin("jac-mcp", {"type": "stdio", "command": jac_cmd});
+    } except Exception as e {
+        _sys.stderr.write(f"[mcp] jac-mcp not available: {e}. Install with: pip install jac-mcp\n");
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Session lifecycle
+# ---------------------------------------------------------------------------
+impl create_session(directory: str, title: str = "", agent: str = "main") -> dict {
+    session_title = title if title else f"Session-{datetime.now().strftime('%H%M%S')}";
+    try {
+        before_ids = set([s.id for s in [root()-->][?:Session]]);
+    } except Exception {
+        before_ids = set();
+    }
+
+    root() spawn new_session(title=session_title, directory=directory);
+
+    session_id = "";
+    session_obj = None;
+    for s in [root()-->][?:Session] {
+        if s.id not in before_ids {
+            session_id = s.id;
+            session_obj = s;
+            break;
+        }
+    }
+    if not session_id {
+        return {"error": "Failed to create session"};
+    }
+
+    # Store in registry so background threads can find it
+    _session_registry[session_id] = session_obj;
+
+    return {"session_id": session_id, "title": session_title, "status": "created"};
+}
+
+
+impl list_sessions() -> list {
+    result: list = [];
+    try {
+        sessions = [root()-->][?:Session][?status=="active"];
+    } except Exception {
+        return [];
+    }
+    for s in sessions {
+        try {
+            user_msgs = len([m for m in s.chat_history if m.get("role") == "user"]);
+            result.append(
+                {
+                    "id": s.id,
+                    "title": s.title,
+                    "message_count": user_msgs,
+                    "updated_at": s.updated_at
+                }
+            );
+        } except Exception {
+            continue;
+        }
+    }
+    result.sort(key=lambda x : x["updated_at"], reverse=True);
+    return result;
+}
+
+
+impl get_session(session_id: str) -> dict {
+    matches = [root()-->][?:Session][?id==session_id];
+    if not matches {
+        return {"error": "Session not found"};
+    }
+    s = matches[0];
+    return {
+        "id": s.id,
+        "title": s.title,
+        "status": s.status,
+        "directory": s.directory,
+        "chat_history": s.chat_history,
+        "created_at": s.created_at,
+        "updated_at": s.updated_at
+    };
+}
+
+
+impl close_session(session_id: str) -> dict {
+    matches = [root()-->][?:Session][?id==session_id];
+    if not matches {
+        return {"error": "Session not found"};
+    }
+    matches[0].status = "closed";
+    matches[0].updated_at = datetime.now().isoformat();
+    _session_registry.pop(session_id, None);
+    return {"status": "closed", "id": matches[0].id};
+}
+
+
+# ---------------------------------------------------------------------------
+# chat — the main entry point
+# ---------------------------------------------------------------------------
+impl chat(
+    session_id: str,
+    message: str,
+    directory: str = "",
+    on_event: Any = None,
+    mode: str = "full",
+    agent_context: str = ""
+) -> dict {
+    # Find session — try registry first (works across threads), then graph
+    session = _session_registry.get(session_id);
+    if not session {
+        matches = [root()-->][?:Session][?id==session_id];
+        if matches {
+            session = matches[0];
+            _session_registry[session_id] = session;
+        }
+    }
+    if not session {
+        return {"error": "Session not found", "agent": "error"};
+    }
+
+    # Override directory if provided
+    if directory {
+        session.directory = directory;
+    }
+    work_dir = session.directory;
+
+    # Setup
+    reset_steps();
+    start_turn();
+    if work_dir {
+        set_sandbox_root(work_dir);
+    }
+    if on_event {
+        register_event_callback(on_event);
+    }
+
+    try {
+        # Memory initialization
+        _ensure_memory(session, work_dir);
+
+        # Add user message
+        session.chat_history.append({"role": "user", "content": message});
+        session.updated_at = datetime.now().isoformat();
+
+        # Get MainAgent — always resolve fresh (cached refs go stale in jac serve)
+        main_agent = ensure_main_agent();
+
+        # Initialize shared budget for SubAgents
+        config = get_config();
+        _init_spawn_budget(config.max_react_iterations * 3);
+
+        # Build context
+        ctx_history = build_context(
+            session.chat_history,
+            session.active_files,
+            session.pending_errors,
+            project_summary=session.project_summary or ""
+        );
+
+        # Inject agent_context if provided (e.g. from JacBuilder)
+        if agent_context {
+            ctx_history.insert(0, {"role": "system", "content": agent_context});
+        }
+
+        # Inject available MCP tools into context so agent knows what's callable
+        try {
+            mcp_tools = mcp_get_tools();
+        } except Exception {
+            mcp_tools = [];
+        }
+        if mcp_tools {
+            lines: list = [
+                "Available MCP tools — call via mcp_call(server_name, tool_name, arguments_json):",
+                "Check each tool's inputSchema for required arguments before calling."
+            ];
+            for t in mcp_tools {
+                schema_hint = "";
+                input_schema = t.get("inputSchema", {});
+                if input_schema {
+                    required = input_schema.get("required", []);
+                    if required {
+                        schema_hint = f"  required: {', '.join(required)}";
+                    }
+                }
+                lines.append(f"  - server={t['server']}  tool={t['name']}  {t['description']}{schema_hint}");
+            }
+            mcp_sys_msg: dict = {"role": "system", "content": "\n".join(lines)};
+            ctx_with_mcp: list[dict] = [mcp_sys_msg];
+            ctx_with_mcp.extend(ctx_history);
+            ctx_history = ctx_with_mcp;
+        }
+
+        # Call MainAgent — returns StreamEvent generator with logging enabled
+        event_stream = main_agent.respond(message=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;
+
+        # Update session state
+        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
+        record: dict = {"role": "assistant", "content": response_text, "agent": "main"};
+        if tools_used {
+            record["tools_used"] = tools_used;
+        }
+        if files_modified {
+            record["files_modified"] = files_modified;
+        }
+        session.chat_history.append(record);
+        session.last_agent = "main";
+        session.updated_at = datetime.now().isoformat();
+
+        return {
+            "response": response_text,
+            "agent": "main",
+            "tools_used": tools_used,
+            "files_modified": files_modified,
+            "has_errors": has_errors,
+            "next_steps": [],
+            "turn_summary": summary
+        };
+    } except Exception as e {
+        sys.stderr.write(f"[api] chat error: {e}\n");
+        return {"error": str(e), "agent": "error"};
+    } finally {
+        if on_event {
+            clear_event_callbacks();
+        }
+    }
+}
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+def _ensure_memory(session: Session, work_dir: str) -> None {
+    if not work_dir or session.project_summary {
+        return;
+    }
+    memory = find_or_create_memory(work_dir);
+    if not memory {
+        return;
+    }
+    has_project = (
+        os.path.exists(os.path.join(work_dir, "jac.toml"))
+        or os.path.exists(os.path.join(work_dir, "main.jac"))
+    );
+    if not memory.architecture and not memory.scan_attempted and has_project {
+        _init_memory(memory, work_dir);
+    }
+    summary = memory.summarize();
+    if summary {
+        session.project_summary = summary;
+    }
+}
+
+
+def _post_process(session: Session, response_obj: Any) -> None {
+    # Track files
+    if response_obj.files_modified {
+        for f in response_obj.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:];
+        }
+    }
+
+    # Track errors
+    if response_obj.has_errors {
+        files_str = ", ".join(response_obj.files_modified)
+            if response_obj.files_modified
+            else "unknown";
+        session.pending_errors = [f"Errors in previous turn (files: {files_str})"];
+    } else {
+        session.pending_errors = [];
+    }
+
+    # Update memory
+    if response_obj.files_modified and session.directory {
+        memory = find_or_create_memory(session.directory);
+        if memory {
+            update_memory_from_session(
+                memory, response_obj.files_modified, response_obj.content[:500]
+            );
+            session.project_summary = memory.summarize();
+        }
+    }
+
+    # Persist response
+    record: dict = {
+        "role": "assistant",
+        "content": response_obj.content,
+        "agent": "main"
+    };
+    if response_obj.tools_used {
+        record["tools_used"] = response_obj.tools_used;
+    }
+    if response_obj.files_modified {
+        record["files_modified"] = response_obj.files_modified;
+    }
+    session.chat_history.append(record);
+    session.last_agent = "main";
+    session.updated_at = datetime.now().isoformat();
+}
+
+
+# ---------------------------------------------------------------------------
+# Model management API
+# ---------------------------------------------------------------------------
+impl api_set_model(model: str) -> dict {
+    return _set_model(model);
+}
+
+impl api_get_model() -> dict {
+    return _get_model();
+}
+
+
+# ---------------------------------------------------------------------------
+# MCP management API
+# ---------------------------------------------------------------------------
+impl api_mcp_add(name: str, config: dict) -> dict {
+    raw = mcp_add_server(name, config);
+    result: dict = {**raw};
+    return result;
+}
+
+impl api_mcp_remove(name: str) -> dict {
+    raw = mcp_remove_server(name);
+    result: dict = {**raw};
+    return result;
+}
+
+impl api_mcp_list() -> list {
+    raw = mcp_list_servers();
+    result: list = [*raw];
+    return result;
+}
+
+
+def _init_spawn_budget(total: int) -> None {
+    try {
+        import from jac_coder.tool.delegation { init_budget }
+        ;
+        init_budget(total);
+    } except Exception { }
+}

jac_coder/impl/config.impl.jac

@@ -0,0 +1,163 @@
+impl get_home_dir() -> str {
+    home = os.path.join(os.path.expanduser("~"), ".jaccoder");
+    os.makedirs(home, exist_ok=True);
+    return home;
+}
+
+
+glob _STR_FIELDS: list = ["default_model"];
+glob _FLOAT_FIELDS: list = ["temperature"];
+glob _INT_FIELDS: list = ["max_tokens", "max_react_iterations"];
+
+
+impl _merge_from_file(config: JacCoderConfig, path: str) -> None {
+    try {
+        with open(path, "r") as f {
+            data = json.load(f);
+        }
+    } except (json.JSONDecodeError, FileNotFoundError, OSError) {
+        return;
+    }
+    for key in _STR_FIELDS {
+        if key in data {
+            setattr(config, key, str(data[key]));
+        }
+    }
+    for key in _FLOAT_FIELDS {
+        if key in data {
+            try {
+                setattr(config, key, float(data[key]));
+            } except (ValueError, TypeError) { }
+        }
+    }
+    for key in _INT_FIELDS {
+        if key in data {
+            try {
+                setattr(config, key, int(data[key]));
+            } except (ValueError, TypeError) { }
+        }
+    }
+}
+
+
+impl load_config(project_dir: str = "") -> JacCoderConfig {
+    global _config;
+    config = JacCoderConfig();
+
+    if project_dir {
+        config.project_dir = os.path.realpath(project_dir);
+    } else {
+        config.project_dir = os.getcwd();
+    }
+
+    global_path = os.path.join(get_home_dir(), "config.json");
+    if os.path.exists(global_path) {
+        _merge_from_file(config, global_path);
+    }
+
+    project_path = os.path.join(config.project_dir, "jaccoder.json");
+    if os.path.exists(project_path) {
+        _merge_from_file(config, project_path);
+    }
+
+    env_overrides: list = [
+        ("MODEL", "default_model", str),
+        ("TEMPERATURE", "temperature", float),
+        ("MAX_TOKENS", "max_tokens", int),
+        ("MAX_REACT_ITERATIONS", "max_react_iterations", int)
+    ];
+    for (env_key, attr, cast) in env_overrides {
+        val = os.environ.get(env_key, "");
+        if val {
+            try {
+                setattr(config, attr, cast(val));
+            } except (ValueError, TypeError) { }
+        }
+    }
+
+    _config = config;
+    return config;
+}
+
+
+impl get_config() -> JacCoderConfig {
+    global _config;
+    return _config;
+}
+
+
+# ---------------------------------------------------------------------------
+# Model switching — simple swap, keys come from env/.env
+# ---------------------------------------------------------------------------
+"""Switch the active LLM model. Mutates the existing Model object
+so all modules that imported `llm` see the change immediately."""
+impl set_model(model: str) -> dict {
+    global model_name, _config;
+    model = model.strip();
+    if not model {
+        return {"error": "Model name cannot be empty"};
+    }
+    model_name = model;
+    llm.model_name = model;
+    _config.default_model = model;
+    return {"status": "ok", "model": model};
+}
+
+"""Return current model name."""
+impl get_model() -> dict {
+    return {"model": model_name};
+}
+
+
+glob _data_dir_cache: str = "";
+
+impl get_data_dir() -> str {
+    global _data_dir_cache;
+    if _data_dir_cache {
+        return _data_dir_cache;
+    }
+
+    # Strategy 1: JACCODER_ROOT env var
+    jc_root = os.environ.get("JACCODER_ROOT", "");
+    if jc_root {
+        candidate = os.path.join(jc_root, "jac_coder", "data");
+        if os.path.isdir(os.path.join(candidate, "rules")) {
+            _data_dir_cache = candidate;
+            return _data_dir_cache;
+        }
+    }
+
+    # Strategy 2: walk up from __file__ until we find jac_coder/data/rules
+    path = os.path.abspath(__file__);
+    for _i in range(10) {
+        path = os.path.dirname(path);
+        if path == os.path.dirname(path) {
+            break;
+        }
+        candidate = os.path.join(path, "data");
+        if os.path.isdir(os.path.join(candidate, "rules")) {
+            _data_dir_cache = candidate;
+            return _data_dir_cache;
+        }
+        candidate = os.path.join(path, "jac_coder", "data");
+        if os.path.isdir(os.path.join(candidate, "rules")) {
+            _data_dir_cache = candidate;
+            return _data_dir_cache;
+        }
+    }
+
+    # Strategy 3: CWD based
+    for base in [os.getcwd(), os.path.dirname(os.getcwd())] {
+        candidate = os.path.join(base, "jac_coder", "data");
+        if os.path.isdir(os.path.join(candidate, "rules")) {
+            _data_dir_cache = candidate;
+            return _data_dir_cache;
+        }
+    }
+
+    # Fallback: best guess from __file__
+    _data_dir_cache = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "data"
+    );
+    return _data_dir_cache;
+}

jac_coder/impl/context.impl.jac

@@ -0,0 +1,117 @@
+def _build_prefix(
+    active_files: list[str], pending_errors: list[str], project_summary: str = ""
+) -> list[dict] {
+    parts = [];
+    if project_summary {
+        parts.append("Project context:\n" + project_summary);
+    }
+    if active_files {
+        parts.append("Active files: " + ", ".join(active_files));
+    }
+    if pending_errors {
+        parts.append("Pending errors:\n" + "\n".join(pending_errors));
+    }
+    if parts {
+        return [{"role": "system", "content": "\n\n".join(parts)}];
+    }
+    return [];
+}
+
+
+def _extract_key_actions(messages: list[dict]) -> str {
+    files = [];
+    for msg in messages {
+        if msg.get("role") == "assistant" {
+            for f in msg.get("files_modified", []) {
+                if f not in files {
+                    files.append(f);
+                }
+            }
+        }
+    }
+    if files {
+        return ", ".join(files[:5]);
+    }
+    return "exploration and planning";
+}
+
+
+def _select_important(older: list[dict]) -> list[dict] {
+    important = [];
+    i = 0;
+    while i < len(older) {
+        msg = older[i];
+        if msg.get("role") == "assistant" {
+            content = msg.get("content", "");
+            files = msg.get("files_modified", []);
+            is_important = (
+                len(files) > 0
+                or "ACTION REQUIRED" in content
+                or "VALIDATION ERRORS" in content
+                or "RUNTIME ERRORS" in content
+            );
+            if is_important {
+                if i > 0 and older[i - 1] not in important {
+                    important.append(older[i - 1]);
+                }
+                important.append(msg);
+            }
+        }
+        i += 1;
+    }
+    return important;
+}
+
+
+impl estimate_tokens(messages: list[dict]) -> int {
+    total = 0;
+    for msg in messages {
+        total += len(msg.get("content", ""));
+    }
+    return total // 4;
+}
+
+
+impl needs_compaction(messages: list[dict], budget: int = 20000) -> bool {
+    return estimate_tokens(messages) > int(budget * 0.8);
+}
+
+
+impl build_context(
+    chat_history: list[dict],
+    active_files: list[str] = [],
+    pending_errors: list[str] = [],
+    config: ContextConfig | None = None,
+    project_summary: str = ""
+) -> list[dict] {
+    cfg = config if config else ContextConfig();
+    prefix = _build_prefix(active_files, pending_errors, project_summary);
+
+    if not needs_compaction(chat_history, cfg.token_budget) {
+        return prefix + list(chat_history);
+    }
+
+    recent_msg_count = cfg.recent_window * 2;
+    if len(chat_history) <= recent_msg_count {
+        return prefix + list(chat_history);
+    }
+
+    recent = chat_history[-recent_msg_count:];
+    older = chat_history[:-recent_msg_count];
+
+    important = _select_important(older);
+
+    non_important_count = (len(older) - len(important)) // 2;
+    result = list(prefix);
+    if non_important_count > 0 {
+        actions = _extract_key_actions(older);
+        summary = (
+            f"[Context compacted: {non_important_count} earlier exchanges condensed. "
+            f"Key actions: {actions}]"
+        );
+        result.append({"role": "system", "content": summary});
+    }
+    result.extend(important);
+    result.extend(recent);
+    return result;
+}