skiller 0.1.0b1__tar.gz

skiller-0.1.0b1/.codex/skills/skiller-dev/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: skiller-dev
+description: Apply the preferred Skiller coding style when refactoring or adding code in this repository. Use when editing runtime services, use cases, ports, or supporting tests and you need code that is flat, explicit, contract-driven, and easy to read.
+---
+
+# Skiller Dev
+
+Use this skill to keep Skiller code flat, explicit, and easy to maintain.
+
+## Core Rules
+
+- Follow the dependency rule: `interfaces -> application -> domain <- infrastructure`.
+- Infrastructure may implement domain ports and use domain models, but must not orchestrate
+  other domain ports or coordinate business flows.
+- Put ports in `domain` under their feature directory, never in `application`.
+- Keep services thin. Orchestrate; do not persist state directly from the service.
+- Put state changes and side effects in dedicated use cases.
+- Prefer closed contracts with enums for finite domains like statuses and step types.
+- Keep result objects minimal. Prefer `status + payload + error` over many optional fields.
+- Prefer typed contracts at port boundaries. Do not model stable operations as long scalar
+  parameter lists or generic `dict[str, object]` bags when the domain concept is known.
+- Prefer predictive flow over defensive flow. If a case is expected in normal execution,
+  model it in the contract or result type instead of rediscovering it through scattered
+  `None` checks or generic exceptions.
+- Do not make dependencies or fields optional by default. Use `| None` only when absence is
+  a real domain state or a boundary genuinely may not provide the value.
+- Avoid adding `__init__.py` files by default. Use namespace packages unless a package needs
+  real initialization logic, explicit re-exports, or tooling compatibility that requires it.
+- Trust the contract of a use case. Do not add defensive checks for states that should be impossible.
+- Prefer one clear error message over many overly specific status variants.
+- Do not hide non-trivial preparation inside constructor or function-call parameters. Use explicit
+  local variables; do not create private helpers for one or two simple statements unless asked.
+- Do not put architectural responsibility in large top-level functions. If a function coordinates
+  dependencies, owns a workflow, parses a whole external contract, or keeps growing, model it as an
+  object with a clear role such as adapter, mapper, resolver, manager, use case, store, or tool.
+
+## Read By Need
+
+- For readability and control-flow rules, read `packages/skiller/docs/architecture/code-style.md`.
+- For architecture boundaries and allowed dependencies, read `packages/skiller/docs/architecture/architecture.md`.
+- For runtime patterns used in this repo, read `SKILL.md -> references/runtime-patterns.md`.
+- For test taxonomy and what counts as unit/integration/e2e here, read `SKILL.md -> references/testing-rules.md`.
+- For the general pre-commit checklist used in this repo, read `SKILL.md -> references/pre-commit-checklist.md`.
+- For the documented feature and release branch flow of this repo, read `SKILL.md -> references/workflow.md`.
+- For functional runtime rules around waiting, resume, and persisted external events, prefer `SKILL.md -> references/runtime-patterns.md`.
+
+## Sandbox Execution
+
+- Do not assume `pytest` is available in the global `PATH`.
+- In this repo, run tests with `./.venv/bin/pytest ...`.
+- If you prefer activation first, use `source .venv/bin/activate` and then `pytest ...`.
+- For ad hoc Python commands with local imports, use `PYTHONPATH=src python3 ...`.
+- When reporting verification, include the exact command so the next agent can repeat it without rediscovering the environment.
+
+## Release Workflow
+
+Use the documented repo flow in `references/workflow.md` unless the user says otherwise.
+- Treat the `[Agent]`, `[User]`, `[Admin]`, and `[Workflow]` labels in `references/workflow.md` as the source of truth for responsibilities.
+
+## Default Checklist
+
+- Is the control flow flat?
+- Are statuses and types modeled as enums when appropriate?
+- Does each use case have one clear responsibility?
+- Is the service only coordinating use cases?
+- Would a new reader understand the happy path first?
+- Are constructor and function-call parameters simple names instead of inline transformations?
+- Are invalid cases reported with one clear message?
+- If behavior or step contracts changed, did you review the affected docs, especially `docs/steps/*` and `docs/guia_creacion_skills.md`?
+- If the task involves integration or release prep, did you follow `references/workflow.md` instead of an older manual flow?

skiller-0.1.0b1/.codex/skills/skiller-dev/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "Skiller Dev"
+  short_description: "Readable Skiller code style"
+  default_prompt: "Use $skiller-dev to keep Skiller code flat, explicit, and contract-driven."

skiller-0.1.0b1/.codex/skills/skiller-dev/references/pre-commit-checklist.md

@@ -0,0 +1,45 @@
+# Pre-Commit Checklist
+
+## Goal
+
+- The change solves one clear thing.
+- The commit does not mix unrelated work without a reason.
+
+## Code
+
+- The touched code compiles.
+- Contracts are coherent.
+- Old names or stale concepts are not left behind.
+- No personal paths or machine-local assumptions leak into the repo.
+
+## Tests
+
+- The right test level covers the change.
+- Do not add redundant tests.
+- If a scenario is already covered in `integration`, do not duplicate it in `e2e`.
+- `e2e` tests must justify their cost.
+
+## Tree Hygiene
+
+- No `__pycache__`
+- No temporary files
+- No deleted tests half-replaced by new ones
+- No stale references to removed folders or old taxonomy
+
+## Docs
+
+- Update only the docs that really changed.
+- If the change alters step behavior or visible runtime contracts, review and update `docs/steps/*` and `docs/guia_creacion_skills.md`.
+- Do not duplicate living rules across many files.
+- Keep stable rules in the skill references when possible.
+- If you detect duplicated rules across skill files, docs, or checklists, prefer consolidating them into one stable source and leave only short pointers elsewhere.
+
+## Operational Risk
+
+- Call out any manual step the user must know.
+- Example: "recreate the DB because the schema changed".
+
+## Final Check
+
+- `git status` is understandable.
+- The commit can be explained in one sentence.

skiller-0.1.0b1/.codex/skills/skiller-dev/references/runtime-patterns.md

@@ -0,0 +1,79 @@
+# Runtime Patterns
+
+## Current Runtime Flow
+
+- `start_run` -> `StartRunUseCase`
+- loop -> `RenderCurrentStepUseCase`
+- `READY + assign` -> `ExecuteAssignStepUseCase`
+- `READY + notify` -> `ExecuteNotifyStepUseCase`
+- `READY + llm_prompt` -> `ExecuteLlmPromptStepUseCase`
+- `READY + mcp` -> `RenderMcpConfigUseCase` -> `ExecuteMcpStepUseCase`
+- `READY + wait_webhook` -> `ExecuteWaitWebhookStepUseCase`
+- `DONE` -> `CompleteRunUseCase`
+- `INVALID_*` or error -> `FailRunUseCase`
+
+## Webhook Runtime Flow
+
+- webhook input arrives already normalized
+- `HandleWebhookUseCase` persists the webhook and returns matching `run_ids`
+- `ResumeRunUseCase` marks a waiting run as `RUNNING`
+- the service re-enters `_run_steps_loop(run_id)`
+- `ExecuteWaitWebhookStepUseCase` is the owner of leaving the wait:
+  - if no matching webhook event exists, it leaves the run in `WAITING`
+  - if the event exists, it writes `results[step_id]`, advances the step, and continues the loop
+
+## Waiting Semantics
+
+- `wait_webhook` is not consumed when the run first enters `WAITING`
+- while waiting, `current_step` stays on the same `wait_webhook` step
+- the step is only consumed once a matching `webhook + key` event exists
+- the same waiting step owns resolving itself once the matching event exists
+- the webhook must be persisted before any attempt to resume the run
+- `wait_webhook` must survive process restarts and machine shutdowns because its state lives in persistence
+- `webhook receive` must return a minimal operational response:
+  - `accepted`
+  - `duplicate`
+  - `webhook`
+  - `key`
+  - `matched_runs`
+- if `run --start-webhooks` does not end in `WAITING`, the `webhooks` process must not be started
+- if `run --start-webhooks` ends in `WAITING`, the system must try to start the `webhooks` process and fail clearly if it cannot
+- the minimal `webhooks` process must expose:
+  - `GET /health`
+  - `POST /webhooks/{webhook}/{key}`
+
+## Contract Style
+
+- `RenderCurrentStepUseCase` returns a minimal result:
+  - `status`
+  - `next_step` only when `READY`
+- `RenderMcpConfigUseCase` returns a minimal result:
+  - `status`
+  - `mcp_config`
+  - `error`
+- `ResumeRunUseCase` returns an explicit result:
+  - `RESUMED`
+  - `RUN_NOT_FOUND`
+  - `NOT_WAITING`
+
+## Use Case Naming
+
+- Prefer explicit names:
+  - `RenderMcpConfigUseCase`
+  - `ExecuteMcpStepUseCase`
+  - `ExecuteNotifyStepUseCase`
+  - `ExecuteWaitWebhookStepUseCase`
+  - `HandleWebhookUseCase`
+  - `ResumeRunUseCase`
+  - `CompleteRunUseCase`
+  - `FailRunUseCase`
+
+- Avoid vague names when the code is really rendering, executing, completing, or failing something.
+
+## Style Intention
+
+- Prepare data in one step.
+- Execute it in the next step.
+- Keep the loop declarative.
+- Keep invalid cases short and explicit.
+- Avoid use case -> use case chains and callback-driven runtime flow.

skiller-0.1.0b1/.codex/skills/skiller-dev/references/testing-rules.md

@@ -0,0 +1,57 @@
+# Testing Rules
+
+## Test Types
+
+- `unit`
+  - tests one piece in isolation
+  - no real infrastructure
+  - no external process
+  - no real network
+  - no real database
+
+- `integration`
+  - crosses real components of the system
+  - may use fixtures
+  - may use subprocesses
+  - may use a temporary real database
+  - may use local HTTP servers or test MCP servers
+
+- `e2e`
+  - enters through a real system interface
+  - typically CLI or HTTP
+  - no infrastructure fixtures from the repo
+  - validates an observable final result
+  - keep these few and high-value
+  - treat them as manual operator smoke tests, not exhaustive behavioral tests
+
+## Classification Rule
+
+- If a test needs infrastructure fixtures, it is not `e2e`.
+- If a scenario is already well covered in `integration`, do not duplicate it in `e2e`.
+- In `e2e`, less is more.
+
+## Current Repo Intent
+
+- Prefer one script per operator flow under `tests/e2e/cli_*.sh`.
+- Isolate each run with a temporary DB via `AGENT_DB_PATH`.
+- Execute the real runtime entrypoint with `PYTHONPATH=src ... -m skiller`.
+- Assert a small final JSON contract such as `run_id`, `status`, and only the minimum extra fields needed for the flow.
+- Do not assert internal persistence details, event payloads, or intermediate state if `integration` already covers them.
+- Use `SKIPPED` instead of failing when the flow depends on external credentials or provider access that may not exist locally.
+- Reserve multi-command E2E flows for genuinely operational paths such as wait/resume.
+- `notify`, `assign`, `switch`, `when`, `wait_webhook`, and `llm_prompt` through CLI are valid manual operator flows in this repo.
+- `llm_prompt` CLI remains opt-in when it depends on real provider credentials.
+- `stdio mcp` through CLI is part of the manual CLI coverage in this repo.
+- MCP with test servers or repo fixtures belongs to `integration`.
+- Manual CLI wrappers live in `tests/e2e/cli_*.sh`.
+- `tests/e2e/cli_all.sh` is the manual aggregator for those flows.
+- When adding a new runtime step intended for real usage, add at least one `cli_<step>.sh` flow and register it in `cli_all.sh`.
+
+## Placement
+
+- `tests/unit/...`
+- `tests/integration/...`
+- `tests/e2e/...`
+
+Keep fixtures near the integration tests that use them. Do not keep infrastructure fixtures under `tests/e2e/`.
+Small YAML skills used only by manual CLI wrappers may live under `tests/e2e/skills/`.

skiller-0.1.0b1/.codex/skills/skiller-dev/references/workflow.md

@@ -0,0 +1,116 @@
+# Repo Workflow
+
+Use this repo flow unless the user says otherwise.
+
+## Feature Workflow
+
+1. `[Agent, User]` Work on `feature/<topic>` from `main`.
+2. `[Agent]` Implement the feature on that branch.
+3. `[Agent]` Validate locally with the repo commands:
+   - `./.venv/bin/ruff check .`
+   - `./.venv/bin/pytest`
+   - `./.venv/bin/python -m hatchling build`
+4. `[Agent]` Make sure the working tree is intentional before rewriting history.
+   - `git status -sb` must be understandable.
+   - If there are accidental unstaged changes, resolve them before the squash.
+5. `[Agent]` Squash the branch into one clean commit on top of `main`.
+6. `[Agent]` Verify the branch compares against `main` as exactly one commit.
+   - `git rev-list --count main..HEAD` must return `1`.
+   - `git log --oneline main..HEAD` must show the single PR commit.
+7. `[Agent]` If the branch history changed, update the remote branch.
+   - Use `git push --force-with-lease origin feature/<topic>` after a squash or other rewrite.
+8. `[Agent]` Open the PR from `feature/<topic>` into `main` using `skiller run pr` with explicit inputs.
+9. `[Workflow]` The `Feature PR` workflow validates:
+   - branch base is `main`
+   - branch name starts with `feature/`
+   - branch compares as one commit directly on top of `main`
+   - `ruff`
+   - `pytest`
+   - package build
+10. `[User]` Review and approve the PR.
+11. `[Admin]` Merge the PR into `main`.
+
+## Release Workflow
+
+1. `[Agent, User]` Create `release/<version>` from `main`.
+2. `[Agent]` Update `project.version` in `pyproject.toml`.
+3. `[Agent]` Update `CHANGELOG.md` with the release summary.
+4. `[Agent]` Close the changelog entry as `## <version> - <date>` and reset `## Unreleased`.
+5. `[Agent]` Validate locally with the repo commands:
+   - `./.venv/bin/ruff check .`
+   - `./.venv/bin/pytest`
+   - `./.venv/bin/python -m hatchling build`
+6. `[Agent]` Make sure the working tree is intentional before rewriting history.
+   - `git status -sb` must be understandable.
+7. `[Agent]` Squash the branch into one clean commit on top of `main`.
+8. `[Agent]` Verify the branch compares against `main` as exactly one commit.
+   - `git rev-list --count main..HEAD` must return `1`.
+9. `[Agent]` Verify the release branch changes only:
+   - `pyproject.toml`
+   - `CHANGELOG.md`
+10. `[Agent]` If the branch history changed, update the remote branch.
+   - Use `git push --force-with-lease origin release/<version>` after a squash or other rewrite.
+11. `[Agent]` Open the PR from `release/<version>` into `main` using `skiller run pr` with explicit inputs.
+12. `[Workflow]` The `Release PR` workflow validates:
+   - branch base is `main`
+   - branch name starts with `release/`
+   - branch compares as one commit directly on top of `main`
+   - only `pyproject.toml` and `CHANGELOG.md` changed
+   - `CHANGELOG.md` has a closed section for `<version>`
+   - `CHANGELOG.md` resets `Unreleased`
+   - `project.version` in `pyproject.toml` matches `<version>`
+   - `ruff`
+   - `pytest`
+   - package build
+13. `[User]` Review and approve the PR.
+14. `[Admin]` Merge the PR into `main`.
+15. `[Workflow]` After merge, CI creates the tag `v<version>` on the merged commit.
+
+## PR Command
+
+The internal `pr` agent does not infer repo metadata or PR fields by itself.
+Pass the inputs explicitly with `--arg`.
+
+Feature PR template:
+
+```bash
+./.venv/bin/skiller run pr \
+  --arg owner=<github-owner> \
+  --arg repo=<github-repo> \
+  --arg head=feature/<topic> \
+  --arg base=main \
+  --arg title='<commit-or-pr-title>' \
+  --arg body='<short summary and validation>'
+```
+
+Release PR template:
+
+```bash
+./.venv/bin/skiller run pr \
+  --arg owner=<github-owner> \
+  --arg repo=<github-repo> \
+  --arg head=release/<version> \
+  --arg base=main \
+  --arg title='release: <version>' \
+  --arg body='<release summary and validation>'
+```
+
+Practical notes:
+- Derive `owner` and `repo` from `git remote get-url origin` if needed.
+- If the branch was renamed for workflow compliance, push the new branch before opening the PR.
+- If the old remote branch is no longer needed after a rename, delete it explicitly.
+- If `pr` fails with unresolved placeholders such as `{{inputs.owner}}`, rerun it with explicit `--arg` inputs.
+
+## Rules
+
+- Do not use a manual release workflow on `main`; that flow is obsolete.
+- Do not update `CHANGELOG.md` on feature branches unless the user explicitly asks for it.
+- Do not open a release PR with extra file changes.
+- Do not leave a feature or release branch as multiple commits when the workflow requires one clean commit.
+- Do not open a PR from a branch whose name does not match the required prefix.
+- Do not assume a local squash is enough; after rewriting history, verify the remote branch too.
+- Do not read or inspect tokens, secrets, or `.env` contents directly.
+- Use trusted repo commands that consume credentials implicitly for their normal operation, for example `skiller run pr`.
+- If a trusted repo command depends on authenticated environment that is not available in the sandbox, ask permission and run that command outside the sandbox instead of trying it inside the sandbox first.
+- Do not use ad hoc scripts or generic tooling around credentials when a trusted repo command already exists for the task.
+- If a trusted repo command cannot authenticate because the required environment is missing, report that as a blocker.

skiller-0.1.0b1/.env.development

@@ -0,0 +1 @@
+AGENT_DB_PATH=dev-runtime.db

skiller-0.1.0b1/.github/workflows/feature.yml

@@ -0,0 +1,56 @@
+name: Feature PR
+
+on:
+  pull_request:
+    branches:
+      - main
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - ready_for_review
+
+permissions:
+  contents: read
+
+jobs:
+  validate:
+    if: startsWith(github.event.pull_request.head.ref, 'feature/')
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout PR head
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e .[dev] build
+
+      - name: Validate branch shape
+        env:
+          GITHUB_BASE_REF: ${{ github.base_ref }}
+          GITHUB_HEAD_REF: ${{ github.head_ref }}
+        run: |
+          python scripts/ci/validate_pr_branch.py \
+            --base-ref "$GITHUB_BASE_REF" \
+            --expected-base "main" \
+            --head-ref "$GITHUB_HEAD_REF" \
+            --head-prefix "feature/"
+
+      - name: Run ruff
+        run: python -m ruff check packages/skiller/src apps/tui/src packages/skiller/tests apps/tui/tests
+
+      - name: Run pytest
+        run: python -m pytest
+
+      - name: Build package
+        run: python -m build

skiller-0.1.0b1/.github/workflows/publish.yml

@@ -0,0 +1,41 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+    inputs:
+      ref:
+        description: "Git ref to publish (for example: v1.0.0-alpha.8)"
+        required: true
+        type: string
+
+permissions:
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: pypi
+
+    steps:
+      - name: Checkout tagged commit
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event_name == 'workflow_dispatch' && inputs.ref || github.ref }}
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Build package
+        run: |
+          python -m pip install --upgrade pip build
+          python -m build
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verify-metadata: false

skiller-0.1.0b1/.github/workflows/release.yml

@@ -0,0 +1,101 @@
+name: Release PR
+
+on:
+  pull_request:
+    branches:
+      - main
+    types:
+      - opened
+      - synchronize
+      - reopened
+      - ready_for_review
+      - closed
+
+permissions:
+  contents: write
+
+jobs:
+  validate:
+    if: github.event.action != 'closed' && startsWith(github.event.pull_request.head.ref, 'release/')
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout PR head
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          python -m pip install -e .[dev] build
+
+      - name: Validate branch shape
+        env:
+          GITHUB_BASE_REF: ${{ github.base_ref }}
+          GITHUB_HEAD_REF: ${{ github.head_ref }}
+        run: |
+          python scripts/ci/validate_pr_branch.py \
+            --base-ref "$GITHUB_BASE_REF" \
+            --expected-base "main" \
+            --head-ref "$GITHUB_HEAD_REF" \
+            --head-prefix "release/"
+
+      - name: Validate release metadata
+        env:
+          GITHUB_BASE_REF: ${{ github.base_ref }}
+          GITHUB_HEAD_REF: ${{ github.head_ref }}
+        run: |
+          python scripts/ci/validate_release_pr.py \
+            --base-ref "$GITHUB_BASE_REF" \
+            --expected-base "main" \
+            --head-ref "$GITHUB_HEAD_REF"
+
+      - name: Run ruff
+        run: python -m ruff check packages/skiller/src apps/tui/src packages/skiller/tests apps/tui/tests
+
+      - name: Run pytest
+        run: python -m pytest
+
+      - name: Build package
+        run: python -m build
+
+  create_tag:
+    if: github.event.action == 'closed' && github.event.pull_request.merged == true && startsWith(github.event.pull_request.head.ref, 'release/')
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout merged commit
+        uses: actions/checkout@v4
+        with:
+          ref: ${{ github.event.pull_request.merge_commit_sha }}
+          fetch-depth: 0
+
+      - name: Ensure tag does not already exist
+        env:
+          RELEASE_TAG: v${{ github.event.pull_request.head.ref }}
+        run: |
+          release_version="${RELEASE_TAG#vrelease/}"
+          release_tag="v${release_version}"
+          if git rev-parse "$release_tag" >/dev/null 2>&1; then
+            echo "tag already exists: $release_tag" >&2
+            exit 1
+          fi
+
+      - name: Create and push tag
+        env:
+          RELEASE_BRANCH: ${{ github.event.pull_request.head.ref }}
+          MERGE_COMMIT_SHA: ${{ github.event.pull_request.merge_commit_sha }}
+        run: |
+          release_version="${RELEASE_BRANCH#release/}"
+          release_tag="v${release_version}"
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git tag "$release_tag" "$MERGE_COMMIT_SHA"
+          git push origin "$release_tag"

skiller-0.1.0b1/.gitignore

@@ -0,0 +1,62 @@
+# Python bytecode
+__pycache__/
+*.py[cod]
+*$py.class
+
+# Packaging / build artifacts
+build/
+dist/
+.eggs/
+*.egg
+*.egg-info/
+pip-wheel-metadata/
+
+# Virtual environments
+.venv/
+venv/
+env/
+ENV/
+
+# Tool caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.pyre/
+.pytype/
+.hypothesis/
+.tox/
+.nox/
+
+# Coverage
+.coverage
+.coverage.*
+coverage.xml
+htmlcov/
+
+# Notebook / editor / OS
+.ipynb_checkpoints/
+.DS_Store
+.idea/
+.vscode/
+
+# Environment files
+.env
+.env.*
+!.env.development
+
+# Runtime artifacts
+*.db
+*.sqlite3
+logs/
+.tmp/
+docs-legacy/
+docs/spikes/
+
+# Local JS bridge artifacts
+src/skiller/local/channels/whatsapp/bridge/node_modules/
+src/skiller/local/channels/whatsapp/bridge/package-lock.json
+packages/skiller/src/skiller/local/channels/whatsapp/bridge/node_modules/
+packages/skiller/src/skiller/local/channels/whatsapp/bridge/package-lock.json
+legacy/
+
+apps/tui/docs/todo