td-ai-tools 1.0.2 → 1.0.4

package/skills/everhour-basecamp-estimates/scripts/update_estimates.py

@@ -27,6 +27,7 @@ WHITESPACE_RE = re.compile(r"\s+")
 class TodoItem:
     id: str
     title: str
+    api_url: str | None = None
 
 
 @dataclass(frozen=True)
@@ -200,6 +201,13 @@ def extract_title(record: dict[str, Any]) -> str:
     raise ScriptError(f"Could not determine a title from Basecamp payload: {record}")
 
 
+def extract_api_url(record: dict[str, Any]) -> str | None:
+    value = record.get("url")
+    if isinstance(value, str) and value.strip():
+        return value.strip()
+    return None
+
+
 def extract_todo_objects(payload: Any) -> list[dict[str, Any]]:
     if isinstance(payload, list):
         candidates = [item for item in payload if is_todo_like(item)]
@@ -258,17 +266,46 @@ def is_todo_completed(record: dict[str, Any]) -> bool:
 def load_basecamp_todos(basecamp_bin: str, basecamp_url: str) -> TodoSelection:
     parsed = run_basecamp_json(basecamp_bin, "url", "parse", basecamp_url)
     resource_type = str(parsed.get("type", "")).strip().lower()
+    project_id = str(parsed.get("project_id", "")).strip()
+    recording_id = str(parsed.get("recording_id", "")).strip()
 
     if resource_type in {"todo", "todos"}:
         payload = run_basecamp_json(basecamp_bin, "todos", "show", basecamp_url)
-        todo = TodoItem(id=str(payload["id"]), title=extract_title(payload))
+        todo = TodoItem(
+            id=str(payload["id"]),
+            title=extract_title(payload),
+            api_url=extract_api_url(payload),
+        )
         if is_todo_completed(payload):
             return TodoSelection(active=[], skipped_completed=[todo])
         return TodoSelection(active=[todo], skipped_completed=[])
 
     if resource_type in {"todolist", "todolists"}:
-        payload = run_basecamp_json(basecamp_bin, "todolists", "show", basecamp_url)
-        todo_objects = extract_todo_objects(payload)
+        payload: Any = None
+        todo_objects: list[dict[str, Any]] = []
+        try:
+            payload = run_basecamp_json(basecamp_bin, "todolists", "show", basecamp_url)
+        except ScriptError:
+            payload = None
+
+        if payload is not None:
+            todo_objects = extract_todo_objects(payload)
+
+        # Some Basecamp CLI versions return an empty payload for todolists show even
+        # though the list exists. Fall back to listing todos scoped to the parsed
+        # project and todolist IDs.
+        if not todo_objects and project_id and recording_id:
+            fallback_payload = run_basecamp_json(
+                basecamp_bin,
+                "todos",
+                "list",
+                "--in",
+                project_id,
+                "--todolist",
+                recording_id,
+            )
+            todo_objects = extract_todo_objects(fallback_payload)
+
         if not todo_objects:
             raise ScriptError(
                 "The Basecamp todolist payload did not include any todo items. "
@@ -277,7 +314,11 @@ def load_basecamp_todos(basecamp_bin: str, basecamp_url: str) -> TodoSelection:
         active: list[TodoItem] = []
         skipped_completed: list[TodoItem] = []
         for item in todo_objects:
-            todo = TodoItem(id=str(item["id"]), title=extract_title(item))
+            todo = TodoItem(
+                id=str(item["id"]),
+                title=extract_title(item),
+                api_url=extract_api_url(item),
+            )
             if is_todo_completed(item):
                 skipped_completed.append(todo)
             else:
@@ -370,14 +411,12 @@ class EverhourClient:
             raise ScriptError("Everhour task search response was not a list.")
         return [task for task in tasks if isinstance(task, dict)]
 
-    def match_task(self, title: str) -> dict[str, Any]:
+    def match_task(self, title: str, source_id: str) -> dict[str, Any]:
         normalized = normalize_title(title)
         open_matches = self.list_open_tasks().get(normalized, [])
-        if len(open_matches) == 1:
-            return open_matches[0]
-        if len(open_matches) > 1:
-            matches = ", ".join(str(task.get("id")) for task in open_matches)
-            raise ScriptError(f"Ambiguous Everhour matches for '{title}': {matches}")
+        open_match = select_single_task_match(title, open_matches, source_id)
+        if open_match is not None:
+            return open_match
 
         search_matches = [
             task
@@ -385,13 +424,12 @@ class EverhourClient:
             if normalize_title(str(task.get("name", ""))) == normalized
         ]
         if not search_matches:
-            raise ScriptError(
-                f"No Everhour task match found for Basecamp title '{title}' in project {self.project_id}."
-            )
-        if len(search_matches) > 1:
-            matches = ", ".join(str(task.get("id")) for task in search_matches)
-            raise ScriptError(f"Ambiguous Everhour matches for '{title}': {matches}")
-        return search_matches[0]
+            raise ScriptError(format_missing_match_error(title, self.project_id))
+        search_match = select_single_task_match(title, search_matches, source_id)
+        if search_match is not None:
+            return search_match
+
+        raise ScriptError(format_ambiguous_match_error(title, search_matches, source_id))
 
     def update_task_estimate(self, task_id: str, total_seconds: int) -> None:
         self._request(
@@ -401,8 +439,106 @@ class EverhourClient:
         )
 
 
-def update_basecamp_title(basecamp_bin: str, todo_id: str, title: str) -> None:
-    run_basecamp_json(basecamp_bin, "todos", "update", todo_id, "--title", title)
+def task_matches_source_id(task: dict[str, Any], source_id: str) -> bool:
+    normalized_source_id = str(source_id).strip()
+    if not normalized_source_id:
+        return False
+
+    task_id = str(task.get("id", "")).strip()
+    if task_id == normalized_source_id or task_id.endswith(f":{normalized_source_id}"):
+        return True
+
+    url = str(task.get("url", "")).strip().rstrip("/")
+    return bool(url) and url.endswith(f"/{normalized_source_id}")
+
+
+def select_single_task_match(
+    title: str,
+    tasks: list[dict[str, Any]],
+    source_id: str,
+) -> dict[str, Any] | None:
+    if len(tasks) == 1:
+        return tasks[0]
+    if len(tasks) == 0:
+        return None
+
+    source_matches = [task for task in tasks if task_matches_source_id(task, source_id)]
+    if len(source_matches) == 1:
+        return source_matches[0]
+    if len(source_matches) > 1:
+        raise ScriptError(format_ambiguous_match_error(title, source_matches, source_id))
+    return None
+
+
+def format_ambiguous_match_error(
+    title: str,
+    matches: list[dict[str, Any]],
+    source_id: str,
+) -> str:
+    match_ids = ", ".join(str(task.get("id")) for task in matches)
+    return (
+        f"Ambiguous Everhour matches for '{title}': {match_ids}. "
+        f"None could be uniquely matched to Basecamp todo {source_id}."
+    )
+
+
+def format_missing_match_error(title: str, project_id: str) -> str:
+    return f"No Everhour task match found for Basecamp title '{title}' in project {project_id}."
+
+
+def update_basecamp_title(basecamp_bin: str, todo: TodoItem, title: str) -> None:
+    if not todo.api_url:
+        raise ScriptError(f"Basecamp todo {todo.id} payload did not include an API URL.")
+    current = run_basecamp_json(basecamp_bin, "api", "get", todo.api_url)
+    if not isinstance(current, dict):
+        raise ScriptError(
+            f"Basecamp todo {todo.id} GET did not return a JSON object: {current!r}"
+        )
+    payload = build_basecamp_update_payload(current, title)
+    run_basecamp_json(
+        basecamp_bin,
+        "api",
+        "put",
+        todo.api_url,
+        "-d",
+        json.dumps(payload),
+    )
+
+
+def build_basecamp_update_payload(current: dict[str, Any], title: str) -> dict[str, Any]:
+    # Basecamp's PUT to a todo replaces all writable fields, so any field omitted
+    # here gets cleared. Carry over the assignees, completion subscribers, notes
+    # (description), and dates from the current record so we only change `content`.
+    payload: dict[str, Any] = {"content": title}
+
+    description = current.get("description")
+    if isinstance(description, str) and description:
+        payload["description"] = description
+
+    assignee_ids = _extract_person_ids(current.get("assignees"))
+    if assignee_ids:
+        payload["assignee_ids"] = assignee_ids
+
+    subscriber_ids = _extract_person_ids(current.get("completion_subscribers"))
+    if subscriber_ids:
+        payload["completion_subscriber_ids"] = subscriber_ids
+
+    for key in ("due_on", "starts_on"):
+        value = current.get(key)
+        if isinstance(value, str) and value:
+            payload[key] = value
+
+    return payload
+
+
+def _extract_person_ids(people: Any) -> list[Any]:
+    if not isinstance(people, list):
+        return []
+    ids: list[Any] = []
+    for person in people:
+        if isinstance(person, dict) and "id" in person:
+            ids.append(person["id"])
+    return ids
 
 
 def build_plan(
@@ -430,7 +566,7 @@ def build_plan(
             )
         seen_titles[normalized_title] = todo
 
-        task = everhour.match_task(todo.title)
+        task = everhour.match_task(todo.title, source_id=todo.id)
         task_id = str(task.get("id", "")).strip()
         task_name = str(task.get("name", "")).strip()
         if not task_id or not task_name:
@@ -504,7 +640,7 @@ def main() -> int:
         everhour.update_task_estimate(plan.everhour_task_id, plan.seconds)
 
     for plan in plans:
-        update_basecamp_title(args.basecamp_bin, plan.todo.id, plan.new_basecamp_title)
+        update_basecamp_title(args.basecamp_bin, plan.todo, plan.new_basecamp_title)
 
     print("Completed Everhour estimate updates and Basecamp title updates.")
     return 0

package/skills/everhour-basecamp-estimates/tests/test_update_estimates.py

@@ -1,4 +1,5 @@
 import importlib.util
+import json
 import sys
 import unittest
 from decimal import Decimal
@@ -65,7 +66,7 @@ class BuildPlanTest(unittest.TestCase):
             MODULE.build_plan(todos, estimates, everhour)
 
         self.assertIn("duplicates todo 1", str(caught.exception))
-        everhour.match_task.assert_called_once_with("Ship estimate")
+        everhour.match_task.assert_called_once_with("Ship estimate", source_id="1")
 
     def test_rejects_duplicate_everhour_task_matches(self) -> None:
         todos = [
@@ -88,6 +89,198 @@ class BuildPlanTest(unittest.TestCase):
         self.assertIn("todo 1 and todo 2", str(caught.exception))
         self.assertEqual(everhour.match_task.call_count, 2)
 
+    def test_passes_basecamp_todo_id_to_everhour_matcher(self) -> None:
+        todos = [MODULE.TodoItem(id="1", title="Ship estimate")]
+        estimates = [(Decimal("1"), 3600)]
+        everhour = mock.Mock()
+        everhour.match_task.return_value = {
+            "id": "abc123",
+            "name": "Ship estimate",
+        }
+
+        plans = MODULE.build_plan(todos, estimates, everhour)
+
+        everhour.match_task.assert_called_once_with("Ship estimate", source_id="1")
+        self.assertEqual(plans[0].everhour_task_id, "abc123")
+
+
+class EverhourClientMatchTaskTest(unittest.TestCase):
+    def test_duplicate_open_matches_are_resolved_by_basecamp_todo_id(self) -> None:
+        client = MODULE.EverhourClient(api_key="key", project_id="project")
+        client.list_open_tasks = mock.Mock(
+            return_value={
+                "ship estimate": [
+                    {"id": "b3:1", "name": "Ship estimate"},
+                    {"id": "b3:2", "name": "Ship estimate"},
+                ],
+            }
+        )
+        client.search_tasks = mock.Mock(return_value=[])
+
+        task = client.match_task("Ship estimate", source_id="2")
+
+        self.assertEqual(task["id"], "b3:2")
+        client.search_tasks.assert_not_called()
+
+    def test_duplicate_open_matches_still_fail_without_todo_id_match(self) -> None:
+        client = MODULE.EverhourClient(api_key="key", project_id="project")
+        client.list_open_tasks = mock.Mock(
+            return_value={
+                "ship estimate": [
+                    {"id": "b3:1", "name": "Ship estimate"},
+                    {"id": "b3:2", "name": "Ship estimate"},
+                ],
+            }
+        )
+        client.search_tasks = mock.Mock(
+            return_value=[
+                {"id": "b3:1", "name": "Ship estimate"},
+                {"id": "b3:2", "name": "Ship estimate"},
+            ]
+        )
+
+        with self.assertRaises(MODULE.ScriptError) as caught:
+            client.match_task("Ship estimate", source_id="3")
+
+        self.assertIn("Basecamp todo 3", str(caught.exception))
+
+    def test_duplicate_search_matches_are_resolved_by_basecamp_todo_id(self) -> None:
+        client = MODULE.EverhourClient(api_key="key", project_id="project")
+        client.list_open_tasks = mock.Mock(return_value={})
+        client.search_tasks = mock.Mock(
+            return_value=[
+                {"id": "b3:1", "name": "Ship estimate"},
+                {"id": "b3:2", "name": "Ship estimate"},
+            ]
+        )
+
+        task = client.match_task("Ship estimate", source_id="2")
+
+        self.assertEqual(task["id"], "b3:2")
+        client.search_tasks.assert_called_once_with("Ship estimate")
+
+    def test_basecamp_todo_id_can_match_task_url(self) -> None:
+        task = {
+            "id": "opaque",
+            "name": "Ship estimate",
+            "url": "https://3.basecamp.com/1/buckets/2/todos/123",
+        }
+
+        self.assertTrue(MODULE.task_matches_source_id(task, "123"))
+
+
+class UpdateBasecampTitleTest(unittest.TestCase):
+    def test_fetches_current_todo_then_puts_with_only_changed_content(self) -> None:
+        todo = MODULE.TodoItem(
+            id="123",
+            title="Ship estimate",
+            api_url="https://3.basecampapi.com/1/buckets/2/todos/123.json",
+        )
+        current_payload = {
+            "id": 123,
+            "content": "Ship estimate",
+            "description": "<div>Original notes with image</div>",
+            "assignees": [{"id": 7}, {"id": 8}],
+            "completion_subscribers": [{"id": 9}],
+            "due_on": "2026-05-01",
+            "starts_on": None,
+        }
+
+        with mock.patch.object(MODULE, "run_basecamp_json") as run_basecamp_json:
+            run_basecamp_json.side_effect = [current_payload, {}]
+            MODULE.update_basecamp_title("basecamp", todo, "Ship estimate [2h]")
+
+        self.assertEqual(run_basecamp_json.call_count, 2)
+        get_call, put_call = run_basecamp_json.call_args_list
+
+        self.assertEqual(
+            get_call.args,
+            (
+                "basecamp",
+                "api",
+                "get",
+                "https://3.basecampapi.com/1/buckets/2/todos/123.json",
+            ),
+        )
+
+        self.assertEqual(put_call.args[:5], (
+            "basecamp",
+            "api",
+            "put",
+            "https://3.basecampapi.com/1/buckets/2/todos/123.json",
+            "-d",
+        ))
+        body = json.loads(put_call.args[5])
+        self.assertEqual(body["content"], "Ship estimate [2h]")
+        self.assertEqual(body["description"], "<div>Original notes with image</div>")
+        self.assertEqual(body["assignee_ids"], [7, 8])
+        self.assertEqual(body["completion_subscriber_ids"], [9])
+        self.assertEqual(body["due_on"], "2026-05-01")
+        self.assertNotIn("starts_on", body)
+
+    def test_omits_fields_absent_from_current_todo(self) -> None:
+        todo = MODULE.TodoItem(
+            id="123",
+            title="Ship estimate",
+            api_url="https://3.basecampapi.com/1/buckets/2/todos/123.json",
+        )
+        current_payload = {
+            "id": 123,
+            "content": "Ship estimate",
+            "description": "",
+            "assignees": [],
+            "completion_subscribers": [],
+            "due_on": None,
+            "starts_on": None,
+        }
+
+        with mock.patch.object(MODULE, "run_basecamp_json") as run_basecamp_json:
+            run_basecamp_json.side_effect = [current_payload, {}]
+            MODULE.update_basecamp_title("basecamp", todo, "Ship estimate [2h]")
+
+        put_call = run_basecamp_json.call_args_list[1]
+        body = json.loads(put_call.args[5])
+        self.assertEqual(body, {"content": "Ship estimate [2h]"})
+
+    def test_rejects_missing_basecamp_api_url(self) -> None:
+        todo = MODULE.TodoItem(id="123", title="Ship estimate")
+
+        with self.assertRaises(MODULE.ScriptError) as caught:
+            MODULE.update_basecamp_title("basecamp", todo, "Ship estimate [2h]")
+
+        self.assertIn("did not include an API URL", str(caught.exception))
+
+
+class BuildBasecampUpdatePayloadTest(unittest.TestCase):
+    def test_extracts_assignee_and_subscriber_ids_and_preserves_dates(self) -> None:
+        current = {
+            "content": "Old",
+            "description": "<p>note</p>",
+            "assignees": [{"id": 1}, {"id": 2}],
+            "completion_subscribers": [{"id": 3}],
+            "due_on": "2026-05-01",
+            "starts_on": "2026-04-01",
+        }
+
+        payload = MODULE.build_basecamp_update_payload(current, "New title")
+
+        self.assertEqual(
+            payload,
+            {
+                "content": "New title",
+                "description": "<p>note</p>",
+                "assignee_ids": [1, 2],
+                "completion_subscriber_ids": [3],
+                "due_on": "2026-05-01",
+                "starts_on": "2026-04-01",
+            },
+        )
+
+    def test_skips_empty_or_missing_fields(self) -> None:
+        payload = MODULE.build_basecamp_update_payload({"content": "Old"}, "New title")
+
+        self.assertEqual(payload, {"content": "New title"})
+
 
 if __name__ == "__main__":
     unittest.main()

package/skills/playwright-cli/CODEX-CONFIG.md

@@ -0,0 +1,79 @@
+# Codex sandbox config bootstrap
+
+This directory contains a template + generator that produces `<repo>/.codex/config.toml`
+on demand, so the file does not need to be committed with hardcoded paths tied to one
+machine or one project clone location.
+
+## Files
+
+- `config.toml.template` — the source of truth. Uses two placeholders:
+  - `__PROJECT_ROOT__` — replaced with the absolute path to the repo root
+  - `__CHROME_PATH__` — replaced with the absolute path to the Chrome/Chromium binary
+- `setup-codex.sh` — reads the template, substitutes the placeholders, writes
+  `<repo>/.codex/config.toml`.
+
+The generated `.codex/` directory is gitignored, so each clone gets its own copy.
+
+## Usage
+
+Run once after cloning the repo (or after moving the clone to a new path):
+
+```bash
+.agents/skills/playwright-cli/setup-codex.sh
+```
+
+The script prints the values it resolved, e.g.:
+
+```
+wrote /home/you/code/lio/.codex/config.toml
+  PROJECT_ROOT=/home/you/code/lio
+  CHROME_PATH=/usr/bin/google-chrome
+```
+
+Re-run it any time the template changes or you move the repo.
+
+## How paths are resolved
+
+**`PROJECT_ROOT`** — derived in this order:
+
+1. `git rev-parse --show-toplevel` from the script's directory (works for any clone
+   location, on any machine, regardless of username)
+2. Falls back to walking three directories up from the script
+   (`.agents/skills/playwright-cli` → repo root) if the repo isn't a git checkout
+
+**`CHROME_PATH`** — derived in this order:
+
+1. The `CHROME_PATH` environment variable, if set
+2. First match from `PATH` of: `google-chrome`, `google-chrome-stable`, `chromium`,
+   `chromium-browser`
+3. Falls back to `/usr/bin/google-chrome` with a warning if nothing is found
+
+Override the Chrome binary explicitly when needed:
+
+```bash
+CHROME_PATH=/opt/google/chrome/chrome .agents/skills/playwright-cli/setup-codex.sh
+```
+
+## Why a generator instead of variable expansion
+
+Codex CLI parses `config.toml` as static TOML and does not expand `~`, `$HOME`, or
+`${VAR}` in path values — they would be treated as literal strings. Generating the
+file at setup time is the simplest way to keep the template portable while still
+producing the absolute paths Codex expects at runtime.
+
+## What the generated config does
+
+The output `.codex/config.toml` configures Codex's sandbox so Playwright can run
+inside it:
+
+- `sandbox_workspace_write.writable_roots` — directories Playwright is allowed to
+  write to (browser cache, artifacts, test reports, daemon sockets)
+- `shell_environment_policy.set` — pins `PLAYWRIGHT_*`, `XDG_*`, and `TMPDIR`-family
+  env vars to repo-local paths so Playwright stores its browser, cache, and runtime
+  state under the project rather than the user's home directory
+
+## Editing
+
+Edit `config.toml.template` (not the generated file) and re-run `setup-codex.sh`.
+Changes to `.codex/config.toml` directly will be overwritten the next time the
+generator runs.