codee-agent 0.1.0__py3-none-any.whl

codee/lib/test_trigger_issue_skills.py

@@ -0,0 +1,93 @@
+import tempfile
+import unittest
+from pathlib import Path
+
+from codee.lib.trigger_issue_skills import (
+    find_issue_triggered_skills,
+    issue_statuses,
+    match_issue_skill,
+)
+
+
+class IssueTriggeredSkillsTest(unittest.TestCase):
+    def _skill(self, root: Path, slug: str, frontmatter: str) -> None:
+        directory = root / slug
+        directory.mkdir()
+        (directory / "SKILL.md").write_text(f"---\n{frontmatter}---\nBody\n")
+
+    def test_reads_the_model_frontmatter_when_present(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            self._skill(
+                root, "with-model",
+                "name: With model\ndisable-model-invocation: true\n"
+                "x-codee-trigger: issue\nx-codee-issue-status: [Ready]\n"
+                "x-codee-issue-type: story\nmodel: claude-opus-5\n",
+            )
+            self._skill(
+                root, "without-model",
+                "name: Without model\ndisable-model-invocation: true\n"
+                "x-codee-trigger: issue\nx-codee-issue-status: [Ready]\n"
+                "x-codee-issue-type: task\n",
+            )
+
+            models = {skill.slug: skill.model
+                      for skill in find_issue_triggered_skills(root)}
+
+            self.assertEqual(models,
+                             {"with-model": "claude-opus-5", "without-model": ""})
+
+    def test_loads_valid_issue_type_and_rejects_invalid_skills(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            self._skill(
+                root,
+                "valid",
+                "name: Valid\ndisable-model-invocation: true\n"
+                "x-codee-trigger: issue\n"
+                "x-codee-issue-status: [Ready, Custom status]\n"
+                "x-codee-issue-type: story\n",
+            )
+            self._skill(
+                root,
+                "invalid",
+                "name: Invalid\nx-codee-trigger: issue\n"
+                "x-codee-issue-status: [Ready]\n",
+            )
+            self._skill(
+                root,
+                "invalid-type",
+                "name: Invalid type\ndisable-model-invocation: true\n"
+                "x-codee-trigger: issue\nx-codee-issue-status: [Ready]\n"
+                "x-codee-issue-type: bug\n",
+            )
+
+            skills = find_issue_triggered_skills(root)
+
+            self.assertEqual([skill.slug for skill in skills], ["valid"])
+            self.assertEqual(issue_statuses(skills), [
+                             "Ready", "Custom status"])
+            self.assertEqual(match_issue_skill(
+                skills, "custom STATUS", "Story").slug, "valid")
+
+    def test_matches_only_the_requested_issue_type(self) -> None:
+        with tempfile.TemporaryDirectory() as temporary_directory:
+            root = Path(temporary_directory)
+            common = (
+                "disable-model-invocation: true\nx-codee-trigger: issue\n"
+                "x-codee-issue-status: ['In Progress']\n"
+            )
+            self._skill(root, "story", f"{common}x-codee-issue-type: story\n")
+            self._skill(root, "task", f"{common}x-codee-issue-type: task\n")
+            skills = find_issue_triggered_skills(root)
+
+            self.assertEqual(match_issue_skill(
+                skills, "in progress", "Story").slug, "story")
+            self.assertEqual(match_issue_skill(
+                skills, "in progress", "Task").slug, "task")
+            self.assertIsNone(match_issue_skill(
+                skills, "in progress", "Bug"))
+
+
+if __name__ == "__main__":
+    unittest.main()

codee/lib/trigger_aws_sqs_skills.py

@@ -0,0 +1,224 @@
+import uuid
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable, Protocol
+
+from codee_main_context.context import CodeeMainContext
+
+from codee.lib import runs_db
+from codee_main_context.context import project_root, skills_dir as default_skills_dir
+
+REPO_ROOT = project_root()
+SKILLS_DIR = default_skills_dir(REPO_ROOT)
+
+RunClaude = Callable[[str, str, str], str]
+
+
+@dataclass(frozen=True)
+class AwsSqsTriggeredSkill:
+    key: str
+    name: str
+    path: Path
+    queue: str
+    body: str
+    model: str
+
+
+@dataclass(frozen=True)
+class AwsSqsMessage:
+    content: str
+    queue_url: str
+    receipt_handle: str
+
+
+class AwsSqsMessageSource(Protocol):
+    def receive(self, skill: AwsSqsTriggeredSkill) -> AwsSqsMessage | None:
+        pass
+
+    def delete(self, message: AwsSqsMessage) -> None:
+        pass
+
+
+def trigger_aws_sqs_skills(
+    run_claude: RunClaude,
+    *,
+    skills_dir: Path = SKILLS_DIR,
+    sqs_message_source: AwsSqsMessageSource | None = None,
+    main_context: CodeeMainContext
+) -> None:
+    """Scan skills with AWS SQS trigger frontmatter and run one message per skill."""
+    skills = find_aws_sqs_triggered_skills(skills_dir)
+    if not skills:
+        print("[aws_sqs_skills] No AWS SQS-triggered skills found.")
+        return
+
+    if sqs_message_source is None:
+        sqs_message_source = Boto3AwsSqsMessageSource()
+
+    for skill in skills:
+        try:
+            message = sqs_message_source.receive(skill)
+        except Exception as exc:
+            print(
+                f"[aws_sqs_skills] Failed to poll SQS trigger for {skill.name}: {exc}")
+            continue
+
+        if message is None:
+            continue
+
+        print(
+            f"[aws_sqs_skills] Running {skill.name} from SQS queue {skill.queue}")
+        session_id = str(uuid.uuid4())
+        prompt = render_aws_sqs_prompt(skill.body, message.content)
+        try:
+            response = run_claude(prompt, session_id, skill.model)
+            print(
+                f"[aws_sqs_skills] Claude response for {skill.name} ({len(response)} chars)")
+            sqs_message_source.delete(message)
+            runs_db.record_run(skill.name, "aws-sqs",
+                               session_id, "succeeded", message=prompt,
+                               main_context=main_context)
+        except Exception as exc:
+            print(f"[aws_sqs_skills] Failed to run {skill.name}: {exc}")
+            runs_db.record_run(skill.name, "aws-sqs", session_id, "failed",
+                               error=str(exc)[:500], message=prompt,
+                               main_context=main_context)
+
+
+def find_aws_sqs_triggered_skills(skills_dir: Path = SKILLS_DIR) -> list[AwsSqsTriggeredSkill]:
+    skills: list[AwsSqsTriggeredSkill] = []
+    for path in sorted(skills_dir.glob("*/SKILL.md")):
+        try:
+            metadata, body = _parse_skill_file(path.read_text())
+        except OSError as exc:
+            print(f"[aws_sqs_skills] Failed to read {path}: {exc}")
+            continue
+
+        trigger = metadata.get("x-codee-trigger", "").strip().lower()
+        if not trigger:
+            continue
+
+        name = metadata.get(
+            "name", path.parent.name).strip() or path.parent.name
+        if metadata.get("disable-model-invocation", "").strip().lower() != "true":
+            print(
+                f"[aws_sqs_skills] ERROR: {path} declares x-codee-trigger but is missing "
+                "disable-model-invocation: true; skipping."
+            )
+            continue
+
+        if trigger != "aws-sqs":
+            continue
+
+        queue = metadata.get("x-codee-aws-sqs-queue", "").strip()
+        if not queue:
+            print(
+                f"[aws_sqs_skills] ERROR: {path} declares x-codee-trigger: aws-sqs but is missing "
+                "x-codee-aws-sqs-queue; skipping."
+            )
+            continue
+
+        skills.append(
+            AwsSqsTriggeredSkill(
+                key=_skill_key(path),
+                name=name,
+                path=path,
+                queue=queue,
+                body=body.strip(),
+                model=metadata.get("model", "").strip(),
+            )
+        )
+    return skills
+
+
+class Boto3AwsSqsMessageSource:
+    def __init__(self, *, visibility_timeout: int = 7200) -> None:
+        import boto3
+
+        self._sqs = boto3.client("sqs")
+        self._visibility_timeout = visibility_timeout
+        self._queue_urls_by_skill: dict[str, str] = {}
+
+    def receive(self, skill: AwsSqsTriggeredSkill) -> AwsSqsMessage | None:
+        queue_url = self._resolve_queue_url(skill)
+        print("Receiving from SQS queue:", queue_url)
+        response = self._sqs.receive_message(
+            QueueUrl=queue_url,
+            MaxNumberOfMessages=1,
+            WaitTimeSeconds=0,
+            VisibilityTimeout=self._visibility_timeout,
+            AttributeNames=["All"],
+            MessageAttributeNames=["All"],
+        )
+        messages = response.get("Messages", [])
+        if not messages:
+            return None
+
+        raw_message = messages[0]
+        return AwsSqsMessage(
+            content=raw_message.get("Body", ""),
+            queue_url=queue_url,
+            receipt_handle=raw_message["ReceiptHandle"],
+        )
+
+    def delete(self, message: AwsSqsMessage) -> None:
+        self._sqs.delete_message(
+            QueueUrl=message.queue_url, ReceiptHandle=message.receipt_handle)
+
+    def _resolve_queue_url(self, skill: AwsSqsTriggeredSkill) -> str:
+        if skill.key in self._queue_urls_by_skill:
+            return self._queue_urls_by_skill[skill.key]
+
+        if skill.queue.startswith("http://") or skill.queue.startswith("https://"):
+            queue_url = skill.queue
+        else:
+            queue_url = self._sqs.get_queue_url(
+                QueueName=skill.queue)["QueueUrl"]
+
+        self._queue_urls_by_skill[skill.key] = queue_url
+        return queue_url
+
+
+def render_aws_sqs_prompt(body: str, content: str) -> str:
+    if "{CONTENT}" in body:
+        return body.replace("{CONTENT}", content)
+    return f"{body.rstrip()}\n\n{content}"
+
+
+def _parse_skill_file(contents: str) -> tuple[dict[str, str], str]:
+    lines = contents.splitlines()
+    if not lines or lines[0].strip() != "---":
+        return {}, contents
+
+    end_index = None
+    for index, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            end_index = index
+            break
+
+    if end_index is None:
+        return {}, contents
+
+    metadata: dict[str, str] = {}
+    for line in lines[1:end_index]:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or ":" not in stripped:
+            continue
+        key, _, value = stripped.partition(":")
+        metadata[key.strip().lower()] = _strip_quotes(value.strip())
+
+    body = "\n".join(lines[end_index + 1:]).lstrip("\n")
+    return metadata, body
+
+
+def _skill_key(path: Path) -> str:
+    try:
+        return str(path.relative_to(REPO_ROOT))
+    except ValueError:
+        return str(path)
+
+
+def _strip_quotes(value: str) -> str:
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
+        return value[1:-1]
+    return value

codee/lib/trigger_cron_skills.py

@@ -0,0 +1,364 @@
+import json
+import uuid
+from dataclasses import dataclass
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Callable
+
+from codee_main_context.context import CodeeMainContext
+
+from codee.lib import runs_db
+from codee_main_context.context import project_root, skills_dir as default_skills_dir
+
+REPO_ROOT = project_root()
+SKILLS_DIR = default_skills_dir(REPO_ROOT)
+
+# How far back to look for a missed scheduled fire. A tick can be delayed for
+# hours because a single run_once may block on long-running Claude jobs (each up
+# to 2h). Without catch-up the exact cron minute is skipped and the job waits a
+# whole period (e.g. a week for "0 0 * * 1"). 24h covers realistic backlogs
+# while still refusing to run occurrences that are absurdly stale.
+DEFAULT_CATCHUP = timedelta(hours=24)
+
+
+# (prompt, session_id, model) -> agent reply. `model` is the skill's `model:`
+# frontmatter, empty when it declares none.
+RunClaude = Callable[[str, str, str], str]
+
+
+@dataclass(frozen=True)
+class CronField:
+    values: set[int]
+    is_wildcard: bool
+
+
+@dataclass(frozen=True)
+class ScheduledSkill:
+    key: str
+    name: str
+    path: Path
+    cron: str
+    body: str
+    model: str
+
+
+def _get_force_file_path(main_context: CodeeMainContext) -> Path:
+    return main_context.data_dir / "cron_skill_force.json"
+
+
+def trigger_cron_skills(
+    run_claude: RunClaude,
+    *,
+    now: datetime | None = None,
+    skills_dir: Path = SKILLS_DIR,
+    state_file: Path = None,
+    force_file: Path = None,
+    catchup_window: timedelta = DEFAULT_CATCHUP,
+    main_context: CodeeMainContext
+) -> None:
+    """Scan skills with cron frontmatter and run due jobs.
+
+    A job is considered due if its most recent scheduled fire at or before
+    ``now`` (within ``catchup_window``) has not been recorded yet. This lets a
+    delayed tick still run a job whose exact cron minute was missed while the
+    process was busy, instead of skipping it until the next period.
+    """
+
+    if state_file is None:
+        state_file = main_context.data_dir / "cron_skill_runs.json"
+    if force_file is None:
+        force_file = _get_force_file_path(main_context)
+
+    tick = (now or datetime.now()).replace(second=0, microsecond=0)
+    state = _load_state(state_file)
+    forced = _load_force(force_file)
+    changed = False
+    force_changed = False
+
+    scheduled_skills = _find_scheduled_skills(skills_dir)
+    if not scheduled_skills:
+        print("[cron_skills] No scheduled skills found.")
+        return
+
+    for skill in scheduled_skills:
+        is_forced = skill.key in forced
+
+        if is_forced:
+            # Admin UI asked for a one-off run on this tick; ignore the schedule.
+            print(
+                f"[cron_skills] Force-running {skill.name} on this tick (manual schedule).")
+        else:
+            try:
+                due = _latest_due(skill.cron, tick, catchup_window)
+            except ValueError as exc:
+                print(f"[cron_skills] Invalid cron for {skill.name}: {exc}")
+                continue
+
+            if due is None:
+                continue
+
+            due_slot = due.isoformat(timespec="minutes")
+            if state.get(skill.key) == due_slot:
+                continue
+
+            if skill.key not in state and due != tick:
+                # First time we observe this skill and the only due fire is in the
+                # past (before the process/skill existed). Don't back-run it; seed a
+                # baseline so genuine future misses are still caught up.
+                state[skill.key] = due_slot
+                changed = True
+                continue
+
+            if due != tick:
+                print(
+                    f"[cron_skills] {skill.name} ({skill.cron}) scheduled at {due_slot} "
+                    f"was missed; catching up at {tick.isoformat(timespec='minutes')}."
+                )
+            print(
+                f"[cron_skills] Running {skill.name} ({skill.cron}) from {skill.path}")
+        session_id = str(uuid.uuid4())
+        try:
+            response = run_claude(skill.body, session_id, skill.model)
+            print(
+                f"[cron_skills] Claude response for {skill.name} ({len(response)} chars)")
+            runs_db.record_run(skill.name, "cron", session_id,
+                               "succeeded", message=skill.body,
+                               main_context=main_context)
+        except Exception as exc:
+            # Don't advance the state slot: leave the job "due" so a later tick
+            # (within the catch-up window) retries it instead of skipping the
+            # whole period. Over-limit runs raise here and get retried.
+            print(
+                f"[cron_skills] Failed to run {skill.name}, will retry: {exc}")
+            runs_db.record_run(skill.name, "cron", session_id, "failed",
+                               error=str(exc)[:500], message=skill.body,
+                               main_context=main_context)
+            continue
+        if is_forced:
+            # One-shot off-schedule run: clear the flag but leave the cron slot
+            # untracked, so the next tick still catches up a genuinely-due fire.
+            forced.discard(skill.key)
+            force_changed = True
+        else:
+            state[skill.key] = due_slot
+            changed = True
+
+    if changed:
+        _save_state(state_file, state)
+    if force_changed:
+        _save_force(force_file, forced)
+
+
+def _latest_due(cron: str, tick: datetime, catchup_window: timedelta) -> datetime | None:
+    """Most recent minute matching ``cron`` in ``[tick - catchup_window, tick]``.
+
+    Returns ``None`` if no scheduled fire falls within the window. Validates the
+    expression on the first candidate so an invalid cron raises ``ValueError``.
+    """
+    max_steps = max(0, int(catchup_window.total_seconds() // 60))
+    candidate = tick
+    for _ in range(max_steps + 1):
+        if _cron_matches(cron, candidate):
+            return candidate
+        candidate -= timedelta(minutes=1)
+    return None
+
+
+def _find_scheduled_skills(skills_dir: Path = SKILLS_DIR) -> list[ScheduledSkill]:
+    skills: list[ScheduledSkill] = []
+    for path in sorted(skills_dir.glob("*/SKILL.md")):
+        try:
+            metadata, body = _parse_skill_file(path.read_text())
+        except OSError as exc:
+            print(f"[cron_skills] Failed to read {path}: {exc}")
+            continue
+
+        # New convention: x-codee-trigger: cron + x-codee-cron. Old `cron` kept as fallback.
+        cron = (metadata.get("x-codee-cron")
+                or metadata.get("cron", "")).strip()
+        if not cron:
+            continue
+
+        name = metadata.get(
+            "name", path.parent.name).strip() or path.parent.name
+        if metadata.get("disable-model-invocation", "").strip().lower() != "true":
+            print(
+                f"[cron_skills] ERROR: {path} declares cron but is missing "
+                "disable-model-invocation: true; skipping."
+            )
+            continue
+
+        skills.append(
+            ScheduledSkill(
+                key=_skill_key(path),
+                name=name,
+                path=path,
+                cron=cron,
+                body=body.strip(),
+                model=metadata.get("model", "").strip(),
+            )
+        )
+    return skills
+
+
+def _parse_skill_file(contents: str) -> tuple[dict[str, str], str]:
+    lines = contents.splitlines()
+    if not lines or lines[0].strip() != "---":
+        return {}, contents
+
+    end_index = None
+    for index, line in enumerate(lines[1:], start=1):
+        if line.strip() == "---":
+            end_index = index
+            break
+
+    if end_index is None:
+        return {}, contents
+
+    metadata: dict[str, str] = {}
+    for line in lines[1:end_index]:
+        stripped = line.strip()
+        if not stripped or stripped.startswith("#") or ":" not in stripped:
+            continue
+        key, _, value = stripped.partition(":")
+        metadata[key.strip().lower()] = _strip_quotes(value.strip())
+
+    body = "\n".join(lines[end_index + 1:]).lstrip("\n")
+    return metadata, body
+
+
+def _cron_matches(expression: str, tick: datetime) -> bool:
+    parts = expression.split()
+    if len(parts) != 5:
+        raise ValueError(
+            "expected 5 fields: minute hour day-of-month month day-of-week")
+
+    minute = _parse_cron_field(parts[0], 0, 59)
+    hour = _parse_cron_field(parts[1], 0, 23)
+    day_of_month = _parse_cron_field(parts[2], 1, 31)
+    month = _parse_cron_field(parts[3], 1, 12)
+    day_of_week = _parse_cron_field(
+        parts[4], 0, 7, normalize_seven_to_zero=True)
+    cron_day_of_week = (tick.weekday() + 1) % 7
+
+    if tick.minute not in minute.values or tick.hour not in hour.values or tick.month not in month.values:
+        return False
+
+    month_day_matches = tick.day in day_of_month.values
+    week_day_matches = cron_day_of_week in day_of_week.values
+
+    if not day_of_month.is_wildcard and not day_of_week.is_wildcard:
+        return month_day_matches or week_day_matches
+    return month_day_matches and week_day_matches
+
+
+def _parse_cron_field(
+    field: str,
+    minimum: int,
+    maximum: int,
+    *,
+    normalize_seven_to_zero: bool = False,
+) -> CronField:
+    values: set[int] = set()
+    is_wildcard = True
+
+    for item in field.split(","):
+        item = item.strip()
+        if not item:
+            raise ValueError(f"empty cron field item in {field!r}")
+
+        base, slash, step_text = item.partition("/")
+        step = 1
+        if slash:
+            if not step_text.isdigit() or int(step_text) <= 0:
+                raise ValueError(f"invalid step {step_text!r} in {field!r}")
+            step = int(step_text)
+
+        if base == "*":
+            start = minimum
+            end = maximum
+        elif "-" in base:
+            start_text, _, end_text = base.partition("-")
+            start = _parse_cron_int(
+                start_text, minimum, maximum, normalize_seven_to_zero)
+            end = _parse_cron_int(
+                end_text, minimum, maximum, normalize_seven_to_zero)
+            is_wildcard = False
+            if start > end:
+                raise ValueError(f"invalid range {base!r} in {field!r}")
+        else:
+            value = _parse_cron_int(
+                base, minimum, maximum, normalize_seven_to_zero)
+            start = value
+            end = value
+            is_wildcard = False
+
+        values.update(range(start, end + 1, step))
+
+    if normalize_seven_to_zero and 7 in values:
+        values.remove(7)
+        values.add(0)
+
+    return CronField(values=values, is_wildcard=is_wildcard)
+
+
+def _parse_cron_int(value: str, minimum: int, maximum: int, normalize_seven_to_zero: bool) -> int:
+    if not value.isdigit():
+        raise ValueError(f"invalid integer {value!r}")
+    parsed = int(value)
+    if normalize_seven_to_zero and parsed == 7:
+        return parsed
+    if parsed < minimum or parsed > maximum:
+        raise ValueError(f"value {parsed} outside {minimum}-{maximum}")
+    return parsed
+
+
+def _load_state(state_file: Path) -> dict[str, str]:
+    try:
+        if state_file.exists():
+            data = json.loads(state_file.read_text())
+            if isinstance(data, dict):
+                return {str(key): str(value) for key, value in data.items()}
+    except (json.JSONDecodeError, OSError) as exc:
+        print(f"[cron_skills] Failed to load state from {state_file}: {exc}")
+    return {}
+
+
+def _save_state(state_file: Path, state: dict[str, str]) -> None:
+    state_file.write_text(json.dumps(state, indent=2, sort_keys=True))
+
+
+def _load_force(force_file: Path) -> set[str]:
+    try:
+        if force_file.exists():
+            data = json.loads(force_file.read_text())
+            if isinstance(data, list):
+                return {str(key) for key in data}
+    except (json.JSONDecodeError, OSError) as exc:
+        print(
+            f"[cron_skills] Failed to load force list from {force_file}: {exc}")
+    return set()
+
+
+def _save_force(force_file: Path, keys: set[str]) -> None:
+    force_file.write_text(json.dumps(sorted(keys), indent=2))
+
+
+def request_force_run(skill_path: Path, main_context: CodeeMainContext) -> None:
+    """Queue a cron skill to run on the next trigger tick, ignoring its schedule."""
+    keys = _load_force(_get_force_file_path(main_context))
+    keys.add(_skill_key(Path(skill_path)))
+    _save_force(_get_force_file_path(main_context), keys)
+
+
+def _skill_key(path: Path) -> str:
+    try:
+        return str(path.relative_to(REPO_ROOT))
+    except ValueError:
+        return str(path)
+
+
+def _strip_quotes(value: str) -> str:
+    if len(value) >= 2 and value[0] == value[-1] and value[0] in {'"', "'"}:
+        return value[1:-1]
+    return value