@1aboveio/skills 0.17.0 → 0.19.0

package/skills/engineering/rush-release/scripts/plan.mjs

@@ -0,0 +1,264 @@
+#!/usr/bin/env node
+// Changelog + SemVer plan from baseline tag..SHA.
+//
+// Usage:
+//   node plan.mjs --sha <sha> [--trunk main] [--json] [--strict]
+//
+// Exit: 0 ok · 1 git/inspect failed · 2 usage
+import { existsSync, readFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { spawnSync } from 'node:child_process'
+import { isMainModule } from '../../engineering-runtime/scripts/main-module.mjs'
+
+const SEMVER_RE = /^v?(\d+)\.(\d+)\.(\d+)$/
+const TITLE_RE = /^\s*([a-zA-Z]+)(?:\(([^)]*)\))?(!)?:\s*(.+)$/
+const SECTION_BY_TYPE = {
+  feat: 'Added',
+  fix: 'Fixed',
+  perf: 'Changed',
+  refactor: 'Changed',
+  revert: 'Removed',
+  security: 'Security',
+}
+const INTERNAL_TYPES = new Set(['build', 'chore', 'ci', 'docs', 'style', 'test'])
+const SECTION_ORDER = ['Breaking', 'Added', 'Changed', 'Removed', 'Fixed', 'Security']
+
+export function parseSemver(input) {
+  const match = SEMVER_RE.exec(String(input || '').trim())
+  if (!match) return null
+  return { major: Number(match[1]), minor: Number(match[2]), patch: Number(match[3]) }
+}
+
+export function formatVersion(version) {
+  return `${version.major}.${version.minor}.${version.patch}`
+}
+
+export function compareVersions(left, right) {
+  for (const key of ['major', 'minor', 'patch']) {
+    if (left[key] !== right[key]) return left[key] < right[key] ? -1 : 1
+  }
+  return 0
+}
+
+export function latestReleaseTag(tags) {
+  const parsed = tags
+    .map((tag) => ({ tag, version: parseSemver(tag) }))
+    .filter((item) => item.version)
+  if (parsed.length === 0) return null
+  parsed.sort((left, right) => compareVersions(left.version, right.version))
+  return parsed[parsed.length - 1]
+}
+
+export function classifySubject(subject, body = '') {
+  const title = String(subject || '').trim()
+  const match = TITLE_RE.exec(title)
+  const type = match ? match[1].toLowerCase() : 'other'
+  const breaking = Boolean(match && match[3]) || /(^|\n)BREAKING[ -]CHANGE:/.test(body)
+  const internal = INTERNAL_TYPES.has(type)
+  const section = breaking ? 'Breaking' : internal ? null : (SECTION_BY_TYPE[type] || 'Changed')
+  return {
+    title,
+    type,
+    breaking,
+    internal,
+    section,
+    scope: match ? match[2] || null : null,
+    summary: match ? match[4] : title,
+  }
+}
+
+export function bumpFor(changes, current, { strict = false } = {}) {
+  const zeroVer = !strict && current.major === 0
+  if (changes.some((change) => change.breaking)) {
+    return { bump: zeroVer ? 'minor' : 'major', reason: 'breaking change in the release content' }
+  }
+  if (changes.some((change) => change.type === 'feat')) {
+    return { bump: 'minor', reason: 'new feature in the release content' }
+  }
+  return { bump: 'patch', reason: 'fixes and internal changes only' }
+}
+
+export function nextVersion(current, bump) {
+  if (bump === 'major') return { major: current.major + 1, minor: 0, patch: 0 }
+  if (bump === 'minor') return { major: current.major, minor: current.minor + 1, patch: 0 }
+  return { major: current.major, minor: current.minor, patch: current.patch + 1 }
+}
+
+export function renderChangelog({ version, date, changes }) {
+  const groups = new Map(SECTION_ORDER.map((name) => [name, []]))
+  for (const change of changes) {
+    if (!change.section) continue
+    const list = groups.get(change.section)
+    if (list) list.push(change)
+  }
+  const lines = [`## [${version}] - ${date}`]
+  for (const name of SECTION_ORDER) {
+    const items = groups.get(name)
+    if (!items.length) continue
+    lines.push('', `### ${name}`)
+    for (const item of items) lines.push(`- ${item.summary}`)
+  }
+  if (lines.length === 1) {
+    lines.push('', '- See the commits included in this tag.')
+  }
+  return `${lines.join('\n')}\n`
+}
+
+export function discoverVersionFiles(root) {
+  const files = []
+  for (const name of ['package.json', 'package-lock.json', 'pyproject.toml', 'VERSION']) {
+    if (existsSync(join(root, name))) files.push(name)
+  }
+  return files
+}
+
+export function currentVersionFromFiles(root, files = discoverVersionFiles(root)) {
+  if (files.includes('package.json')) {
+    const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
+    const parsed = parseSemver(pkg.version)
+    if (parsed) return formatVersion(parsed)
+  }
+  if (files.includes('pyproject.toml')) {
+    const text = readFileSync(join(root, 'pyproject.toml'), 'utf8')
+    const match = text.match(/^version\s*=\s*"([^"]+)"/m)
+    const parsed = match && parseSemver(match[1])
+    if (parsed) return formatVersion(parsed)
+  }
+  if (files.includes('VERSION')) {
+    const parsed = parseSemver(readFileSync(join(root, 'VERSION'), 'utf8'))
+    if (parsed) return formatVersion(parsed)
+  }
+  return null
+}
+
+function git(args, cwd) {
+  const result = spawnSync('git', args, { encoding: 'utf8', cwd })
+  if (result.status !== 0) {
+    const err = new Error(result.stderr.trim() || `git ${args.join(' ')} failed`)
+    err.exitCode = 1
+    throw err
+  }
+  return result.stdout
+}
+
+function versionFilesAt(sha, cwd) {
+  const tree = new Set(git(['ls-tree', '-r', '--name-only', sha], cwd)
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean))
+  return ['package.json', 'package-lock.json', 'pyproject.toml', 'VERSION']
+    .filter((name) => tree.has(name))
+}
+
+function versionFromGitFiles(sha, files, cwd) {
+  const contents = (path) => git(['show', `${sha}:${path}`], cwd)
+  if (files.includes('package.json')) {
+    const parsed = parseSemver(JSON.parse(contents('package.json')).version)
+    if (parsed) return formatVersion(parsed)
+  }
+  if (files.includes('pyproject.toml')) {
+    const match = contents('pyproject.toml').match(/^version\s*=\s*"([^"]+)"/m)
+    const parsed = match && parseSemver(match[1])
+    if (parsed) return formatVersion(parsed)
+  }
+  if (files.includes('VERSION')) {
+    const parsed = parseSemver(contents('VERSION'))
+    if (parsed) return formatVersion(parsed)
+  }
+  return null
+}
+
+function parseLog(stdout) {
+  return stdout
+    .split('\u001e')
+    .map((chunk) => chunk.trim())
+    .filter(Boolean)
+    .map((chunk) => {
+      const [subject, ...rest] = chunk.split('\n')
+      return classifySubject(subject, rest.join('\n'))
+    })
+}
+
+export function planRelease({ sha, trunk = 'main', strict = false, cwd = process.cwd(), now = new Date() } = {}) {
+  if (!sha) {
+    const err = new Error('usage: plan.mjs --sha <sha> [--trunk main] [--json] [--strict]')
+    err.exitCode = 2
+    throw err
+  }
+  git(['rev-parse', '--verify', sha], cwd)
+  const tags = git(['tag', '--merged', sha, '--list', 'v*'], cwd)
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((tag) => parseSemver(tag))
+  const baseline = latestReleaseTag(tags)
+  const range = baseline ? `${baseline.tag}..${sha}` : sha
+  const logArgs = baseline
+    ? ['log', range, '--first-parent', '--format=%s%n%b%x1e']
+    : ['log', sha, '--first-parent', '-n', '50', '--format=%s%n%b%x1e']
+  const changes = parseLog(git(logArgs, cwd))
+  const files = versionFilesAt(sha, cwd)
+  const fileVersion = versionFromGitFiles(sha, files, cwd)
+  const current = parseSemver(fileVersion) || baseline?.version || { major: 0, minor: 0, patch: 0 }
+  const { bump, reason } = bumpFor(changes, current, { strict })
+  const next = nextVersion(current, bump)
+  const version = formatVersion(next)
+  const date = now.toISOString().slice(0, 10)
+  return {
+    trunk,
+    sha,
+    baselineTag: baseline?.tag || null,
+    currentVersion: formatVersion(current),
+    bump,
+    reason,
+    nextVersion: version,
+    tag: `v${version}`,
+    versionFiles: files,
+    changes,
+    date,
+    changelogMarkdown: renderChangelog({ version, date, changes }),
+  }
+}
+
+function parseArgs(argv) {
+  const opts = { json: false, strict: false, trunk: 'main', sha: null }
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i]
+    if (arg === '--json') opts.json = true
+    else if (arg === '--strict') opts.strict = true
+    else if (arg === '--sha') opts.sha = argv[++i]
+    else if (arg === '--trunk') opts.trunk = argv[++i]
+    else if (arg === '--help' || arg === '-h') opts.help = true
+    else {
+      const err = new Error(`unknown argument: ${arg}`)
+      err.exitCode = 2
+      throw err
+    }
+  }
+  if (opts.help) return opts
+  if (!opts.sha || !opts.trunk) {
+    const err = new Error('usage: plan.mjs --sha <sha> [--trunk main] [--json] [--strict]')
+    err.exitCode = 2
+    throw err
+  }
+  return opts
+}
+
+export function main(argv = process.argv.slice(2)) {
+  const opts = parseArgs(argv)
+  if (opts.help) {
+    process.stdout.write('plan.mjs --sha <sha> [--trunk main] [--json] [--strict]\n')
+    return 0
+  }
+  const result = planRelease(opts)
+  process.stdout.write(opts.json ? `${JSON.stringify(result, null, 2)}\n` : `${result.tag}\n${result.changelogMarkdown}`)
+  return 0
+}
+
+if (isMainModule(import.meta.url)) {
+  try {
+    process.exitCode = main()
+  } catch (error) {
+    process.stderr.write(`${error.message}\n`)
+    process.exitCode = error.exitCode || 1
+  }
+}

package/skills/fullstack/zod-v4/SKILL.md

@@ -22,7 +22,7 @@ Use these skills by name when the Zod change is part of a larger stack-specific
 - `web-design-guidelines` for UI review after validation-driven form changes
 - `vercel-react-best-practices` for React/Next.js performance-sensitive form patterns
 - `app-debug` for runtime failures caused by validation or payload mismatches
-- `airflow-dag-develop` only when Zod-related config or payload contracts affect DAG tooling
+- `airflow` only when Zod-related config or payload contracts affect DAG tooling
 
 ---
 

package/skills/data-science/airflow-dag-develop/SKILL.md

@@ -1,111 +0,0 @@
----
-name: airflow-dag-develop
-description: Airflow DAG architecture and conventions. Read when designing, creating, or debugging DAGs — covers CLI validation, environment-based scheduling, and pytest integrity tests.
-user-invocable: true
----
-
-# Airflow DAG Development Patterns
-
-## 1. Quick DAG Validation with Airflow CLI
-
-Use these commands for fast feedback during development:
-
-```bash
-# List import errors (fastest check - catches syntax and import issues)
-airflow dags list-import-errors
-
-# Full lint check (comprehensive - catches best practice violations)
-airflow dags lint
-```
-
-**When to use:**
-- `list-import-errors`: During active development for quick syntax/import validation
-- `lint`: Before commits to catch style and best practice issues
-
-## 2. Environment-Based Schedule Override
-
-Disable schedules in local development to prevent accidental runs:
-
-```python
-import os
-from datetime import datetime
-from airflow import DAG
-
-def get_schedule(production_schedule: str) -> str | None:
-    """Return None for local dev, actual schedule for deployed environments.
-
-    Set AIRFLOW_ENV=local in .env for local development.
-    Cloud Run deployments set AIRFLOW_ENV=dev|staging|prod.
-    """
-    env = os.getenv("AIRFLOW_ENV", "local")
-    if env == "local":
-        return None
-    return production_schedule
-```
-
-**Usage in DAG:**
-```python
-with DAG(
-    dag_id="my_dag",
-    schedule=get_schedule("0 4 * * *"),  # Daily 4 AM in prod, None locally
-    start_date=datetime(2024, 1, 1),
-    catchup=False,
-) as dag:
-    ...
-```
-
-**Environment setup:**
-- **Local:** Add `AIRFLOW_ENV=local` to `.env`
-- **Cloud Run:** Set via cloudbuild.yaml substitutions (`_AIRFLOW_ENV: dev|staging|prod`)
-
-## 3. Pytest DAG Integrity Tests
-
-Standard pytest patterns for validating DAG quality:
-
-```python
-# tests/test_dag_integrity.py
-import pytest
-from airflow.models import DagBag
-
-@pytest.fixture(scope="session")
-def dagbag():
-    return DagBag(dag_folder="dags/", include_examples=False)
-
-def test_no_import_errors(dagbag):
-    """Verify all DAGs load without import errors."""
-    assert not dagbag.import_errors, f"DAG import errors: {dagbag.import_errors}"
-
-def test_dags_have_tags(dagbag):
-    """Verify all DAGs have at least one tag for organization."""
-    for dag_id, dag in dagbag.dags.items():
-        assert dag.tags, f"DAG {dag_id} has no tags"
-
-def test_dags_have_owner(dagbag):
-    """Verify all DAGs have an owner in default_args."""
-    for dag_id, dag in dagbag.dags.items():
-        assert dag.default_args.get("owner"), f"DAG {dag_id} missing owner"
-
-def test_no_cycles(dagbag):
-    """Verify DAGs don't have circular dependencies."""
-    for dag_id, dag in dagbag.dags.items():
-        # DagBag already validates this, but explicit test for clarity
-        assert dag.topo_sort(), f"DAG {dag_id} has cycles"
-```
-
-**Run tests:**
-```bash
-# Run all DAG tests
-pytest tests/test_dag_integrity.py -v
-
-# Run specific test
-pytest tests/test_dag_integrity.py::test_no_import_errors -v
-```
-
-## Quick Reference
-
-| Task | Command |
-|------|---------|
-| Check import errors | `airflow dags list-import-errors` |
-| Lint DAGs | `airflow dags lint` |
-| Run integrity tests | `pytest tests/test_dag_integrity.py -v` |
-| Trigger manual run | `airflow dags trigger <dag_id>` |