@firatcand/forge 0.1.0

package/lib/linear-helpers.sh

@@ -0,0 +1,188 @@
+#!/usr/bin/env bash
+# linear-helpers.sh — Linear MCP wrappers used by /push-to-linear, /sync-status.
+#
+# These functions assume the Linear MCP server is configured for Claude Code
+# and that tool calls happen through the agent. Bash callers (e.g. setup
+# scripts) can use the JSON-printing variants which read API_KEY from
+# $LINEAR_API_KEY as a fallback.
+#
+# Source this file: `source "${FORGE_DIR}/lib/linear-helpers.sh"`
+
+set -euo pipefail
+
+# ──────────────────────────────────────────────
+# Logging
+# ──────────────────────────────────────────────
+_log()  { printf '\033[1;36m[linear]\033[0m %s\n' "$*" >&2; }
+_warn() { printf '\033[1;33m[linear]\033[0m %s\n' "$*" >&2; }
+_err()  { printf '\033[1;31m[linear]\033[0m %s\n' "$*" >&2; }
+
+# ──────────────────────────────────────────────
+# linear_check_mcp
+# Verifies that the Linear MCP server is registered with Claude Code.
+# Returns 0 if available, 1 otherwise.
+# ──────────────────────────────────────────────
+linear_check_mcp() {
+  if ! command -v claude >/dev/null 2>&1; then
+    _err "claude CLI not found on PATH"
+    return 1
+  fi
+
+  if ! claude mcp list 2>/dev/null | grep -qi 'linear'; then
+    _warn "Linear MCP server not registered. Run: claude mcp add linear ..."
+    return 1
+  fi
+
+  _log "Linear MCP server registered"
+  return 0
+}
+
+# ──────────────────────────────────────────────
+# linear_api_call ENDPOINT_PATH METHOD [BODY_JSON]
+# Low-level wrapper for direct Linear API access (fallback when MCP isn't
+# configured). Requires LINEAR_API_KEY in env.
+# ──────────────────────────────────────────────
+linear_api_call() {
+  local endpoint="${1:?endpoint required}"
+  local method="${2:-GET}"
+  local body="${3:-}"
+
+  if [[ -z "${LINEAR_API_KEY:-}" ]]; then
+    _err "LINEAR_API_KEY not set"
+    return 1
+  fi
+
+  local args=(-sS -X "${method}" \
+    -H "Authorization: ${LINEAR_API_KEY}" \
+    -H "Content-Type: application/json" \
+    "https://api.linear.app${endpoint}")
+
+  if [[ -n "${body}" ]]; then
+    args+=(-d "${body}")
+  fi
+
+  curl "${args[@]}"
+}
+
+# ──────────────────────────────────────────────
+# linear_create_project NAME [DESCRIPTION]
+# Echoes the new project's id to stdout.
+# ──────────────────────────────────────────────
+linear_create_project() {
+  local name="${1:?name required}"
+  local description="${2:-}"
+
+  local payload
+  payload=$(jq -n --arg name "${name}" --arg description "${description}" \
+    '{query: "mutation($name: String!, $description: String!) { projectCreate(input: {name: $name, description: $description}) { project { id name } } }",
+      variables: {name: $name, description: $description}}')
+
+  linear_api_call /graphql POST "${payload}" | jq -r '.data.projectCreate.project.id'
+}
+
+# ──────────────────────────────────────────────
+# linear_create_cycle TEAM_ID NAME [STARTS_AT] [ENDS_AT]
+# Echoes the new cycle's id.
+# ──────────────────────────────────────────────
+linear_create_cycle() {
+  local team_id="${1:?team_id required}"
+  local name="${2:?name required}"
+  local starts_at="${3:-}"
+  local ends_at="${4:-}"
+
+  local payload
+  payload=$(jq -n \
+    --arg team "${team_id}" \
+    --arg name "${name}" \
+    --arg startsAt "${starts_at}" \
+    --arg endsAt "${ends_at}" \
+    '{query: "mutation($input: CycleCreateInput!) { cycleCreate(input: $input) { cycle { id name } } }",
+      variables: {input: {teamId: $team, name: $name, startsAt: $startsAt, endsAt: $endsAt}}}')
+
+  linear_api_call /graphql POST "${payload}" | jq -r '.data.cycleCreate.cycle.id'
+}
+
+# ──────────────────────────────────────────────
+# linear_create_issue PROJECT_ID TITLE BODY PRIORITY ESTIMATE [CYCLE_ID]
+# Priority: 1 (urgent), 2 (high), 3 (medium), 4 (low)
+# Estimate: numeric (e.g. 1=S, 3=M, 5=L)
+# Echoes the new issue's id.
+# ──────────────────────────────────────────────
+linear_create_issue() {
+  local project_id="${1:?project_id required}"
+  local title="${2:?title required}"
+  local body="${3:-}"
+  local priority="${4:-3}"
+  local estimate="${5:-3}"
+  local cycle_id="${6:-}"
+
+  local payload
+  payload=$(jq -n \
+    --arg project "${project_id}" \
+    --arg title "${title}" \
+    --arg body "${body}" \
+    --argjson priority "${priority}" \
+    --argjson estimate "${estimate}" \
+    --arg cycle "${cycle_id}" \
+    '{query: "mutation($input: IssueCreateInput!) { issueCreate(input: $input) { issue { id identifier } } }",
+      variables: {input: {projectId: $project, title: $title, description: $body, priority: $priority, estimate: $estimate, cycleId: ($cycle | select(. != ""))}}}')
+
+  linear_api_call /graphql POST "${payload}" | jq -r '.data.issueCreate.issue.id'
+}
+
+# ──────────────────────────────────────────────
+# linear_set_blocks ISSUE_ID BLOCKER_IDS...
+# Sets "blocked by" relations from BLOCKER_IDS to ISSUE_ID.
+# ──────────────────────────────────────────────
+linear_set_blocks() {
+  local issue_id="${1:?issue_id required}"
+  shift
+
+  local blocker
+  for blocker in "$@"; do
+    local payload
+    payload=$(jq -n \
+      --arg issue "${issue_id}" \
+      --arg blocker "${blocker}" \
+      '{query: "mutation($issueId: String!, $relatedIssueId: String!) { issueRelationCreate(input: {issueId: $issueId, relatedIssueId: $relatedIssueId, type: blocks}) { success } }",
+        variables: {issueId: $blocker, relatedIssueId: $issue}}')
+
+    linear_api_call /graphql POST "${payload}" >/dev/null
+  done
+}
+
+# ──────────────────────────────────────────────
+# linear_get_issue_status ISSUE_ID
+# Echoes the current status name (e.g. "Todo", "In Progress").
+# ──────────────────────────────────────────────
+linear_get_issue_status() {
+  local issue_id="${1:?issue_id required}"
+
+  local payload
+  payload=$(jq -n --arg id "${issue_id}" \
+    '{query: "query($id: String!) { issue(id: $id) { state { name } } }", variables: {id: $id}}')
+
+  linear_api_call /graphql POST "${payload}" | jq -r '.data.issue.state.name'
+}
+
+# ──────────────────────────────────────────────
+# linear_link_github PROJECT_ID GITHUB_REPO_SLUG
+# Connects a Linear project to a GitHub repo for native sync.
+# Note: Linear's GraphQL API for this is limited. In practice this is
+# configured via the Linear UI; this function prints a manual instruction.
+# ──────────────────────────────────────────────
+linear_link_github() {
+  local project_id="${1:?project_id required}"
+  local repo="${2:?repo (owner/name) required}"
+
+  cat <<EOF >&2
+[linear] Manual step required:
+  1. Open Linear → Settings → Integrations → GitHub
+  2. Connect repo: ${repo}
+  3. Map to project: ${project_id}
+  4. Enable: branch-name auto-link, PR-status sync
+
+Once linked, branches like 'feat/{ID}-slug' auto-attach to the issue,
+and PRs move issues through Todo → In Progress → In Review → Done.
+EOF
+}

package/lib/paths.js

@@ -0,0 +1,13 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs-extra';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export const FORGE_ROOT = path.resolve(__dirname, '..');
+
+export function getPackageVersion() {
+  const pkg = fs.readJsonSync(path.join(FORGE_ROOT, 'package.json'));
+  return pkg.version;
+}

package/lib/tools.js

@@ -0,0 +1,68 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs-extra';
+
+const TOOL_DEFINITIONS = [
+  {
+    key: 'claude',
+    name: 'Claude Code',
+    dir: path.join(os.homedir(), '.claude'),
+    skillsDir: 'skills',
+    agentsDir: 'agents',
+  },
+  {
+    key: 'codex',
+    name: 'Codex CLI',
+    dir: path.join(os.homedir(), '.codex'),
+    skillsDir: 'skills',
+    agentsDir: 'subagents',
+  },
+  {
+    key: 'cursor',
+    name: 'Cursor',
+    dir: path.join(os.homedir(), '.cursor'),
+    skillsDir: 'skills',
+    agentsDir: 'agents',
+  },
+  {
+    key: 'gemini',
+    name: 'Gemini CLI',
+    dir: path.join(os.homedir(), '.gemini'),
+    skillsDir: 'extensions',
+    agentsDir: null,
+  },
+];
+
+export function detectTools() {
+  return TOOL_DEFINITIONS.filter(tool => fs.pathExistsSync(tool.dir));
+}
+
+export async function installToTool(tool, forgeRoot) {
+  const skillsTarget = path.join(tool.dir, tool.skillsDir);
+  const agentsTarget = tool.agentsDir ? path.join(tool.dir, tool.agentsDir) : null;
+
+  await fs.ensureDir(skillsTarget);
+  if (agentsTarget) await fs.ensureDir(agentsTarget);
+
+  const skillsSource = path.join(forgeRoot, 'skills');
+  const skills = await fs.readdir(skillsSource);
+  for (const skill of skills) {
+    const src = path.join(skillsSource, skill);
+    const dst = path.join(skillsTarget, skill);
+    await fs.remove(dst);
+    await fs.copy(src, dst, { overwrite: true, errorOnExist: false });
+  }
+
+  if (agentsTarget) {
+    const agentsSource = path.join(forgeRoot, 'agents');
+    if (await fs.pathExists(agentsSource)) {
+      const agents = await fs.readdir(agentsSource);
+      for (const agent of agents) {
+        const src = path.join(agentsSource, agent);
+        const dst = path.join(agentsTarget, agent);
+        await fs.remove(dst);
+        await fs.copy(src, dst, { overwrite: true, errorOnExist: false });
+      }
+    }
+  }
+}

package/lib/validators.sh

@@ -0,0 +1,284 @@
+#!/usr/bin/env bash
+# validators.sh — spec + phases.yaml validation used by /ingest-spec, /decompose.
+#
+# Source: `source "${FORGE_DIR}/lib/validators.sh"`
+
+set -euo pipefail
+
+# ──────────────────────────────────────────────
+# Logging
+# ──────────────────────────────────────────────
+_log()  { printf '\033[1;34m[validate]\033[0m %s\n' "$*" >&2; }
+_warn() { printf '\033[1;33m[validate]\033[0m %s\n' "$*" >&2; }
+_err()  { printf '\033[1;31m[validate]\033[0m %s\n' "$*" >&2; }
+
+# ──────────────────────────────────────────────
+# validate_spec_section FILE SECTION_HEADER
+# Verifies the file contains a non-empty section under the given header.
+# Returns 0 if section exists with content, 1 otherwise.
+# ──────────────────────────────────────────────
+validate_spec_section() {
+  local file="${1:?file required}"
+  local header="${2:?header required}"
+
+  if [[ ! -f "${file}" ]]; then
+    _err "${file}: file does not exist"
+    return 1
+  fi
+
+  # Find the section and check it contains content beyond the header
+  awk -v hdr="## ${header}" '
+    BEGIN { found=0; content=0 }
+    $0 == hdr { found=1; next }
+    found && /^## / { exit }
+    found && /[^[:space:]]/ && !/^<!--/ { content=1 }
+    END { exit (found && content) ? 0 : 1 }
+  ' "${file}"
+
+  local rc=$?
+  if [[ ${rc} -ne 0 ]]; then
+    _err "${file}: missing or empty section '${header}'"
+  fi
+  return ${rc}
+}
+
+# ──────────────────────────────────────────────
+# validate_brief PATH
+# Validates spec/BRIEF.md against required sections.
+# ──────────────────────────────────────────────
+validate_brief() {
+  local file="${1:?path required}"
+  local sections=(
+    "The pain"
+    "The user"
+    "The unfair advantage"
+    "The smallest valuable thing"
+    "Non-goals"
+    "North-star metric"
+    "Kill criteria"
+  )
+
+  local failed=0
+  local s
+  for s in "${sections[@]}"; do
+    validate_spec_section "${file}" "${s}" || failed=$((failed + 1))
+  done
+
+  if [[ ${failed} -eq 0 ]]; then
+    _log "✓ BRIEF.md complete"
+  fi
+  return ${failed}
+}
+
+# ──────────────────────────────────────────────
+# validate_prd PATH
+# ──────────────────────────────────────────────
+validate_prd() {
+  local file="${1:?path required}"
+  local sections=(
+    "Problem"
+    "Target user"
+    "Acceptance Criteria (the MVP)"
+    "Explicit non-goals"
+    "Success metrics"
+    "Constraints"
+  )
+
+  local failed=0
+  local s
+  for s in "${sections[@]}"; do
+    validate_spec_section "${file}" "${s}" || failed=$((failed + 1))
+  done
+
+  if [[ ${failed} -eq 0 ]]; then
+    _log "✓ PRD.md complete"
+  fi
+  return ${failed}
+}
+
+# ──────────────────────────────────────────────
+# validate_spec PATH
+# ──────────────────────────────────────────────
+validate_spec() {
+  local file="${1:?path required}"
+  local sections=(
+    "Stack"
+    "Data model"
+    "Key flows"
+    "Security model"
+    "Environment variables"
+  )
+
+  local failed=0
+  local s
+  for s in "${sections[@]}"; do
+    validate_spec_section "${file}" "${s}" || failed=$((failed + 1))
+  done
+
+  if [[ ${failed} -eq 0 ]]; then
+    _log "✓ SPEC.md complete"
+  fi
+  return ${failed}
+}
+
+# ──────────────────────────────────────────────
+# validate_phases_yaml PATH
+# Validates structure + DAG. Requires `yq`.
+#
+# Checks:
+#   - top-level fields: project, phases
+#   - each phase has id, name, goal, gate_criteria, tasks
+#   - each task has id, title, type, priority, depends_on, estimate, owner_type, acceptance
+#   - no XL estimates
+#   - dependency graph is a DAG (no cycles)
+# ──────────────────────────────────────────────
+validate_phases_yaml() {
+  local file="${1:?path required}"
+
+  if [[ ! -f "${file}" ]]; then
+    _err "${file}: does not exist"
+    return 1
+  fi
+
+  if ! command -v yq >/dev/null 2>&1; then
+    _err "yq required (https://github.com/mikefarah/yq)"
+    return 1
+  fi
+
+  local failed=0
+
+  # Top-level fields
+  for field in project phases; do
+    if [[ "$(yq ".${field}" "${file}")" == "null" ]]; then
+      _err "missing top-level field: ${field}"
+      failed=$((failed + 1))
+    fi
+  done
+
+  # Phase fields
+  local phase_count
+  phase_count=$(yq '.phases | length' "${file}")
+  local i
+  for ((i = 0; i < phase_count; i++)); do
+    for field in id name goal gate_criteria tasks; do
+      if [[ "$(yq ".phases[${i}].${field}" "${file}")" == "null" ]]; then
+        _err "phase ${i}: missing field '${field}'"
+        failed=$((failed + 1))
+      fi
+    done
+  done
+
+  # Task fields + XL check + collect ids/deps for DAG check
+  local all_ids=()
+  local all_deps=()
+
+  for ((i = 0; i < phase_count; i++)); do
+    local task_count
+    task_count=$(yq ".phases[${i}].tasks | length" "${file}")
+    local j
+    for ((j = 0; j < task_count; j++)); do
+      local prefix=".phases[${i}].tasks[${j}]"
+
+      for field in id title type priority depends_on estimate owner_type acceptance; do
+        if [[ "$(yq "${prefix}.${field}" "${file}")" == "null" ]]; then
+          _err "task ${prefix}: missing field '${field}'"
+          failed=$((failed + 1))
+        fi
+      done
+
+      local estimate
+      estimate=$(yq "${prefix}.estimate" "${file}")
+      if [[ "${estimate}" == "XL" ]]; then
+        _err "task $(yq "${prefix}.id" "${file}"): XL estimates are not allowed — split it"
+        failed=$((failed + 1))
+      fi
+
+      local task_id
+      task_id=$(yq "${prefix}.id" "${file}")
+      all_ids+=("${task_id}")
+
+      local dep_count
+      dep_count=$(yq "${prefix}.depends_on | length // 0" "${file}")
+      local k
+      for ((k = 0; k < dep_count; k++)); do
+        local dep
+        dep=$(yq "${prefix}.depends_on[${k}]" "${file}")
+        all_deps+=("${task_id}:${dep}")
+      done
+    done
+  done
+
+  # DAG cycle check via Kahn's algorithm
+  if [[ ${#all_deps[@]} -gt 0 ]]; then
+    if ! _check_dag "${all_ids[@]}" "--" "${all_deps[@]}"; then
+      _err "dependency graph contains a cycle"
+      failed=$((failed + 1))
+    fi
+  fi
+
+  if [[ ${failed} -eq 0 ]]; then
+    _log "✓ phases.yaml valid (DAG, all required fields present, no XL)"
+  fi
+  return ${failed}
+}
+
+# ──────────────────────────────────────────────
+# _check_dag NODES... -- EDGES (each as "from:to" meaning from depends on to)
+# Returns 0 if DAG, 1 if cycle detected.
+# ──────────────────────────────────────────────
+_check_dag() {
+  local sep=0
+  local -a nodes=()
+  local -a edges=()
+  local arg
+  for arg in "$@"; do
+    if [[ "${arg}" == "--" ]]; then sep=1; continue; fi
+    if [[ ${sep} -eq 0 ]]; then nodes+=("${arg}"); else edges+=("${arg}"); fi
+  done
+
+  # Use Python for the cycle check — simpler than pure bash for graphs.
+  python3 - "${nodes[@]}" "${#nodes[@]}" "${edges[@]}" <<'PY'
+import sys
+from collections import defaultdict
+
+argv = sys.argv[1:]
+n = int(argv[len(argv) - 1 - len([a for a in argv if ':' in a])])
+# Reconstruct: nodes are the first n args, then count, then edges.
+# Simpler: split by ':' to find edges.
+nodes = []
+edges = []
+i = 0
+while i < len(argv):
+    a = argv[i]
+    if a.isdigit() and i + 1 < len(argv) and ':' in argv[i + 1]:
+        i += 1
+        while i < len(argv):
+            edges.append(argv[i])
+            i += 1
+        break
+    else:
+        nodes.append(a)
+        i += 1
+
+graph = defaultdict(list)
+in_degree = {n: 0 for n in nodes}
+for e in edges:
+    if ':' not in e: continue
+    src, dst = e.split(':', 1)
+    if src in in_degree and dst in in_degree:
+        graph[dst].append(src)  # dependency: src depends on dst, so dst → src
+        in_degree[src] += 1
+
+queue = [n for n, d in in_degree.items() if d == 0]
+visited = 0
+while queue:
+    node = queue.pop()
+    visited += 1
+    for nxt in graph[node]:
+        in_degree[nxt] -= 1
+        if in_degree[nxt] == 0:
+            queue.append(nxt)
+
+sys.exit(0 if visited == len(nodes) else 1)
+PY
+}

package/lib/worktree-helpers.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+# worktree-helpers.sh — git worktree wrappers used by /pickup-task.
+#
+# Layout:
+#   ~/repos/{project}/                      ← main checkout (dev branch)
+#   ~/repos/{project}-worktrees/{TICKET}/   ← per-task worktrees
+#
+# Source this file: `source "${FORGE_DIR}/lib/worktree-helpers.sh"`
+
+set -euo pipefail
+
+# ──────────────────────────────────────────────
+# Logging
+# ──────────────────────────────────────────────
+_log()  { printf '\033[1;32m[worktree]\033[0m %s\n' "$*" >&2; }
+_warn() { printf '\033[1;33m[worktree]\033[0m %s\n' "$*" >&2; }
+_err()  { printf '\033[1;31m[worktree]\033[0m %s\n' "$*" >&2; }
+
+# ──────────────────────────────────────────────
+# worktree_path PROJECT TICKET_ID
+# Echoes the canonical worktree path for a ticket.
+# ──────────────────────────────────────────────
+worktree_path() {
+  local project="${1:?project required}"
+  local ticket="${2:?ticket required}"
+  echo "../${project}-worktrees/${ticket}"
+}
+
+# ──────────────────────────────────────────────
+# worktree_create TICKET_ID BRANCH [BASE_BRANCH=dev]
+# Creates a new worktree at ../${project}-worktrees/${TICKET_ID} on
+# branch BRANCH, branched from BASE_BRANCH. Idempotent.
+# ──────────────────────────────────────────────
+worktree_create() {
+  local ticket="${1:?ticket required}"
+  local branch="${2:?branch required}"
+  local base="${3:-dev}"
+
+  if ! git rev-parse --is-inside-work-tree >/dev/null 2>&1; then
+    _err "not inside a git repo"
+    return 1
+  fi
+
+  local project
+  project=$(basename "$(git rev-parse --show-toplevel)")
+  local target
+  target=$(worktree_path "${project}" "${ticket}")
+
+  if [[ -d "${target}" ]]; then
+    _warn "worktree already exists at ${target}"
+    return 0
+  fi
+
+  # Ensure base branch exists locally
+  if ! git rev-parse --verify "${base}" >/dev/null 2>&1; then
+    _err "base branch '${base}' does not exist locally"
+    return 1
+  fi
+
+  _log "Creating worktree: ${target} (branch ${branch} from ${base})"
+  git worktree add "${target}" -b "${branch}" "${base}"
+  _log "✓ worktree ready: cd ${target}"
+}
+
+# ──────────────────────────────────────────────
+# worktree_list
+# Lists all worktrees with their branch and HEAD.
+# ──────────────────────────────────────────────
+worktree_list() {
+  git worktree list --porcelain | awk '
+    /^worktree / {wt=$2}
+    /^branch / {br=$2}
+    /^HEAD / {hd=substr($2, 1, 8)}
+    /^$/ {if (wt) printf "  %-40s  %-30s  %s\n", wt, br, hd; wt=""; br=""; hd=""}
+    END {if (wt) printf "  %-40s  %-30s  %s\n", wt, br, hd}
+  '
+}
+
+# ──────────────────────────────────────────────
+# worktree_remove TICKET_ID
+# Removes the worktree for a ticket. Refuses if uncommitted changes exist.
+# ──────────────────────────────────────────────
+worktree_remove() {
+  local ticket="${1:?ticket required}"
+
+  local project
+  project=$(basename "$(git rev-parse --show-toplevel)")
+  local target
+  target=$(worktree_path "${project}" "${ticket}")
+
+  if [[ ! -d "${target}" ]]; then
+    _warn "worktree does not exist: ${target}"
+    return 0
+  fi
+
+  _log "Removing worktree: ${target}"
+  git worktree remove "${target}"
+  _log "✓ removed"
+}
+
+# ──────────────────────────────────────────────
+# worktree_cleanup
+# Removes worktrees whose branch has been deleted upstream or merged.
+# Dry-run by default; pass --apply to actually remove.
+# ──────────────────────────────────────────────
+worktree_cleanup() {
+  local apply="${1:-}"
+
+  git worktree prune
+
+  local removed=0
+  while IFS= read -r line; do
+    local wt branch
+    wt=$(echo "${line}" | awk '{print $1}')
+    branch=$(echo "${line}" | sed -n 's/.*\[\(.*\)\].*/\1/p')
+
+    [[ -z "${branch}" ]] && continue
+    [[ "${wt}" == "$(git rev-parse --show-toplevel)" ]] && continue
+
+    # If branch is gone upstream
+    if ! git ls-remote --exit-code --heads origin "${branch}" >/dev/null 2>&1; then
+      if [[ "${apply}" == "--apply" ]]; then
+        _log "Removing ${wt} (branch ${branch} gone upstream)"
+        git worktree remove "${wt}" --force
+        git branch -D "${branch}" 2>/dev/null || true
+      else
+        _warn "[dry-run] would remove: ${wt} (branch ${branch} gone)"
+      fi
+      removed=$((removed + 1))
+    fi
+  done < <(git worktree list)
+
+  if [[ "${apply}" != "--apply" && ${removed} -gt 0 ]]; then
+    echo "Run with --apply to actually remove" >&2
+  fi
+}