witooh

@witooh source repo

29 skills
0 followers
4 hours ago last updated

▌
Ship 2 · witooh
One-command release for the neo-plugin — bump the plugin version, pack all working-tree changes into a single commit, tag, push, and publish a GitHub release, in that order. Takes the bump type as an argument (major | minor | patch); infers it from the diff when omitted. Use when the user says "/ship", "/ship minor", "/ship patch", "ship it", "cut a release", "bump version + commit + push + release", "ออก release", "bump + push + release ทีเดียว".

0
installs
▌
Sync Mattpocock 2 · witooh bundle
Sync the allowlisted method-layer skills from mattpocock/skills into this neo-plugin repo. Use when updating the method layer, pulling tdd/code-review/grilling and related skills, or when the user says "sync mattpocock", "update method skills", or "pull mattpocock skills".

0
installs
▌
Commit · witooh
Smart git commit workflow with branch protection, rebase, and conventional commits. Detects protected branches (main, develop, release/*, staging) and auto-creates a feature/* branch before committing. Rebases onto base branch to keep history clean. Analyzes changes, smart-stages files (excluding secrets), writes conventional commit messages, and offers to push. Use whenever the user says "commit", "/commit", "commit changes", "save my work", "push this", "commit and push", or wants to commit code changes. Also trigger when the user finishes a task and says "done", "เสร็จแล้ว", "commit ให้หน่อย", "ช่วย commit", or "save and push".

0
installs
▌
Notion · witooh
Interact with Notion workspaces via the `ntn` CLI tool (Notion's official CLI). Use this skill whenever the user wants to read, create, update, archive, or search Notion pages, query Notion databases (data sources), upload/list files, manage comments, or call any Notion REST endpoint from the terminal without opening a browser. Also trigger when the user says things like "ดู page Notion", "สร้าง page ใน Notion", "อัปเดต page", "query database Notion", "ค้นใน Notion", "อัปโหลดไฟล์ขึ้น Notion", "create notion page", "update notion db row", "search notion", "list notion users", or pastes a `notion.so` URL and wants to do something with it. Always run `ntn` via the shell execution tool — do not call the Notion REST API directly with `curl` when an `ntn` subcommand or `ntn api` invocation will do.

0
installs
▌
Improve · witooh bundle
Iteratively improve any output until measurable criteria are met. Use when the user wants to refine existing work against specific standards — whether it's code, prose, data, config, or any other artifact. Triggers on phrases like "improve this", "make it better", "iterate", "refine", "keep improving", "not good enough yet", "optimize this", "polish this", "tighten this up", "ปรับปรุง", "ทำให้ดีขึ้น", "ยังไม่ดี", "แก้ให้ดีกว่านี้", "iterate ต่อ", or when the user provides criteria and wants repeated improvement until they're satisfied. Also use when the user gives feedback on output and expects you to keep refining, even if they don't say "improve" explicitly.

0
installs
▌
Fastmail · witooh bundle
Manages Fastmail email and calendar via JMAP and CalDAV APIs. Use for emails (read, send, reply, search, organize, bulk operations, threads) or calendar (events, reminders, RSVP invitations). Timezone auto-detected from system.

0
installs
▌
State DB · witooh
Centralized state management layer for all Claude Code skills using self-hosted PostgREST. Provides persistent read/write access to a shared PostgreSQL database via REST API. Use this skill whenever another skill needs to persist data, retrieve stored state, or manage records across sessions. Trigger on: "save state", "load state", "persist data", "skill state", "state-db", "read from db", "write to db", "postgrest", "skill_state", or when any skill needs to store or retrieve persistent data. Also use when building or modifying skills that require cross-session memory or shared data storage.

0
installs
▌
Brainstorm · witooh bundle
ALWAYS use this skill before answering brainstorming, ideation, prompt crafting, or open-ended exploration requests. Transforms vague requests into actionable outputs via adaptive guided questioning — triages into Prompt Mode (craft/improve prompts), Explore Mode (brainstorm ideas), or Focused Mode (specific problem strategies). Trigger when user says: "brainstorm", "ช่วยคิด", "help me think", "I have an idea", "improve this prompt", "let's explore", "I want to build", "I'm thinking about", "brainstorm วิธี", "ช่วยคิดหน่อย", "อยากทำ", "ยังไม่รู้จะทำอะไร", "not sure about the approach", "help me figure out", "what should I". Also trigger for: side projects, career decisions, project planning, migration strategies, architecture decisions, cost optimization, or any request where the user hasn't decided direction yet and would benefit from structured discovery. Do NOT skip — adapts depth automatically (2-7 questions) and produces BETTER results by asking targeted questions first.

0
installs
▌
Food Tracker · witooh bundle
Track daily phosphorus (ฟอสฟอรัส) and potassium (โพแทสเซียม) intake from food for kidney disease management. Use this skill whenever the user mentions food they ate, wants to log meals, check daily/monthly intake, or asks for nutrient reports. Trigger on: "กินข้าว", "กิน...มื้อเช้า/เที่ยง/เย็น", "บันทึกอาหาร", "สรุปวันนี้", "สรุปเดือน", "รายงานอาหาร", "ฟอสฟอรัส", "โพแทสเซียม", "log food", "food tracker", "what did I eat", any Thai or English food name followed by a meal context, or when the user sends a photo/image of food. Also trigger when the user asks which foods contributed most to their mineral intake.

0
installs
▌
Agent Browser · witooh
Automates browser interactions for web testing, form filling, screenshots, and data extraction. Use when the user needs to navigate websites, interact with web pages, fill forms, take screenshots, test web applications, or extract information from web pages.

0
installs
▌
Gitlab · witooh
Low-level GitLab execution via the glab CLI — the "execution arm" that the neo skill invokes (through the Skill tool) to run glab for MR creation and review-comment posting. Also usable directly for lightweight, side-effect-free MR operations: Read (summarize an MR), Update (อัพเดท MR description), list MRs, view MR/CI status, fetch CI job logs, and approve MRs. Trigger when the user pastes a bare GitLab MR URL or says "อ่าน MR", "ดู MR", "check MR", "สรุป MR", "อัพเดท MR", "update description", "แก้ description", "list MRs", "list open MRs", "check pipeline", "pipeline status", "approve MR", or asks for a raw glab operation. NOTE: creating an MR ("สร้าง MR"), reviewing an MR ("review MR", "ตรวจ MR"), fixing issues/CI, or addressing review feedback now route through the using-neo skill (which calls this skill for the glab I/O) — do NOT trigger this skill directly for those; let using-neo orchestrate.

0
installs
▌
API Spec · witooh bundle
Author the custom-YAML API spec at docs/api/ — the spec-first source of truth for every HTTP endpoint; producer at the head of the api-doc chain. Create, update, or validate _meta.yaml plus one <domain>/<endpoint>.yaml per endpoint (method/path/auth, request/response fields with M/O + Remark, multi-flow business_logic, errors, covers_ac); three-layer verify (apispeccheck.py + fresh-eyes + completeness sweep) + generated index.md. Not OpenAPI. Use when designing an API contract spec-first before code exists (Draft, API step), authoring or adding endpoints, updating the spec from built code (structural sync-back, DOC step), or validating it. Triggers: author/create/write/gen/update api spec, update api spec from code, add an endpoint, validate api spec, ออกแบบ/อัปเดต api spec จาก code. Route elsewhere (read-only consumers): Go-vs-spec drift → openapi-doc; Bruno collection → open-collection; Confluence → confluence-api-doc. Authoring never scans Go — only the from-code sync-back reads it.

0
installs
▌
Atlassian · witooh bundle
Interact with Jira and Confluence from the terminal via the `acli` (Atlassian CLI) — view/search/create/edit/transition/assign/comment on Jira work items, manage sprints, boards, and projects, and read Confluence pages or manage spaces without a browser. The acli reference the `using-neo` skill points to: the command map plus the judgment `--help` can't give (JQL, workflows, safety); run `acli <path> --help` for exact flags. Trigger on a direct, ad-hoc Jira/Confluence CLI action — "ดู issue ของฉัน", "view my issues", "transition ไป In Progress", "move ticket to In Progress", "สร้าง bug ใน Jira", "create a Jira task", "search ด้วย JQL", "find unassigned bugs", "ดู sprint ปัจจุบัน", "assign ให้ฉัน", "ดู Confluence page", "list spaces", or any raw acli operation. Route elsewhere: verifying AC/test-cases/design against a JIRA card, or any read-only card workflow → the `using-neo` skill (runs read-only acli inline); publishing generated API docs to Confluence → `confluence-api-doc` (acli cannot write pages).

0
installs
▌
Using Neo · witooh bundle
Orchestrates engineering work: the main agent does the work itself by default and owns intent, the loop-or-graph decision, the work record, gates, and the completeness verdict. Delegates to specialist nodes only when the work fans out, a step must fail in isolation, or an independent reviewer is required. Enforces grounding plus conditional machine gates. Use when starting any task.

0
installs
▌
Bug Hunter · witooh
Hunts for latent defects in product code that no gate covers and nobody has reported — the gap between "every acceptance criterion passes" and "the code is right". Works six grounds, each with a runnable command that lists candidates: requirement fidelity against `docs/knowledge/`, unexercised contract surface, money/decimal math, calendar/timezone math, idempotency and concurrency, and unvalidated upstream responses. Use when a card is green and you want what it still gets wrong, before a risky release, or on unfamiliar code. Every finding needs a failing test or evidence it cannot trigger; confirmed findings include reproduce steps + proposed fix, then BUG flow (do not fix in the hunt). Not for reported bugs (`diagnosing-bugs`), diff review (`code-review`), gate audits (`falsifying`), or live HTTP abuse (`attack-test`).

0
installs
▌
Falsifying · witooh
Attacks a green signal to find out whether it can go red at all. Audits the measuring apparatus — a gate, checker, coverage number, CI job, or test suite — rather than the product: constructs the case that must fail and checks that it does, and diffs every independent source of the same fact against the others. Use when a gate or checker is written or changed, when a metric looks better than the work feels, before trusting a number in an MR, or when a suite passes on code nobody has exercised. Produces a failing case or a source-disagreement table as evidence; a confirmed finding is handed to the BUG flow, not fixed in place. Not for a reported bug with a symptom (that is `diagnosing-bugs`), not a diff review (`code-review`), not a hunt through product code for latent defects (`bug-hunter`), and not live HTTP abuse probes (`attack-test`).

0
installs
▌
Markitdown · witooh
Ingest an external source (JIRA card, Confluence page, URL, image, HTML, text, or a verbal brief) once into `docs/knowledge/` as curated, reusable context — with provenance (source url, fetched_at, version/etag when available). The memory primitive that neo's ingest-first step depends on. Standalone — call it directly (`/ingest <url>`) to pre-warm the knowledge base, or neo triggers it when a task needs context that is not yet ingested. Triggers: "/ingest", "ingest <source>", "remember this", "add <url> to the knowledge base", or neo routing here during the ingest-first gate.

0
installs
▌
Attack Test · witooh
Fires abuse/hack paths over HTTP against a running stack (local/SIT) after the happy path works. Hunts money-moves, authz bypass, proof forge, and idempotency leaks; reports each finding with reproduce steps plus a fix that names the file/check to enforce. Use when the user says try hack, attack-test, probe the flow, security probe HTTP, or asks whether skipping step X still transfers or completes a protected action. Not for static latent hunts (`bug-hunter`), gate audits (`falsifying`), diff review (`code-review`), or AC-driven e2e (`e2e-playwright`).

0
installs
▌
Code Review · witooh bundle
Review the changes since a fixed point (commit, branch, tag, or merge-base) along two axes — Standards (does the code follow this repo's documented coding standards?) and Spec (does the code match what the originating issue/PRD asked for?). Runs both reviews in parallel sub-agents and reports them side by side. Use when the user wants to review a branch, a PR, work-in-progress changes, or asks to "review since X".

0
installs
▌
Neo Aux Sit · witooh bundle
Connect to Auxiliary SIT (kubectl + self-hosted ArgoCD) to inspect logs (kubectl + OpenSearch), deploy status, and locate Postgres connection settings inside service K8s secrets for debugging.

0
installs
▌
Openapi Doc · witooh bundle
Verify Go source against the custom-YAML **API spec** at `docs/api/` and emit a **drift report** — the sync-back detector for the api-doc chain. The api-spec (authored spec-first by `api-spec`) is the source of truth; this skill **writes nothing** — it scans the Go code and diffs it against `docs/api/<domain>/*.yaml` (routes, request/response fields, M/O, types), reporting where the implementation drifted from the contract so `api-spec` can reconcile it. Built-in **three-layer verify** (script + fresh-eyes agent + completeness sweep). Trigger on: "check go against api-spec", "api drift report", "sync-back api", "did the code drift from the spec", "หา drift api", "เช็ค code ตรงกับ api-spec ไหม". Also trigger when the using-neo flow needs the api-spec drift / sync-back check. NOTE: reads `docs/api/*.yaml` (authored by `api-spec` via `/spec`) + Go, writes nothing — a runnable Bruno collection is `open-collection`; Confluence publishing is `confluence-api-doc`. Not a spec generator, OpenAPI converter, or editor.

0
installs
▌
Ship · witooh
One-command release for the neo-plugin — bump the plugin version, pack all working-tree changes into a single commit, tag, push, and publish a GitHub release, in that order. Takes the bump type as an argument (major | minor | patch); infers it from the diff when omitted. Use when the user says "/ship", "/ship minor", "/ship patch", "ship it", "cut a release", "bump version + commit + push + release", "ออก release", "bump + push + release ทีเดียว".

0
installs
▌
Init Project · witooh bundle
Scaffold a brand-new Go hexagonal / DDD microservice from a bundled, frozen template — an empty-but-runnable account-service snapshot (clean layers, tooling, infra, `.kiro/` steering) with ZERO business domains. It builds and serves `GET /health` immediately, ready for `using-neo` (or Kiro) to add the first domain. Asks the service identity (Go module path, name, id, postgres schema, target dir), runs `scaffold.py` (copy + sentinel-substitute + go mod tidy + git init + build), then verifies (L1 `initcheck.py` + L2 fresh-eyes). Trigger on: "init project", "/init-project", "scaffold a service", "new service from template", "bootstrap a Go service", "สร้าง project ใหม่", "สร้าง service ใหม่", "scaffold service ใหม่", "โครง service เปล่า", "ตั้งโปรเจกต์ใหม่ตาม account-service", "ทำ boilerplate", "new Go service skeleton". Needs Go >= 1.26 and GOPRIVATE access to the org `common-lib` the template needs. NOTE: only CREATES the empty skeleton — adding domains / AC / endpoints / tests is the `using-neo` skill.

0
installs
▌
Neo Core Sit · witooh bundle
Connect to Core SIT (kubectl + managed ArgoCD) to inspect logs (kubectl + OpenSearch), deploy status, and locate Postgres connection settings inside service K8s secrets for debugging.

0
installs
▌
E2e Playwright · witooh bundle
Author, update, and run HTTP end-to-end tests — one per acceptance criterion — for a service with a Jest + Playwright-request e2e harness (Playwright's HTTP client run by Jest, not the @playwright/test runner). Each test title carries the stable prefix '[<CARD> - AC-NNN] <desc> → <expected>' so every AC is traceable. Reads ACs from the neo spec (docs/tasks/<card>/spec.md) or a legacy docs/design/ layout, authors specs from those + the api-spec contract, runs the suite, maps pass/fail to each AC; a task with no AC section runs without the AC gate. Three-layer verify: e2echeck.py coverage tripwire + fresh-eyes + completeness. Only HTTP-observable ACs are gated; a non-observable one (log/PII) is a declared it.skip with a reason. Use when you write, generate, or run AC-driven HTTP e2e ('write e2e', 'run e2e', 'เขียน e2e', 'รัน e2e', 'e2e ตาม AC'), or when neo's Verify phase delegates e2e. NOT here: unit/logic → tdd; browser-UI testing is out of scope; api-spec → api-spec.

0
installs
▌
Migrate Project · witooh bundle
Refactor an EXISTING Go service so its structure conforms to the account-service hexagonal / DDD blueprint — the brownfield sibling of `init-project` (which supplies the target-structure contract: its frozen template + `.kiro/steering/` + `.golangci.yaml`). Plans the work as ordered, independently-verifiable SLICES (one bounded context each), moves each on a branch with `git mv` (behavior-preserving), and verifies per slice (go build/test/vet + golangci) plus a final three-layer check (L1 `structurecheck.py` + L2 fresh-eyes + L3 completeness). Plan-first and resumable via `<target>/docs/migration/plan.md`. Trigger on: "migrate project", "/migrate-project", "restructure an existing service", "refactor ให้เหมือน account-service", "ย้ายโครงสร้างโปรเจกต์", "จัดโครงสร้างใหม่ตาม account-service", "migrate service เดิมให้เข้าโครง", "ปรับโครงสร้าง service ให้เหมือน account-service". NOTE: refactors EXISTING code — a brand-new empty service is `init-project`; adding a domain / AC / endpoint / tests is `using-neo`.

0
installs
▌
Open Collection · witooh bundle
Generate a **runnable, self-documenting** Bruno OpenCollection from the custom-YAML **API spec** at `docs/api/*.yaml` — one request `.yml` per endpoint, grouped by domain, with `environments/` + `folder.yml` auth and a generated `docs:` block per request (rendered from the api-spec, so the collection documents itself). Also update or validate an existing collection. Built-in three-layer verify (deterministic script + independent fresh-eyes agent + completeness sweep). Trigger on: "gen open collection", "สร้าง open collection", "สร้าง bruno จาก api spec", "อัปเดต bruno collection", "bruno from docs/api". Also runs at the using-neo DOC step as a runnable API-collection deliverable. NOTE: the `docs/api/*.yaml` api-spec is authored by the **`api-spec`** skill and drift-checked against Go by `openapi-doc`; this skill only reads it — if missing, author it with `api-spec` first. Publishing to Confluence is `confluence-api-doc`. Not a curl/Postman/OpenAPI converter or an editor.

0
installs
▌
Confluence API Doc · witooh bundle
Publish API docs to Confluence — from the `docs/api/*.yaml` custom-YAML api-spec — one endpoint = one page under domain-group parent pages, with the service overview on the parent page. Assembles each page directly from the api-spec's doc-table shape, converts to Confluence storage, and syncs via acli (auth/reads) + REST (writes), with a built-in **three-layer verify**: a deterministic pre-flight + round-trip check, an independent fresh-eyes pass, and a completeness sweep. Trigger on: "publish api doc", "sync api doc", "push doc to confluence", "publish api spec to confluence", "อัปเดต api doc ไป confluence", "sync api spec to confluence". Also trigger when using-neo requests API-doc publishing (DOC step). NOTE: the api-spec is authored by the `api-spec` skill; `openapi-doc` drift-checks Go against it; a runnable Bruno OpenCollection is the `open-collection` skill. Input is the `docs/api/*.yaml` api-spec — if it does not exist, author it with `api-spec` first. Not a general Confluence editor.

0
installs
▌
Sync Mattpocock · witooh bundle
Sync the allowlisted method-layer skills from mattpocock/skills into this neo-plugin repo. Use when updating the method layer, pulling tdd/code-review/grilling and related skills, or when the user says "sync mattpocock", "update method skills", or "pull mattpocock skills".

0
installs

29 published skills