jac-coder 0.2.5__tar.gz → 0.2.6__tar.gz

{jac_coder-0.2.5 → jac_coder-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jac-coder
-Version: 0.2.5
+Version: 0.2.6
 Summary: AI coding agent backend for Jac, powered by jac-byllm
 Requires-Python: >=3.12
 Requires-Dist: python-dotenv>=1.0.0

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/api.impl.jac

@@ -624,14 +624,27 @@ impl clarification_response(
     if not session_id {
         return {"ok": False, "error": "session_id required"};
     }
-    _clarification_decisions[session_id] = {
+    decision = {
         "request_id": request_id,
         "selected_id": selected_id,
         "custom_text": custom_text,
         "skipped": skipped
     };
+    # Cross-pod delivery: write to Redis so the waiting pod finds it on its next 250ms poll.
+    # Key scoped by request_id — a late response for a timed-out question can't
+    # pollute the next clarification on the same session.
+    # TTL 130s covers the 120s gate timeout + buffer; waiting pod deletes key on pick-up.
+    if os.environ.get("JACCODER_WEB_MODE", "") {
+        import from jac_coder.infra.kv { get_kv }
+        try {
+            get_kv().set_with_ttl(_CLRFY_KEY_PREFIX + session_id + ":" + request_id, decision, 130);
+        } except Exception { ; }
+    }
+    # Same-pod delivery: only store locally if the waiter gate exists on this pod.
+    # Avoids a permanent dict entry on cross-pod responder pods (no one ever pops it there).
     gate = _clarification_events.get(session_id);
     if gate {
+        _clarification_decisions[session_id] = decision;
         gate.set();
     }
     return {"ok": True};

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/api.jac

@@ -43,7 +43,8 @@ import from jac_coder.tool.run.guarded {
     _clear_chat_session,
     _chat_contexts,
     _clarification_events,
-    _clarification_decisions
+    _clarification_decisions,
+    _CLRFY_KEY_PREFIX
 }
 import from jac_coder.runtime.events {
     register_event_callback,

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/cli.jac

@@ -32,7 +32,13 @@ import from jac_coder.util.colors {
 }
 
 
-import from jac_coder.runtime.cost_tracker { record_cost, is_cost_tracking_enabled, reset_request_cost }
+import from jac_coder.runtime.cost_tracker {
+    record_cost,
+    is_cost_tracking_enabled,
+    reset_request_cost,
+    mark_call_started as _ct_mark_call_started,
+    mark_call_finished as _ct_mark_call_finished
+}
 
 # Session-wide accumulated cost totals for the CLI /cost command.
 # Accumulates across all turns in a single CLI session; reset by /cost reset.
@@ -87,6 +93,21 @@ with entry {
         import from litellm.integrations.custom_logger { CustomLogger as _CL }
 
         class _CostLogger(_CL) {
+            def log_pre_api_call(
+                self: _CostLogger,
+                model: object,
+                messages: object,
+                kwargs: dict
+            ) {
+                if is_cost_tracking_enabled() {
+                    try {
+                        _cid = str(kwargs.get("litellm_call_id", "") or "");
+                        _ct_mark_call_started(_cid);
+                    } except Exception {
+                        _ = 0;
+                    }
+                }
+            }
             def log_success_event(
                 self: _CostLogger,
                 kwargs: dict,
@@ -94,16 +115,41 @@ with entry {
                 start_time: object,
                 end_time: object
             ) {
-                if is_cost_tracking_enabled() {
-                    try {
+                _cid = str(kwargs.get("litellm_call_id", "") or "");
+                try {
+                    if is_cost_tracking_enabled() {
                         slp = kwargs.get("standard_logging_object") or {};
                         cost = float(slp.get("response_cost") or 0.0);
                         if cost > 0 {
-                            record_cost(cost);
+                            record_cost(cost, _cid);
+                        }
+                    }
+                } except Exception {
+                    _ = 0;
+                } finally {
+                    try { _ct_mark_call_finished(_cid); } except Exception { ; }
+                }
+            }
+            async def async_log_success_event(
+                self: _CostLogger,
+                kwargs: dict,
+                response_obj: object,
+                start_time: object,
+                end_time: object
+            ) {
+                _cid = str(kwargs.get("litellm_call_id", "") or "");
+                try {
+                    if is_cost_tracking_enabled() {
+                        slp = kwargs.get("standard_logging_object") or {};
+                        cost = float(slp.get("response_cost") or 0.0);
+                        if cost > 0 {
+                            record_cost(cost, _cid);
                         }
-                    } except Exception {
-                        _ = 0;
                     }
+                } except Exception {
+                    _ = 0;
+                } finally {
+                    try { _ct_mark_call_finished(_cid); } except Exception { ; }
                 }
             }
 
@@ -114,11 +160,13 @@ with entry {
                 start_time: object,
                 end_time: object
             ) {
-                _ = 0;
+                _cid = str(kwargs.get("litellm_call_id", "") or "");
+                try { _ct_mark_call_finished(_cid); } except Exception { ; }
             }
         }
 
-        litellm.callbacks.append(_CostLogger());
+        _cli_cost_logger = _CostLogger();
+        litellm.callbacks.append(_cli_cost_logger);
     } except Exception {
         _ = 0;
     }

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/core/nodes.impl.jac

@@ -152,7 +152,7 @@ Build responsive, mobile-first UIs: fluid flex/grid layouts, Tailwind responsive
 ## Workflow
 1. Read .jaccoder/progress.md if it exists, update it as you go.
 2. analyze_project(dir) for existing projects.
-3. Build bottom-up: services → hooks → components → layout.
+3. Minimal main.jac rendering first, then leaf-first: services → hooks → components, wiring each into the layout as it's built. Never import a file you haven't created yet.
 4. **If `components/ui/` exists AND jac.toml has `[jac-shadcn]` (jac-shadcn project):**
    - Load `jac-shadcn-components` skill BEFORE writing any UI.
    - Load `jac-cl-styling` for conditional class and cn() patterns.

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/infra/config.jac

@@ -1,6 +1,7 @@
 import os;
 import json;
 import threading;
+import from contextlib { suppress }
 import from pathlib { Path }
 import from dotenv { load_dotenv }
 import from byllm.lib { Model }
@@ -47,6 +48,33 @@ glob llm = SessionAwareModel(
     call_params={"max_tool_result_length": 20000}
 );
 
+"""Warn (once per model name) when the active model lacks vision support."""
+glob _vision_warned_models: set[str] = `set();
+
+def _warn_if_no_vision(model_name_to_check: str) -> None {
+    if not model_name_to_check or model_name_to_check in _vision_warned_models {
+        return;
+    }
+    _vision_warned_models.add(model_name_to_check);
+    with suppress(Exception) {
+        import litellm;
+        import sys;
+        # Only warn for models litellm knows about — unknown models are
+        # trusted (supports_vision returns False for unknowns too).
+        known = model_name_to_check in litellm.model_cost;
+        if known and not litellm.supports_vision(model_name_to_check) {
+            sys.stderr.write(
+                f"[jac-coder] Note: model '{model_name_to_check}' does not support vision. "
+                "Browser tools will return text only — the agent cannot verify "
+                "visual outcomes (theme colors, layout, rendering). For full "
+                "visual verification, use a vision-capable model "
+                "(e.g. gpt-5.x, claude-sonnet-4.x, gemini-2.x).\n"
+            );
+        }
+    }
+}
+
+
 """Set a thread-local model override. Fully concurrent — no locks, no global mutation."""
 def set_session_llm(model_name_override: str, api_key_override: str = "") {
     import logging;
@@ -55,6 +83,7 @@ def set_session_llm(model_name_override: str, api_key_override: str = "") {
     logging.getLogger("jac_coder.infra.config").info(
         f"Session LLM set: thread={threading.current_thread().name} model={model_name_override} has_key={bool(api_key_override)}"
     );
+    _warn_if_no_vision(model_name_override);
 }
 
 """Clear the thread-local model override."""
@@ -92,4 +121,8 @@ with entry {
         llm.call_params = {"max_tool_result_length": 3000};
     }
     llm.postinit();
+    # Surface a vision-capability warning at startup if the default
+    # model can't handle the image content blocks that browser tools
+    # now return.  Session-level overrides re-check via set_session_llm.
+    _warn_if_no_vision(model_name);
 }

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/runtime/cost_tracker.impl.jac

@@ -43,14 +43,20 @@ impl record_usage(usage_data: dict, agent: str = "main") -> None {
 }
 
 
-impl record_cost(cost: float) -> None {
-    # Accumulate USD cost from a litellm CustomLogger callback into the
-    # per-request ContextVar state. The ContextVar propagates across threads
-    # via litellm's `executor.submit(ctx.run, success_handler)`.
+impl record_cost(cost: float, call_id: str = "") -> None {
     if not _enabled {
         return;
     }
-    state = _request_state_cv.get();
+    state = None;
+    if call_id {
+        with _active_calls_lock {
+            _entry = _active_calls.get(call_id);
+            state = _entry[1] if _entry is not None else None;
+        }
+    }
+    if state is None {
+        state = _request_state_cv.get();
+    }
     if state is not None {
         with _lock {
             state["cost"] = float(state.get("cost", 0.0)) + float(cost);
@@ -93,7 +99,7 @@ impl reset_request_cost() -> None {
 }
 
 
-impl mark_call_started() -> None {
+impl mark_call_started(call_id: str = "") -> None {
     state = _request_state_cv.get();
     if state is None {
         return;
@@ -107,11 +113,38 @@ impl mark_call_started() -> None {
             ev.clear();
         }
     }
+    if call_id {
+        with _active_calls_lock {
+            # Prune stale entries when map is at capacity to bound memory.
+            if len(_active_calls) >= _ACTIVE_CALLS_MAX {
+                _now = time.monotonic();
+                _stale = [];
+                for (_k, _ent) in _active_calls.items() {
+                    if _now - _ent[0] > _ACTIVE_CALLS_TTL_SECONDS {
+                        _stale.append(_k);
+                    }
+                }
+                for _k in _stale {
+                    _active_calls.pop(_k, None);
+                }
+            }
+            _active_calls[call_id] = (time.monotonic(), state);
+        }
+    }
 }
 
 
-impl mark_call_finished() -> None {
-    state = _request_state_cv.get();
+impl mark_call_finished(call_id: str = "") -> None {
+    state = None;
+    if call_id {
+        with _active_calls_lock {
+            _entry = _active_calls.pop(call_id, None);
+            state = _entry[1] if _entry is not None else None;
+        }
+    }
+    if state is None {
+        state = _request_state_cv.get();
+    }
     if state is None {
         return;
     }

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/runtime/cost_tracker.jac

@@ -7,6 +7,7 @@ import os;
 import json;
 import threading;
 import contextvars;
+import time;
 
 glob _enabled: bool = os.environ.get("JACCODER_TRACK_COST", "") in ("1", "true", "yes");
 glob _lock = threading.Lock();
@@ -19,6 +20,13 @@ glob _request_state_cv: contextvars.ContextVar = contextvars.ContextVar(
     "jaccoder_request_state", default=None
 );
 
+# Each entry is (insert_timestamp: float, state: dict) so stale entries
+# can be reaped when the map approaches the size cap.
+glob _active_calls: dict = {};
+glob _active_calls_lock = threading.Lock();
+glob _ACTIVE_CALLS_MAX: int = 2048;
+glob _ACTIVE_CALLS_TTL_SECONDS: float = 300.0;
+
 
 def is_cost_tracking_enabled() -> bool {
     return _enabled;
@@ -35,11 +43,11 @@ def disable_cost_tracking() -> None {
 }
 
 def record_usage(usage_data: dict, agent: str = "main") -> None;
-def record_cost(cost: float) -> None;
+def record_cost(cost: float, call_id: str = "") -> None;
 def get_request_cost() -> float;
 def reset_request_cost() -> None;
-def mark_call_started() -> None;
-def mark_call_finished() -> None;
+def mark_call_started(call_id: str = "") -> None;
+def mark_call_finished(call_id: str = "") -> None;
 def wait_for_pending_costs(timeout: float = 2.0) -> bool;
 def save_to_file(filepath: str = "") -> str;
 def get_per_call_data() -> list;

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/runtime/file_logger.jac

@@ -198,7 +198,7 @@ def file_log_event(session_id: str, event_type: str, data: dict) -> None {
                 return;
             }
 
-            _log_file_handle.write(json.dumps(record) + "\n");
+            _log_file_handle.write(json.dumps(record, default=vars) + "\n");
 
         } except Exception as e {
             sys.stderr.write(f"[JacCoder] log write error: {e}\n");

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/runtime/prompt.jac

@@ -46,26 +46,26 @@ Use absolute paths. Load the `jac-scaffold` skill for the full template list and
 
 ## Iteration Budget
 You have limited iterations. Prioritize a WORKING app over a perfect one:
-- Build breadth-first: get ALL files written and the app running before polishing any single file.
+- Build breadth-first: get a working end-to-end skeleton rendering before polishing any single file.
 - If a component has errors after 2 fix attempts, write a minimal working version and move on.
 - Target: app starts and renders by iteration ~50. Remaining iterations for testing and fixes.
 - Never spend 10+ iterations debugging one file while the rest of the app is unbuilt.
 
 ## Build Workflow
 0. **Inspect the workspace** (per Step 0 above) — decide EXTEND vs CREATE before anything else.
-1. Load the relevant skills from `<jac-skills-available>` (fullstack + anything else the task touches) via `load_jac_skill(name)`.
+1. Load skills from `<jac-skills-available>` via `load_jac_skill(name)`: **always start with `jac-core-cheatsheet`**, then load the task-specific skills (fullstack + anything the task touches).
 2. Create or update `.jaccoder/progress.md` with the plan.
-3. Backend services (.sv.jac) + main.jac.
+3. Backend services (.sv.jac), then a minimal main.jac that renders a real layout (not a stub) — your live-preview shell; it grows as you wire in components.
 4. Tailwind v4 — jac.toml MUST have ALL four of these (missing any one breaks the build silently):
    [dependencies.npm.dev]: `tailwindcss = "latest"` and `"@tailwindcss/vite" = "latest"`
    [plugins.client.vite]: `plugins = ["tailwindcss()"]` AND `lib_imports = ["import tailwindcss from '@tailwindcss/vite'"]`
 5. CSS entry point `styles/global.css`: first line `@import "tailwindcss";`
    Import in main.jac using `cl import`: `cl import ".styles.global.css";`
    (Use `cl import`, NOT plain `import` — plain import causes E5001 if placed before `to cl:`)
-6. Frontend hooks + components (.cl.jac) with Tailwind.
+6. Frontend (.cl.jac) with Tailwind: build LEAF-FIRST — write each hook/component fully, THEN wire it into its parent. Never import a file that doesn't exist yet — it flashes "undefined component" in the live preview.
 7. Run `jac install`— after all jac.toml changes are final.
 8. `run_command("jac start --dev main.jac", background=True)`.
-9. browser_validate(url) → PASS/FAIL. Follow FAIL action instructions.
+9. browser_validate(url) → PASS/FAIL. Follow FAIL action instructions. Validate at milestones, not after every component.
 10. If PASS → one interactive test (browser_do + browser_state), then browser_close.
 11. Update progress.md Status: DONE.
 
@@ -88,19 +88,21 @@ Unstyled OR non-responsive app = bug.""";
 
 
 glob SEM_BROWSER_TESTING: str = """## Browser Testing
-Fix problems yourself — never stop to report them. Follow browser_validate's escalating ACTION instructions exactly:
-- 1st FAIL: read source, fix. 2nd: warning. 3rd+: mandatory bisect (skeleton → add components back).
-- Auth-gated blank page: tool auto-detects, follow its instructions.
-
-## After PASS
-PASS = page renders, NOT that it works. You must:
-1. Screenshot to confirm UI looks correct.
-2. Check the layout at a narrow / mobile width — no horizontal scroll, overlapping elements, or cut-off content. Fix responsive issues before declaring done.
-3. Test the primary feature (one action + verify state changed via screenshot).
-4. If action fails → code bug. Fix, restart, retest. Never retry same action twice.
-5. After 2 failed interactive tests → close browser, report status, move on.
-
-SKELETON/PLACEHOLDER PASS is not done — restore all components.""";
+Browser tools return observations — snapshot, annotated screenshot, JS errors, console errors, optional server-log diagnosis. They do not judge PASS/FAIL. You decide by looking at the screenshot.
+
+## Visual verification is the contract
+After ANY edit that affects rendering (CSS, classNames, layout, component structure), the very next validate MUST confirm your change is visible in the screenshot. A successful file write means nothing if the pixels don't reflect it. Never scrape CSS or curl the page — the screenshot is ground truth.
+
+## When the screenshot shows something wrong
+- Blank or near-blank page → likely auth-gated or routing issue; try the app's known entry path before declaring failure.
+- Placeholder / unfinished UI → not done; restore the real content.
+- JS or console error names a file → read it, fix it, re-validate.
+- 5xx with server-log diagnosis → the diagnosis names the compile error or missing dep; act on it.
+
+## Anti-loop
+3 validates on the same URL without convergence → stop. Reduce the page to a known-good shell, add pieces back one at a time, validate after each. The first addition that breaks is the bug.
+
+Never retry the same failing browser action twice.""";
 
 
 glob SEM_PROGRESS_TEMPLATE: str = """## Progress Tracking

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/server.jac

@@ -541,9 +541,26 @@ with entry {
         try {
             import litellm;
             import from litellm.integrations.custom_logger { CustomLogger as _CL }
-            import from jac_coder.runtime.cost_tracker { record_cost }
+            import from jac_coder.runtime.cost_tracker {
+                record_cost,
+                mark_call_started as _ct_mark_call_started,
+                mark_call_finished as _ct_mark_call_finished
+            }
 
             class _CostLogger(_CL) {
+                def log_pre_api_call(
+                    self: _CostLogger,
+                    model: object,
+                    messages: object,
+                    kwargs: dict
+                ) {
+                    try {
+                        _cid = str(kwargs.get("litellm_call_id", "") or "");
+                        _ct_mark_call_started(_cid);
+                    } except Exception {
+                        _ = 0;
+                    }
+                }
                 def log_success_event(
                     self: _CostLogger,
                     kwargs: dict,
@@ -551,15 +568,18 @@ with entry {
                     start_time: object,
                     end_time: object
                 ) {
+                    _cid = str(kwargs.get("litellm_call_id", "") or "");
                     try {
                         slp = kwargs.get("standard_logging_object") or {};
                         raw = slp.get("response_cost") or 0;
                         cost = float(str(raw));
                         if cost > 0 {
-                            record_cost(cost);
+                            record_cost(cost, _cid);
                         }
                     } except Exception {
                         _ = 0;
+                    } finally {
+                        try { _ct_mark_call_finished(_cid); } except Exception { ; }
                     }
                 }
 
@@ -570,7 +590,8 @@ with entry {
                     start_time: object,
                     end_time: object
                 ) {
-                    _ = 0;
+                    _cid = str(kwargs.get("litellm_call_id", "") or "");
+                    try { _ct_mark_call_finished(_cid); } except Exception { ; }
                 }
             }
 

{jac_coder-0.2.5 → jac_coder-0.2.6}/jac_coder/tool/meta/clarify_intent.impl.jac

@@ -34,7 +34,7 @@ impl clarify_intent(
             "allow_custom": allow_custom,
             "skippable": skippable
         });
-        result = str(_await_clarification(session_id, options_payload));
+        result = str(_await_clarification(session_id, request_id, options_payload));
     } else {
         # 3. CLI branch — colored numbered menu
         print(f"\n{YELLOW}[Clarification]{RESET} {question}\n");