cdragon 0.1.0

package/README.md

@@ -0,0 +1,110 @@
+# skills
+
+개인 스킬 모음 저장소입니다. Claude Code 플러그인 형태로 설치할 수 있습니다.
+
+## Overview
+
+이곳에는 다양한 작업을 자동화하고 생산성을 높이기 위한 스킬들이 정리됩니다.
+
+`cdragon list` 로 항상 최신 목록을 확인할 수 있습니다.
+
+| 스킬                       | 설명                                                          |
+| -------------------------- | ------------------------------------------------------------- |
+| `agent-browser`            | AI 에이전트용 브라우저 자동화 CLI                             |
+| `grill-me`                 | 계획·설계를 끝까지 캐묻는 인터뷰                              |
+| `herdr-agent`              | herdr 안에서 새 탭·분할·워크스페이스에 코딩 에이전트를 띄움   |
+| `herdr-cli`                | herdr를 내부에서 제어 (워크스페이스·탭·분할·에이전트 관리)    |
+| `notion-presentation`      | 콘텐츠를 Notion 프레젠테이션 모드용 슬라이드 문서로 구성      |
+| `setup-matt-pocock-skills` | 엔지니어링 스킬용 이슈 트래커·트리아지 설정                   |
+| `tdd`                      | red-green-refactor 기반 테스트 주도 개발                      |
+| `to-html`                  | 콘텐츠를 브랜드 디자인이 적용된 단일 HTML 파일로 렌더링       |
+| `to-issues`                | 계획·스펙·PRD를 독립적으로 집을 수 있는 이슈로 분해           |
+| `to-prd`                   | 현재 대화를 PRD로 정리해 이슈 트래커에 발행                   |
+
+## Install (Claude Code plugin)
+
+마켓플레이스로 등록한 뒤 플러그인을 설치합니다.
+
+```text
+/plugin marketplace add speardragon/skills
+/plugin install speardragon-skills@speardragon-skills
+```
+
+로컬 경로로 등록할 수도 있습니다.
+
+```text
+/plugin marketplace add /path/to/skills
+```
+
+## `cdragon` CLI
+
+이 레포의 스킬을 원하는 위치의 `.claude/skills` 또는 `.agents/skills` 에 **심링크**로 연결하는 CLI입니다. 플러그인 설치 대신 로컬 디렉터리에 바로 붙이고 싶을 때 사용합니다.
+
+### 설치
+
+셋 중 편한 방법을 고르세요. (모두 Node.js ≥18 필요)
+
+**npm (권장)**
+
+```bash
+npm i -g cdragon
+```
+
+**curl**
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/speardragon/skills/main/install.sh | bash
+# ~/.cdragon 에 clone 후 cdragon 명령을 PATH에 등록. 재실행하면 업데이트됩니다.
+```
+
+**직접 clone (개발용)**
+
+```bash
+git clone https://github.com/speardragon/skills.git
+cd skills
+npm link        # cdragon 명령을 전역 PATH에 등록
+```
+
+### 사용
+
+```bash
+cdragon          # 대화형: scope(project/global) → 폴더(.claude/.agents) → 스킬 선택
+cdragon list     # 사용 가능한 스킬 목록 보기
+cdragon help     # 도움말
+```
+
+대화형 화살표 UI 대신 플래그로 비대화형 실행도 가능합니다.
+
+```bash
+cdragon --project --claude --all -y      # 현재 폴더의 .claude/skills 에 전부 연결
+cdragon --global --both tdd grill-me     # ~/.claude, ~/.agents 양쪽에 일부만 연결
+```
+
+| 플래그                             | 의미                                         |
+| ---------------------------------- | -------------------------------------------- |
+| `-p, --project`                    | 현재 디렉터리에 연결                         |
+| `-g, --global`                     | 홈 디렉터리(`~/.claude`, `~/.agents`)에 연결 |
+| `--claude` / `--agents` / `--both` | 대상 폴더 선택                               |
+| `-a, --all`                        | 모든 스킬 연결                               |
+| `--skills a,b,c`                   | 특정 스킬만 연결                             |
+| `-y, --yes`                        | 확인 프롬프트 건너뛰기                       |
+
+이미 존재하는 **실제 디렉터리**는 덮어쓰지 않고 건너뜁니다. 같은 대상을 가리키는 심링크는 그대로 두고, 다른 곳을 가리키면 다시 연결합니다.
+
+## Getting Started
+
+```bash
+git clone https://github.com/speardragon/skills.git
+cd skills
+```
+
+## Credits
+
+- `grill-me`, `to-issues`, `to-prd`, `tdd`, `setup-matt-pocock-skills` — [mattpocock/skills](https://github.com/mattpocock/skills) (MIT)
+- `agent-browser` — [vercel-labs/agent-browser](https://github.com/vercel-labs/agent-browser)
+
+스킬은 [vercel `skills` CLI](https://github.com/vercel-labs/agent-skills)로 관리되며, 출처는 `skills-lock.json`에 기록됩니다.
+
+## License
+
+MIT

package/bin/cdragon.js

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+'use strict'
+
+const path = require('node:path')
+const os = require('node:os')
+
+const pkg = require('../package.json')
+const c = require('../src/colors')
+const prompt = require('../src/prompt')
+const { SKILLS_DIR, discoverSkills } = require('../src/skills')
+const { linkSkills } = require('../src/link')
+
+const truncate = (s, n) => (s.length > n ? s.slice(0, n - 1) + '…' : s)
+
+function parseArgs(args) {
+  const opts = { scope: null, folders: [], all: false, skills: [], yes: false }
+
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i]
+    if (a === '--global' || a === '-g') opts.scope = 'global'
+    else if (a === '--project' || a === '-p') opts.scope = 'project'
+    else if (a === '--claude') opts.folders.push('.claude')
+    else if (a === '--agents') opts.folders.push('.agents')
+    else if (a === '--both') opts.folders.push('.claude', '.agents')
+    else if (a === '--all' || a === '-a') opts.all = true
+    else if (a === '--skills') opts.skills.push(...(args[++i] || '').split(',').map((s) => s.trim()).filter(Boolean))
+    else if (a === '--yes' || a === '-y') opts.yes = true
+    else if (!a.startsWith('-')) opts.skills.push(a)
+    else throw new Error(`Unknown option: ${a}`)
+  }
+
+  opts.folders = [...new Set(opts.folders)]
+  return opts
+}
+
+function help() {
+  console.log(`
+${c.bold('cdragon')} — symlink this repo's agent skills into a target location
+
+${c.bold('Usage')}
+  cdragon                 Interactive: pick scope, folder(s) and skills to link
+  cdragon [skills...]     Link named skills (skips the skill picker)
+  cdragon list            List available skills
+  cdragon help            Show this help
+
+${c.bold('Flags')} ${c.dim('(skip the matching prompt)')}
+  -p, --project           Link into the current directory ${c.dim('(default prompt)')}
+  -g, --global            Link into your home dir (~/.claude, ~/.agents)
+      --claude            Target .claude/skills
+      --agents            Target .agents/skills
+      --both              Target both
+  -a, --all               Link every skill
+      --skills a,b,c      Link a specific comma-separated set
+  -y, --yes               Skip the confirmation prompt
+
+${c.bold('Examples')}
+  cdragon --project --claude --all -y
+  cdragon -g --both tdd handoff
+`)
+}
+
+function listSkills() {
+  const skills = discoverSkills(SKILLS_DIR)
+  if (!skills.length) {
+    console.log(c.yellow(`No skills found in ${SKILLS_DIR}`))
+    return
+  }
+  const width = Math.max(...skills.map((s) => s.name.length))
+  console.log(`\n${c.bold(`Skills (${skills.length})`)}  ${c.dim(SKILLS_DIR)}\n`)
+  for (const s of skills) {
+    console.log(`  ${c.cyan(s.name.padEnd(width))}  ${c.dim(truncate(s.description, 80))}`)
+  }
+  console.log('')
+}
+
+async function linkCommand(opts) {
+  const skills = discoverSkills(SKILLS_DIR)
+  if (!skills.length) throw new Error(`No skills found in ${SKILLS_DIR}`)
+
+  // 1. Scope: project (cwd) or global (home).
+  let scope = opts.scope
+  if (!scope) {
+    scope = await prompt.select('Install scope?', [
+      { label: `project  ${c.dim('(current directory)')}`, value: 'project' },
+      { label: `global   ${c.dim('(~/.claude, ~/.agents)')}`, value: 'global' },
+    ])
+  }
+
+  // 2. Folder(s): .claude and/or .agents.
+  let folders = opts.folders
+  if (!folders.length) {
+    folders = await prompt.multiselect('Which folder(s) to link into?', [
+      { label: '.claude/skills', value: '.claude' },
+      { label: '.agents/skills', value: '.agents' },
+    ])
+  }
+  if (!folders.length) throw new Error('No target folder selected.')
+
+  // 3. Skills: all, named, or interactively picked.
+  let chosen
+  if (opts.all) {
+    chosen = skills
+  } else if (opts.skills.length) {
+    chosen = opts.skills.map((name) => {
+      const found = skills.find((s) => s.name === name)
+      if (!found) throw new Error(`Unknown skill: ${name}`)
+      return found
+    })
+  } else {
+    const picked = await prompt.multiselect(
+      'Which skills to link?',
+      skills.map((s) => ({ label: `${s.name}  ${c.dim(truncate(s.description, 56))}`, value: s.name }))
+    )
+    chosen = picked.map((name) => skills.find((s) => s.name === name))
+  }
+  if (!chosen.length) throw new Error('No skills selected.')
+
+  const base = scope === 'global' ? os.homedir() : process.cwd()
+
+  // Summary + confirm.
+  console.log('')
+  console.log(`  ${c.bold('scope')}    ${scope} ${c.dim(`(${base})`)}`)
+  console.log(`  ${c.bold('folders')}  ${folders.join(', ')}`)
+  console.log(`  ${c.bold('skills')}   ${chosen.map((s) => s.name).join(', ')}`)
+  console.log('')
+
+  if (!opts.yes) {
+    const ok = await prompt.confirm(`Create ${chosen.length * folders.length} symlink(s)?`, true)
+    if (!ok) {
+      console.log(c.dim('Aborted.'))
+      return
+    }
+  }
+
+  // Link + report.
+  const results = []
+  for (const folder of folders) results.push(...linkSkills(chosen, base, folder))
+
+  const icon = {
+    linked: c.green('+ linked  '),
+    relinked: c.green('↻ relinked'),
+    already: c.dim('= already '),
+    exists: c.yellow('! skipped '),
+  }
+  console.log('')
+  for (const r of results) {
+    const note = r.status === 'exists' ? c.yellow(' (real dir exists, not touched)') : ''
+    console.log(`  ${icon[r.status]}  ${r.folder}/skills/${r.skill}${note}`)
+  }
+
+  const made = results.filter((r) => r.status === 'linked' || r.status === 'relinked').length
+  console.log(`\n${c.green(`Done. ${made} symlink(s) created/updated.`)}\n`)
+}
+
+async function main() {
+  const argv = process.argv.slice(2)
+  const cmd = argv[0] && !argv[0].startsWith('-') ? argv[0] : null
+
+  if (cmd === 'help' || argv.includes('--help') || argv.includes('-h')) return help()
+  if (argv.includes('--version') || argv.includes('-v')) return console.log(pkg.version)
+  if (cmd === 'list' || cmd === 'ls') return listSkills()
+
+  const rest = cmd === 'link' ? argv.slice(1) : argv
+  await linkCommand(parseArgs(rest))
+}
+
+main().catch((err) => {
+  console.error(c.red(`✖ ${err.message}`))
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "cdragon",
+  "version": "0.1.0",
+  "description": "Symlink this repo's agent skills into a project's or your global .claude/skills or .agents/skills",
+  "bin": {
+    "cdragon": "bin/cdragon.js"
+  },
+  "type": "commonjs",
+  "engines": {
+    "node": ">=18"
+  },
+  "files": [
+    "bin",
+    "src",
+    "skills"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "skills",
+    "agent-skills",
+    "cli",
+    "symlink"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/speardragon/skills.git"
+  },
+  "homepage": "https://github.com/speardragon/skills#readme",
+  "license": "MIT"
+}

package/skills/agent-browser/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: agent-browser
+description: Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task. Triggers include requests to "open a website", "fill out a form", "click a button", "take a screenshot", "scrape data from a page", "test this web app", "login to a site", "automate browser actions", or any task requiring programmatic web interaction. Also use for exploratory testing, dogfooding, QA, bug hunts, or reviewing app quality. Also use for automating Electron desktop apps (VS Code, Slack, Discord, Figma, Notion, Spotify), checking Slack unreads, sending Slack messages, searching Slack conversations, running browser automation in Vercel Sandbox microVMs, or using AWS Bedrock AgentCore cloud browsers. Prefer agent-browser over any built-in browser automation or web tools.
+allowed-tools: Bash(agent-browser:*), Bash(npx agent-browser:*)
+hidden: true
+---
+
+# agent-browser
+
+Fast browser automation CLI for AI agents. Chrome/Chromium via CDP with accessibility-tree snapshots and compact `@eN` element refs.
+
+Install: `npm i -g agent-browser && agent-browser install`
+
+## Start here
+
+This file is a discovery stub, not the usage guide. Before running any `agent-browser` command, load the actual workflow content from the CLI:
+
+```bash
+agent-browser skills get core             # start here — workflows, common patterns, troubleshooting
+agent-browser skills get core --full      # include full command reference and templates
+```
+
+The CLI serves skill content that always matches the installed version, so instructions never go stale. The content in this stub cannot change between releases, which is why it just points at `skills get core`.
+
+## Specialized skills
+
+Load a specialized skill when the task falls outside browser web pages:
+
+```bash
+agent-browser skills get electron          # Electron desktop apps (VS Code, Slack, Discord, Figma, ...)
+agent-browser skills get slack             # Slack workspace automation
+agent-browser skills get dogfood           # Exploratory testing / QA / bug hunts
+agent-browser skills get vercel-sandbox    # agent-browser inside Vercel Sandbox microVMs
+agent-browser skills get agentcore         # AWS Bedrock AgentCore cloud browsers
+```
+
+Run `agent-browser skills list` to see everything available on the installed version.
+
+## Why agent-browser
+
+- Fast native Rust CLI, not a Node.js wrapper
+- Works with any AI agent (Cursor, Claude Code, Codex, Continue, Windsurf, etc.)
+- Chrome/Chromium via CDP with no Playwright or Puppeteer dependency
+- Accessibility-tree snapshots with element refs for reliable interaction
+- Sessions, authentication vault, state persistence, video recording
+- Specialized skills for Electron apps, Slack, exploratory testing, cloud providers
+
+## Observability Dashboard
+
+The dashboard runs independently of browser sessions on port 4848 and can also be opened through a proxied or forwarded URL such as `https://dashboard.agent-browser.localhost`. Agents should stay on the dashboard origin: session tabs, status, and stream traffic are proxied internally, so session ports do not need to be exposed.

package/skills/grill-me/SKILL.md

@@ -0,0 +1,7 @@
+---
+name: grill-me
+description: A relentless interview to sharpen a plan or design.
+disable-model-invocation: true
+---
+
+Run a `/grilling` session.

package/skills/herdr-agent/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: herdr-agent
+description: 'Spawn a coding agent (claude / codex / any) into a new herdr location — a new tab, a pane split, or a new workspace — then wait until it is ready (agent_status idle). Use when running inside herdr (HERDR_ENV=1) and the user asks to open/launch/spawn an agent: "launch claude", "one more codex", "split next to me and run claude", "codex in a new workspace".'
+---
+
+# herdr-agent — spawning agents in herdr
+
+A skill for spawning a coding agent (claude / codex / anything else) into a new location inside herdr and **confirming it is ready**. Low-level herdr control is handled by the `herdr-cli` skill; this skill layers an "agent spawn" workflow on top of it.
+
+**The core is simple: pick a location → start the agent → wait until idle → report.** Extra configuration like auto mode and rc is not part of the main flow — it lives in the [appendix](#appendix--extra-configuration) (only when the user explicitly asks).
+
+## Main flow
+
+### 0. Guard
+
+If `HERDR_ENV != 1`, **stop immediately** and tell the user "not inside herdr, so I can't spawn an agent".
+
+```bash
+[ "$HERDR_ENV" = "1" ] || { echo "not inside herdr — stop"; exit 1; }   # echo alone won't stop — you must abort
+herdr pane get "$HERDR_PANE_ID"   # determine my pane/tab/workspace/cwd
+```
+
+Always determine your own location via `$HERDR_PANE_ID`. `focused:true` is the pane the user's UI is looking at, not your pane.
+
+> ids look like `w1K`, `w1K:t6`, `w1K:pA` (alphanumeric allowed). Always re-read them from the `pane get`/`list`/`split` response (they may be compacted).
+
+### 1. Parse intent
+
+Extract from natural language. Use defaults when unspecified.
+
+| Item                | Value                                | Default    |
+| ------------------- | ------------------------------------ | ---------- |
+| Target              | new tab / pane split / new workspace | new tab    |
+| Agent               | claude / codex / other               | claude     |
+| Count               | N                                    | 1          |
+| Split direction     | right / down                         | right      |
+| cwd (new workspace) | path                                 | rule below |
+
+Examples: "one more claude" → claude in a new tab / "split next to me and run codex" → codex in a split right / "two claudes in a new workspace" → workspace ×2.
+
+**New-workspace cwd**: if a path is given, use it as-is. If not, default to the current cwd — but "new workspace" usually means a different project, so **if ambiguous, ask a one-line follow-up**.
+
+> auto mode and rc are not in the main flow. If the user explicitly says "in auto mode", "with remote control", etc., see the [appendix](#appendix--extra-configuration).
+
+### 2. Create the target
+
+Create a pane for each target and **parse the new pane id (`NEW_PANE`) from the response json**. Whatever the target, §3 starts the agent in this `NEW_PANE`. Because the json path differs per target (split is `result.pane.pane_id`; tab/workspace are `result.root_pane.pane_id`), parse them uniformly as below. Use `--no-focus` to keep your own focus. For N, repeat N times.
+
+```bash
+# new tab — root_pane.pane_id
+NEW_PANE=$(herdr tab create --workspace "$WS" --no-focus \
+  | python3 -c 'import sys,json; print(json.load(sys.stdin)["result"]["root_pane"]["pane_id"])')
+
+# pane split — pane.pane_id
+NEW_PANE=$(herdr pane split "$HERDR_PANE_ID" --direction right --no-focus \
+  | python3 -c 'import sys,json; print(json.load(sys.stdin)["result"]["pane"]["pane_id"])')
+
+# new workspace — root_pane.pane_id (if you also need the workspace/tab id, parse result.workspace / result.tab too)
+NEW_PANE=$(herdr workspace create --cwd "$CWD" --no-focus \
+  | python3 -c 'import sys,json; print(json.load(sys.stdin)["result"]["root_pane"]["pane_id"])')
+```
+
+### 3. Start the agent and wait until idle — the core
+
+Use herdr's `agent_status` as the primary ready signal (not the on-screen text). A new pane is an empty shell, so it reads `unknown`; the moment you start the agent and herdr detects it, it becomes `idle`. This primary check is the same regardless of agent type.
+
+> Caution: **`idle` means "not streaming / not working", not "the main prompt is ready to accept input".** First-run prompts like login / model selection / trust-folder confirmation may be on screen yet still look idle to herdr. So after reaching idle, read the screen once to check for a known blocker and report it (below).
+
+```bash
+herdr pane run "$NEW_PANE" "claude"   # or "codex", etc.
+herdr wait agent-status "$NEW_PANE" --status idle --timeout 30000
+echo "exit=$?"
+herdr pane read "$NEW_PANE" --source visible --lines 20   # check for known blockers after idle
+```
+
+- **exit 0 + no blocker on screen → ready.** Done. (If claude's default mode is auto, it comes up in auto as-is.)
+- **If a first-run prompt (login / model selection / trust folder, etc.) is on screen** → don't guess and press keys; **report the facts** and hand off to the user. Most of the time it's already configured, so this rarely actually blocks.
+- **On timeout (exit 1) → do not guess and press keys.** Read that tab further with `--source recent-unwrapped` to see what is blocking, and report the facts.
+
+```bash
+herdr pane read "$NEW_PANE" --source recent-unwrapped --lines 30   # diagnose on timeout
+```
+
+> `wait agent-status` is level-triggered, so if it's already idle it returns immediately. A new pane is `unknown` right before launch, so this is safe. **Always start in a new pane** (reusing an existing agent pane can mistake its prior idle for the new one).
+
+### 4. Report — a simple list
+
+One line per spawned agent. No tables, no verbose logs, no links.
+
+```
+- w1K:p9 (tab) — claude · idle ✓
+- w1K:pA (split right) — codex · idle ✓
+- w2A:p1 (new workspace /path/to/proj) — claude · ⚠ timeout (screen: login prompt)
+```
+
+For any that didn't reach idle, state on that line what was blocking, factually. Don't kill it or retry endlessly. If you applied extra configuration (auto/rc), append the result as a single token too (e.g. `· auto ✓`).
+
+### Beyond spawning — hand off to herdr-cli
+
+This skill ends at "spawned and idle". If the request goes further than spawning — sending a task prompt to the spawned agent, reading its output, or waiting for that task to complete (e.g. "split next to me, run codex, and have it check the translation") — that is the `herdr-cli` skill's job. See its **`wait for an agent task to complete`** section (the `herdr-agent-run-and-wait` helper, which sends a prompt and safely waits for `working → idle/done`) and the **`spawn a new agent and give it a task`** recipe, which chains the full flow end to end.
+
+## Core principles
+
+- Determine your own location only via `$HERDR_PANE_ID` (never `focused`).
+- Always re-parse ids from the response (don't assume they stay stable after compaction).
+- The primary ready check is `agent_status idle`; after that, read the screen once to check only for first-run blockers (idle ≠ guaranteed ready for input).
+- If blocked, don't guess and press keys — read the tab and report.
+- Scope is spawning to idle. For anything past that (task prompt, output, completion wait), use the `herdr-cli` skill.
+
+---
+
+## Appendix — extra configuration
+
+The main flow ends at "start and confirm idle". Below is claude-only extra configuration, applied **only when the user explicitly requests it**. (Other agents like codex don't have these concepts — starting them is all there is.)
+
+### Changing auto mode (claude only)
+
+Unnecessary if the default mode is already auto. Only when the user wants a specific mode ("in plan mode", "switch to auto") or the default isn't auto.
+
+Cycle modes with Shift+Tab (`\e[Z`). Order (4-state):
+`normal → ⏵⏵ accept edits on → ⏸ plan mode on → ⏵⏵ auto mode on → normal`
+
+Procedure — **compute, then verify**:
+
+1. Read the current badge by content: `herdr pane read "$P" --source visible --lines 14 | grep -oE "accept edits on|plan mode on|auto mode on"` (none → normal).
+2. Compute the number of presses N needed to reach the target (e.g. normal→auto = 3, accept→auto = 2, plan→auto = 1).
+3. `for i in $(seq 1 "$N"); do herdr pane send-text "$P" $'\e[Z'; sleep 0.4; done`
+4. Read again and confirm the target badge. If it's off (e.g. version change), send `\e[Z` one at a time to correct, up to 5 times. If still wrong, report the screen state.
+
+### rc (remote control, claude only)
+
+For when you want to continue the session from your phone / claude.ai.
+
+```bash
+herdr pane send-text "$P" "/rc"; sleep 0.6
+herdr pane send-keys "$P" Enter; sleep 1.5
+herdr pane read "$P" --source visible --lines 20
+```
+
+For verification, only check **whether the status bar shows `/rc active`** (don't parse the remote link). If it's not shown, report the screen state.
+
+> rc is claude-only. codex has a separate CLI feature called `codex remote-control`, but it differs from this skill's purpose (bridging an interactive session inside a herdr pane to phone/claude.ai), so it is **not covered.** If the user wants remote control for codex, tell them it's out of scope for this skill.