pantheon-opencode 1.0.0

package/scripts/validate-routing.mjs

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+/**
+ * validate-routing.mjs — Validate routing.yml consistency
+ *
+ * Checks:
+ * - All 18 canonical agents present in routing.yml
+ * - All routing.yml agents have canonical files
+ * - Skills referenced exist in skills/
+ * - Handoffs reference valid agents
+ * - Routing matrix references valid agents
+ *
+ * Usage:
+ *   node scripts/validate-routing.mjs
+ *   node scripts/validate-routing.mjs --verbose   # show all entries checked
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import yaml from 'js-yaml'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const ROOT = join(__dirname, '..')
+
+const VERBOSE = process.argv.includes('--verbose')
+
+let exitCode = 0
+let checks = 0
+let failures = 0
+
+function check(condition, message) {
+  checks++
+  if (!condition) {
+    console.error(`  ❌ ${message}`)
+    failures++
+    exitCode = 1
+  } else if (VERBOSE) {
+    console.log(`  ✅ ${message}`)
+  }
+}
+
+function warn(message) {
+  console.warn(`  ⚠️  ${message}`)
+}
+
+// Load routing.yml
+const routingPath = join(ROOT, 'routing.yml')
+if (!existsSync(routingPath)) {
+  console.error('❌ routing.yml not found')
+  process.exit(1)
+}
+const routing = yaml.load(readFileSync(routingPath, 'utf8'))
+
+console.log('🔍 Validating routing.yml...\n')
+
+// A1. Agents in routing.yml must have canonical files
+const routingAgents = Object.keys(routing.agents || {})
+console.log(`  Agents in routing.yml: ${routingAgents.length}`)
+
+// Get canonical agent files
+const agentsDir = join(ROOT, 'agents')
+const canonicalFiles = readdirSync(agentsDir)
+  .filter((f) => f.endsWith('.agent.md'))
+  .map((f) => f.replace('.agent.md', ''))
+  .sort()
+
+console.log(`  Canonical agent files: ${canonicalFiles.length}`)
+
+for (const name of routingAgents) {
+  if (name === 'zen' || name === 'zeus_copilot') continue // legacy aliases, skip
+  check(canonicalFiles.includes(name), `Agent "${name}" in routing.yml has no canonical file`)
+}
+
+// A2. Canonical files must be in routing.yml
+for (const name of canonicalFiles) {
+  check(routingAgents.includes(name), `Canonical agent "${name}" missing from routing.yml`)
+}
+
+// B. Skill validation
+const skillsDir = join(ROOT, 'skills')
+const existingSkills = existsSync(skillsDir)
+  ? readdirSync(skillsDir).filter((d) => {
+      const skillDir = join(skillsDir, d)
+      try {
+        return existsSync(join(skillDir, 'SKILL.md'))
+      } catch {
+        return false
+      }
+    })
+  : []
+
+console.log(`\n  Skills in skills/: ${existingSkills.length}`)
+
+for (const [name, info] of Object.entries(routing.agents || {})) {
+  const agentSkills = info.skills || []
+  for (const skill of agentSkills) {
+    if (!existingSkills.includes(skill)) {
+      warn(`Agent "${name}" references skill "${skill}" but skills/${skill}/SKILL.md not found`)
+    }
+  }
+}
+
+// C. Handoff validation
+console.log(
+  `\n  Handoff definitions: ${Object.keys(routing.handoffs || {}).length} agents with handoffs`,
+)
+
+for (const [agentName, handoffs] of Object.entries(routing.handoffs || {})) {
+  for (const [key, handoff] of Object.entries(handoffs)) {
+    // Skip if handoff is just a string (auto-generated)
+    if (typeof handoff !== 'object') continue
+    const targetAgent = handoff.agent
+    check(
+      routingAgents.includes(targetAgent),
+      `Handoff "${agentName}/${key}" references unknown agent "${targetAgent}"`,
+    )
+  }
+}
+
+// D. Routing matrix validation
+console.log(`\n  Routing matrix entries: ${(routing.routing_matrix || []).length}`)
+
+for (const entry of routing.routing_matrix || []) {
+  check(
+    routingAgents.includes(entry.primary_agent),
+    `Routing matrix "${entry.category}" references unknown primary agent "${entry.primary_agent}"`,
+  )
+
+  for (const parallel of entry.parallel_with || []) {
+    check(
+      routingAgents.includes(parallel),
+      `Routing matrix "${entry.category}" references unknown parallel agent "${parallel}"`,
+    )
+  }
+}
+
+// E. Subagent delegation validation
+console.log(`\n  Subagent delegation rules:`)
+
+for (const [name, info] of Object.entries(routing.agents || {})) {
+  const delegates = info.subagent_can_delegate_to || []
+  for (const target of delegates) {
+    check(
+      routingAgents.includes(target),
+      `Agent "${name}" can delegate to unknown agent "${target}"`,
+    )
+  }
+}
+
+// Summary
+console.log(`\n${'='.repeat(50)}`)
+const status = failures === 0 ? '✅ PASSED' : `❌ FAILED (${failures}/${checks} checks failed)`
+console.log(` ${status}`)
+console.log(` ${checks} total checks${VERBOSE ? ', see verbose output above' : ''}`)
+if (!VERBOSE && failures > 0) {
+  console.log(' Run with --verbose to see all passing checks.')
+}
+console.log('')
+
+process.exit(exitCode)

package/scripts/validate_agent_frontmatter.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""Validate all OpenCode agent .md files for correct frontmatter."""
+
+import sys
+from pathlib import Path
+
+import yaml
+
+VALID_FIELDS = {
+    "description",
+    "mode",
+    "reasoning_effort",
+    "permission",
+    "temperature",
+    "steps",
+    "color",
+    "hidden",
+    "task_budget",
+    "source",
+}
+VALID_MODES = {"primary", "subagent"}
+VALID_PERMISSION_KEYS = {
+    "edit",
+    "bash",
+    "task",
+    "skill",
+    "read",
+    "glob",
+    "grep",
+    "webfetch",
+    "websearch",
+    "question",
+    "lsp",
+}
+VALID_PERMISSION_VALUES = {"allow", "deny", "ask"}
+
+AGENT_DIRS = [
+    Path("/home/ils15/pantheon/platform/opencode/agents"),
+    Path("/home/ils15/.config/opencode/agents"),
+]
+
+errors = []
+warnings = []
+valid_count = 0
+
+
+def err(filename, field, msg):
+    errors.append(f"❌ [{filename}] {field}: {msg}")
+
+
+def warn(filename, field, msg):
+    warnings.append(f"⚠️  [{filename}] {field}: {msg}")
+
+
+def validate_permission_value(val, path_ctx, filename):
+    if isinstance(val, str):
+        if val not in VALID_PERMISSION_VALUES:
+            err(
+                filename,
+                f"permission.{path_ctx}",
+                f"invalid value '{val}'; must be one of {sorted(VALID_PERMISSION_VALUES)}",
+            )
+    elif isinstance(val, dict):
+        for key, subval in val.items():
+            validate_permission_value(subval, f"{path_ctx}.{key}", filename)
+    else:
+        err(
+            filename,
+            f"permission.{path_ctx}",
+            f"unexpected type '{type(val).__name__}'; expected string or dict",
+        )
+
+
+def validate_file(filepath):  # noqa: C901, PLR0912, PLR0915
+    global valid_count  # noqa: PLW0603
+    filename = filepath.name
+    text = filepath.read_text(encoding="utf-8")
+
+    if not text.startswith("---"):
+        err(filename, "frontmatter", "file does not start with '---'")
+        return
+
+    parts = text.split("---")
+    if len(parts) < 3:  # noqa: PLR2004
+        err(filename, "frontmatter", "missing closing '---' delimiter")
+        return
+
+    raw_yaml = parts[1]
+    try:
+        data = yaml.safe_load(raw_yaml)
+    except yaml.YAMLError as e:
+        err(filename, "frontmatter", f"YAML parse error: {e}")
+        return
+
+    if not isinstance(data, dict):
+        err(filename, "frontmatter", "frontmatter is not a mapping")
+        return
+
+    # Check for unknown fields
+    unknown = set(data.keys()) - VALID_FIELDS
+    for field in sorted(unknown):
+        err(filename, field, f"unknown field '{field}'; valid: {sorted(VALID_FIELDS)}")
+
+    # description: must be present
+    if "description" not in data:
+        err(filename, "description", "description field is required")
+    elif not isinstance(data["description"], str) or not data["description"].strip():
+        err(filename, "description", "must be a non-empty string")
+
+    # mode: must be present and valid
+    if "mode" not in data:
+        err(filename, "mode", "mode field is required")
+    elif data["mode"] not in VALID_MODES:
+        err(
+            filename,
+            "mode",
+            f"invalid value '{data['mode']}'; must be one of {sorted(VALID_MODES)}",
+        )
+
+    # permission: validate keys and values
+    if "permission" in data:
+        perm = data["permission"]
+        if isinstance(perm, dict):
+            for key in perm:
+                if key not in VALID_PERMISSION_KEYS:
+                    err(
+                        filename,
+                        f"permission.{key}",
+                        f"invalid permission key '{key}'; valid: {sorted(VALID_PERMISSION_KEYS)}",
+                    )
+                validate_permission_value(perm[key], key, filename)
+        else:
+            err(
+                filename,
+                "permission",
+                f"unexpected type '{type(perm).__name__}'; expected mapping",
+            )
+
+    # temperature: between 0.0 and 2.0
+    if "temperature" in data:
+        t = data["temperature"]
+        if not isinstance(t, (int, float)):
+            err(filename, "temperature", f"expected a number, got '{type(t).__name__}'")
+        elif t < 0.0 or t > 2.0:  # noqa: PLR2004
+            err(filename, "temperature", f"value {t} is out of range [0.0, 2.0]")
+
+    # steps: must be a positive integer
+    if "steps" in data:
+        s = data["steps"]
+        if not isinstance(s, int) or isinstance(s, bool):
+            err(
+                filename,
+                "steps",
+                f"expected a positive integer, got '{type(s).__name__}'",
+            )
+        elif s < 1:
+            err(filename, "steps", f"value {s} is not a positive integer")
+
+    # Body content checks
+    body = "---".join(parts[2:])
+
+    bash_value = None
+    if isinstance(data.get("permission"), dict):
+        bash_value = data["permission"].get("bash")
+
+    if bash_value == "deny":
+        if "⛔ TOOLS NOT AVAILABLE" not in body:
+            err(
+                filename,
+                "body",
+                "permission.bash is 'deny' but body is missing '## ⛔ TOOLS NOT AVAILABLE' section",
+            )
+        elif "bash" not in body.split("⛔ TOOLS NOT AVAILABLE")[1].split("\n")[0:20]:
+            warn(
+                filename,
+                "body",
+                "permission.bash is 'deny' but 'bash' may not be listed as unavailable in the section",
+            )
+
+    edit_value = None
+    if isinstance(data.get("permission"), dict):
+        edit_value = data["permission"].get("edit")
+
+    if edit_value == "deny":
+        edit_mentions = body.lower().count("edit")
+        if edit_mentions > 0:
+            warn(
+                filename,
+                "body",
+                f"permission.edit is 'deny' but 'edit' appears {edit_mentions} time(s) in body",
+            )
+
+    valid_count += 1
+
+
+def main():
+    all_files = []
+    for d in AGENT_DIRS:
+        if not d.exists():
+            print(f"⚠️  Config error: directory not found: {d}", file=sys.stderr)
+            sys.exit(2)
+        all_files.extend(sorted(d.glob("*.md")))
+
+    if not all_files:
+        print("⚠️  Config error: no agent .md files found", file=sys.stderr)
+        sys.exit(2)
+
+    for f in all_files:
+        validate_file(f)
+
+    for msg in errors:
+        print(msg, file=sys.stderr)
+    for msg in warnings:
+        print(msg, file=sys.stderr)
+
+    print(
+        f"✅ {valid_count} files valid, {len(warnings)} warnings, {len(errors)} errors"
+    )
+
+    if errors:
+        sys.exit(1)
+    sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/versioning.mjs

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+/**
+ * versioning.mjs — Pantheon release versioning helper
+ *
+ * Commands:
+ *   recommend            Analyze commits and suggest next version bump type
+ *   apply [type]         Bump manifests + move [Unreleased] → [vX.Y.Z] in CHANGELOG
+ *                        type: patch | minor | major | auto (default: auto)
+ *   changelog [ver]      (Internal) Insert a versioned section into CHANGELOG
+ *                        Normally called by `apply`; can be run standalone.
+ *   status               Show current version, latest tag, and pending bump type
+ *
+ * Design: the release signal is "package.json version > latest git tag".
+ * Developers (or AI agents) call `apply` to bump + update CHANGELOG, then push.
+ * The auto-release workflow detects the version bump and creates the release.
+ * No version bumping ever happens inside GitHub Actions.
+ */
+
+import { execSync } from 'node:child_process'
+import { readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const ROOT = join(__dirname, '..')
+
+const MANIFEST_FILES = [
+  'platform/forge.json',
+  'pyproject.toml',
+  'package.json',
+  'plugin.json',
+  '.github/plugin/plugin.json',
+]
+
+const CHANGELOG_PATH = join(ROOT, 'CHANGELOG.md')
+
+// ---------------------------------------------------------------------------
+// Git helpers
+// ---------------------------------------------------------------------------
+
+function run(cmd) {
+  try {
+    return execSync(cmd, { cwd: ROOT, encoding: 'utf-8' }).trim()
+  } catch {
+    return ''
+  }
+}
+
+function getLatestTag() {
+  // Use numerically highest tag, not just nearest git ancestor
+  const tag = run("git tag -l 'v[0-9]*.[0-9]*.[0-9]*' | sort -V | tail -1")
+  return tag || 'v0.0.0'
+}
+
+function getCurrentVersion() {
+  return JSON.parse(readFileSync(join(ROOT, 'package.json'), 'utf-8')).version
+}
+
+// ---------------------------------------------------------------------------
+// Semver helpers
+// ---------------------------------------------------------------------------
+
+function bumpVersion(version, type) {
+  const [major, minor, patch] = version.split('.').map(Number)
+  switch (type) {
+    case 'major':
+      return `${major + 1}.0.0`
+    case 'minor':
+      return `${major}.${minor + 1}.0`
+    default:
+      return `${major}.${minor}.${patch + 1}`
+  }
+}
+
+function analyzeConventionalCommits(since) {
+  const log = run(`git log ${since}..HEAD --format="%s"`)
+  if (!log) return 'patch'
+  let bump = 'patch'
+  for (const msg of log.split('\n').filter(Boolean)) {
+    if (/BREAKING CHANGE/i.test(msg) || /^[a-z]+!/i.test(msg)) return 'major'
+    if (/^feat/i.test(msg)) bump = 'minor'
+  }
+  return bump
+}
+
+// ---------------------------------------------------------------------------
+// Manifest updater
+// ---------------------------------------------------------------------------
+
+function updateManifests(newVersion) {
+  for (const file of MANIFEST_FILES) {
+    const path = join(ROOT, file)
+    try {
+      const raw = readFileSync(path, 'utf-8')
+      if (file.endsWith('.toml')) {
+        // TOML: replace version = "X.Y.Z"
+        const updated = raw.replace(/^(version\s*=\s*")[^"]+(")/m, `$1${newVersion}$2`)
+        writeFileSync(path, updated)
+        console.log(`  ✓ ${file} → ${newVersion}`)
+      } else {
+        // JSON
+        const content = JSON.parse(raw)
+        content.version = newVersion
+        writeFileSync(path, `${JSON.stringify(content, null, 2)}\n`)
+        console.log(`  ✓ ${file} → ${newVersion}`)
+      }
+    } catch {
+      console.log(`  ⚠ ${file} not found — skipped`)
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// CHANGELOG updater
+//
+// Finds the [Unreleased] section and:
+//   1. Strips empty subsections (### Added\n\n### Changed...)
+//   2. Renames [Unreleased] → [vX.Y.Z] - date
+//   3. Inserts a fresh empty [Unreleased] template above it
+// ---------------------------------------------------------------------------
+
+function promoteUnreleased(newVersion, dateStr) {
+  const content = readFileSync(CHANGELOG_PATH, 'utf-8')
+
+  const unreleasedHeader = '## [Unreleased]'
+  const idx = content.indexOf(unreleasedHeader)
+  if (idx === -1) {
+    console.log('  ⚠ [Unreleased] section not found in CHANGELOG — skipping')
+    return false
+  }
+
+  // Find the end of [Unreleased]: next ## header or end of file
+  const afterHeader = idx + unreleasedHeader.length
+  const nextSectionIdx = content.indexOf('\n## [', afterHeader)
+  const unreleasedBody =
+    nextSectionIdx === -1 ? content.slice(afterHeader) : content.slice(afterHeader, nextSectionIdx)
+
+  // Check if the [Unreleased] section has any real content (non-empty lines
+  // that aren't just section headers or comments)
+  const realLines = unreleasedBody
+    .split('\n')
+    .filter((l) => l.trim() && !l.startsWith('###') && !l.startsWith('<!--'))
+
+  if (realLines.length === 0) {
+    console.log('  ℹ [Unreleased] is empty — CHANGELOG not modified')
+    return false
+  }
+
+  // Strip lines that are just empty subsections (### X followed by blank line
+  // then another ### or end)
+  const cleanedBody = unreleasedBody
+    .replace(/\n### \w[^\n]*\n(\n(?=###|\n## |\n$))+/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trimEnd()
+
+  const newTemplate = `\n\n<!-- Add new changes here. Running \`node scripts/versioning.mjs apply\` will\n     move this section to a versioned entry and reset the template below. -->\n\n### Added\n\n### Changed\n\n### Fixed\n\n### Removed`
+  const newVersionHeader = `## [v${newVersion}] - ${dateStr}`
+
+  const before = content.slice(0, idx)
+  const after = nextSectionIdx === -1 ? '' : content.slice(nextSectionIdx)
+
+  const updated = `${before + unreleasedHeader + newTemplate}\n\n${newVersionHeader}${cleanedBody}${after}`
+
+  writeFileSync(CHANGELOG_PATH, updated)
+  console.log(`  ✓ CHANGELOG: [Unreleased] → [v${newVersion}]`)
+  return true
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+const command = process.argv[2]
+const arg = process.argv[3]
+
+switch (command) {
+  case 'status': {
+    const latestTag = getLatestTag()
+    const current = getCurrentVersion()
+    const latestVer = latestTag.replace(/^v/, '')
+    const bump = analyzeConventionalCommits(latestTag)
+    const next = bumpVersion(current, bump)
+    const needsRelease = current !== latestVer
+
+    console.log(`Current version  : ${current}`)
+    console.log(`Latest git tag   : ${latestTag}`)
+    console.log(
+      `Release pending  : ${needsRelease ? `YES — tag ${latestTag} < pkg ${current}` : 'NO — already tagged'}`,
+    )
+    console.log(`Recommended bump : ${bump}`)
+    console.log(`Next version     : ${next}`)
+    break
+  }
+
+  case 'recommend': {
+    const latestTag = getLatestTag()
+    const bump = analyzeConventionalCommits(latestTag)
+    const current = getCurrentVersion()
+    console.log(bumpVersion(current, bump))
+    break
+  }
+
+  case 'apply': {
+    const type = arg || 'auto'
+    const latestTag = getLatestTag()
+    const current = getCurrentVersion()
+    const latestVer = latestTag.replace(/^v/, '')
+
+    // If package.json is already ahead of the latest tag, someone bumped
+    // without tagging — warn and use the current version as-is.
+    if (current !== latestVer) {
+      console.log(`⚠ package.json (${current}) already ahead of latest tag (${latestTag}).`)
+      console.log(`  Syncing all manifests to ${current} and promoting CHANGELOG.`)
+      updateManifests(current)
+      const date = new Date().toISOString().slice(0, 10)
+      promoteUnreleased(current, date)
+      break
+    }
+
+    const bumpType = type === 'auto' ? analyzeConventionalCommits(latestTag) : type
+    const newVersion = bumpVersion(current, bumpType)
+    const date = new Date().toISOString().slice(0, 10)
+
+    console.log(`Bumping ${current} → ${newVersion} (${bumpType})`)
+    updateManifests(newVersion)
+    promoteUnreleased(newVersion, date)
+    console.log(`\nDone. Commit with: git add -A && git commit -m "chore(release): v${newVersion}"`)
+    break
+  }
+
+  // Legacy standalone command — kept for backward compat
+  case 'changelog': {
+    const version = arg || getCurrentVersion()
+    const date = new Date().toISOString().slice(0, 10)
+    promoteUnreleased(version, date)
+    break
+  }
+
+  default:
+    console.log(`Usage: node scripts/versioning.mjs <command>
+
+Commands:
+  status               Show current version, latest tag, release status
+  recommend            Print recommended bump type (patch/minor/major)
+  apply [type]         Bump manifests + move [Unreleased] → [vX.Y.Z]
+                       type: patch | minor | major | auto (default: auto)
+  changelog [version]  Promote [Unreleased] → [vX.Y.Z] without bumping
+
+Release flow:
+  1. node scripts/versioning.mjs apply [minor]
+  2. git add -A && git commit -m "chore(release): vX.Y.Z"
+  3. git push     ← CI passes → auto-release fires because pkg > tag
+`)
+}

package/skills-lock.json

@@ -0,0 +1,16 @@
+{
+  "src/skills/agent-coordination/SKILL.md": "cfd040ef29e3dd0fd5e0e67773874facf7c06e3284898afe1fddba4456c3f1aa",
+  "src/skills/artifact-management/SKILL.md": "c60e493666bedf46e9113d0dd20106489d5c5a73905e1370fcfc1c0d71c59185",
+  "src/skills/auto-continue/SKILL.md": "791b7f8d981bca571a6350cfd0f7f623ab8d9c2190b015dc63c15f8663b25e53",
+  "src/skills/code-review-checklist/SKILL.md": "0e59367c65ef4608db80a0674279f32cfc3f67dca7236f233b61a47fe506579f",
+  "src/skills/context-compression/SKILL.md": "07cfddfedeb8087794ae49ef8e60d8adca3ec2342d592cc30d0407d1b8ab1b90",
+  "src/skills/git-workflow-and-versioning/SKILL.md": "685a94041f1b4ce2a430301f517b89102055696267c369a7e8fb191606659276",
+  "src/skills/incremental-implementation/SKILL.md": "7065ddb45da3c6b6751de07f290e92e6cb072e949a2e3aaae13ee7762f0a70fc",
+  "src/skills/memory-bank/SKILL.md": "4717cf18b43550c9f02cfab810968b97a5b2584f00a15516ecba643c80cdc110",
+  "src/skills/orchestration-workflow/SKILL.md": "0eeabaf71a802d1f673f79996548cda2d394bbcc7c62eaca03482d3fa99be688",
+  "src/skills/security-hardening/SKILL.md": "6d637e122421f7bc3b751f04854ad343a5a5d35249458bc8939233138fd3f20d",
+  "src/skills/session-goal/SKILL.md": "793498265f70253c20524f6adc88bcc86db11d7160fe8232a26aedc6b1c5489f",
+  "src/skills/spec-driven-development/SKILL.md": "e93b9103d6cd1848ab01328efde82c1daf564d1cabbdc2278254b346fcf55d02",
+  "src/skills/tdd-with-agents/SKILL.md": "9880919a46b74f549f948147d8b086b008635de94fa259f76261d067772bb8e3",
+  "src/skills/visual-review-pipeline/SKILL.md": "f6e65ff75a9325c38e0e9dde8e87f09b873e14e490936ef48aa80201bb68fe10"
+}