From 5eb6a6c2d88aa10db6b01a3326ebf77b82fa32b6 Mon Sep 17 00:00:00 2001 From: stewartshea Date: Fri, 22 May 2026 14:02:34 -0400 Subject: [PATCH 1/4] Update terminology in documentation and templates to reflect new vocabulary for AI Agent Guidelines. Replace instances of "CodeBundle" with "Skill Template," "Task" with "Tool," "TaskSet" with "Runbook," and "SLI" with "Monitor." Ensure backward compatibility in API paths and internal identifiers while promoting the new user-facing terms across all documentation, issue templates, and UI components. --- cc-registry-v2/backend/app/utils/__init__.py | 0 .../backend/app/utils/terminology.py | 86 ++++++++ cc-registry-v2/docs/PHASE_2_SKILL_MD.md | 202 ++++++++++++++++++ mcp-server/utils/terminology.py | 69 ++++++ 4 files changed, 357 insertions(+) create mode 100644 cc-registry-v2/backend/app/utils/__init__.py create mode 100644 cc-registry-v2/backend/app/utils/terminology.py create mode 100644 cc-registry-v2/docs/PHASE_2_SKILL_MD.md create mode 100644 mcp-server/utils/terminology.py diff --git a/cc-registry-v2/backend/app/utils/__init__.py b/cc-registry-v2/backend/app/utils/__init__.py new file mode 100644 index 000000000000..e69de29bb2d1 diff --git a/cc-registry-v2/backend/app/utils/terminology.py b/cc-registry-v2/backend/app/utils/terminology.py new file mode 100644 index 000000000000..b1b5499a061e --- /dev/null +++ b/cc-registry-v2/backend/app/utils/terminology.py @@ -0,0 +1,86 @@ +"""Display-label helpers for backend response copy. + +Phase 1 of the cosmetic naming convention realignment (2026) renames the +user-facing surface to align with industry-standard automation + agentic +vocabulary, while leaving every internal identifier (DB columns, JSON +``type`` enum values, MCP tool function names, API paths, class names) +byte-identical to the previous schema. + +Mapping (internal -> display): + Task -> Tool + CodeBundle -> Skill Template + SLI -> Monitor (scheduled, continuous, numeric output) + TaskSet -> Runbook (on-demand, event-triggered, findings) + +Lifecycle distinction: + - A **Skill Template** is the registry-side, parameterised package + (formerly "CodeBundle"). Vars and secrets are unresolved placeholders. + - A **Skill** is the runtime instantiation of a Skill Template inside a + workspace, with vars/secrets materialised against real infrastructure. + The registry itself never holds Skills - only Skill Templates - but + the umbrella word "Skill" is used colloquially in user-facing page + titles and chat copy (e.g. "All Skills") because it reads naturally + and aligns with industry usage (Anthropic Agent Skills, etc.). + +The backend continues to emit ``type: "TaskSet" | "SLI" | "CodeBundle"`` on +``/api/v1/registry/tasks`` for backward compatibility. This module is used +where the backend itself composes human-readable text (chat replies, +OpenAPI descriptions, prompt context blocks) and needs to render the new +display vocabulary. +""" + +from typing import Literal + +InternalType = Literal["TaskSet", "SLI", "CodeBundle"] + +TYPE_LABELS: dict[str, dict[str, str]] = { + "TaskSet": {"singular": "Runbook", "plural": "Runbooks"}, + "SLI": {"singular": "Monitor", "plural": "Monitors"}, + "CodeBundle": {"singular": "Skill Template", "plural": "Skill Templates"}, +} + +CONCEPTS: dict[str, dict[str, str]] = { + "TASK": {"singular": "Tool", "plural": "Tools"}, + "CODEBUNDLE": {"singular": "Skill Template", "plural": "Skill Templates"}, + # Runtime instantiation of a Skill Template (vars/secrets materialised + # inside a workspace). The registry itself only stores Skill Templates, + # but "Skill" is the umbrella word used in user-facing page titles. + "SKILL": {"singular": "Skill", "plural": "Skills"}, + "CODECOLLECTION": {"singular": "CodeCollection", "plural": "CodeCollections"}, + "SLI": {"singular": "Monitor", "plural": "Monitors"}, + "TASKSET": {"singular": "Runbook", "plural": "Runbooks"}, +} + +VOCABULARY_BLOCK = """\ +RunWhen registry vocabulary (2026): +- Tool: an invocable unit (formerly "Task"). +- Skill Template: a reusable, parameterised package of Tools that lives + in the registry (formerly "CodeBundle"). Has placeholder vars and + unresolved secrets. +- Skill: the RUNTIME instantiation of a Skill Template inside a workspace, + with vars/secrets materialised against real infrastructure. The registry + itself only stores Skill Templates; Skills only exist at runtime in a + workspace. The umbrella word "Skill" is used colloquially in page titles + and chat copy (e.g. "All Skills"). +- Monitor: a Tool that runs on a schedule, continuously, in the background + and emits a numeric 0-1 health value (formerly "SLI"). +- Runbook: a Tool that runs on demand in response to an event or request + and emits structured findings with next-steps (formerly "TaskSet"). + +Users may use either vocabulary interchangeably. Internal JSON `type` +values returned by the API remain "TaskSet", "SLI", and "CodeBundle" for +backward compatibility with existing integrations. +""" + + +def label_for_type(type_value: str, plural: bool = False) -> str: + """Resolve a display label for an internal ``type`` value.""" + if type_value in TYPE_LABELS: + return TYPE_LABELS[type_value]["plural" if plural else "singular"] + return type_value + + +def label_with_count(type_value: str, count: int) -> str: + """Return a count-friendly label like ``"Runbook (3)"``.""" + label = label_for_type(type_value, plural=count != 1) + return f"{label} ({count})" diff --git a/cc-registry-v2/docs/PHASE_2_SKILL_MD.md b/cc-registry-v2/docs/PHASE_2_SKILL_MD.md new file mode 100644 index 000000000000..5907bd9ce6f6 --- /dev/null +++ b/cc-registry-v2/docs/PHASE_2_SKILL_MD.md @@ -0,0 +1,202 @@ +# Phase 2 — `SKILL.md` Authoring and Rendering + +> **Status:** Draft outline (Phase 2 of the 2026 terminology realignment). Phase 1 (display-only cosmetic rename) is complete; this document plans the *next* phase, which adds real authoring artifacts to each Skill Template and renders them in the registry. Phase 2 is independent of Phase 1 and can be designed and scheduled separately. + +## Goal + +Adopt the [Anthropic Agent Skills specification](https://agentskills.io/specification) for every Skill Template (formerly "CodeBundle") in the registry. Each Skill Template gains a first-class `SKILL.md` file authored by the codebundle owner; the registry parses, stores, indexes, and renders that file as the canonical "what this Skill Template does, and when to use it" surface for both humans and LLMs. + +## Why a separate phase + +Phase 1 was purely a display-string rename — reversible, zero schema/API churn, low risk. Phase 2 introduces: + +- A new on-disk convention in every external CodeCollection repo (`SKILL.md` per Skill Template). +- A new column (or columns) on the `codebundles` table → migration + reindex. +- Authoring tooling (LLM-assisted starter generator + spec validator). +- A material change to how the chat assistant frames Skill Template descriptions. + +These are non-trivial and benefit from being scheduled, rolled out, and measured on their own cadence. + +## Scope + +### In scope + +1. **Author convention.** Define and document the `SKILL.md` frontmatter + body contract for RunWhen Skill Templates. +2. **Parser.** Extend the sync/parse pipeline to ingest `SKILL.md` alongside `runbook.robot` and `sli.robot`. +3. **Storage.** Add a column for the SKILL.md raw markdown plus a parsed metadata blob. +4. **Indexing.** Include SKILL.md content in vector embeddings so semantic search hits real authored intent (not just auto-generated descriptions). +5. **UI rendering.** Display the SKILL.md body on the Skill Template detail page as the primary descriptive content (above the Tools tabs). +6. **MCP integration.** Return SKILL.md content via `get_codebundle_details` and bias `find_codebundle` toward SKILL.md-rich Skill Templates when relevant. +7. **Authoring tooling.** Optional LLM-assisted generator that reads `meta.yaml` + Robot docstrings and proposes a starter `SKILL.md`; spec validator that runs at indexing time and at PR-CI time. + +### Out of scope (for Phase 2) + +- Renaming MCP tool function names (`find_codebundle` → `find_skill_template`). Still deferred to a future phase. +- Renaming API paths or DB columns. Still deferred. +- Source-repo folder convention changes (`codebundles/` → `skill-templates/` on disk). Still deferred. +- Renaming "CodeCollection" itself. Not planned. + +## Author convention + +Each `codebundles/{slug}/SKILL.md` follows the Anthropic Agent Skills spec, adapted for RunWhen: + +```markdown +--- +name: Azure App Service Health +description: | + Triage an Azure App Service Web App when it's slow, returning 5xx, or failing health probes. + Covers App Service Plan capacity, web app config, application logs, and dependent resources. +allowed-tools: + - RW.CLI + - RW.K8s +platform: azure +support-tags: [azure, appservice, webapp] +when-to-use: | + Use when an Azure App Service Web App reports degraded performance or errors AND you have + Reader access to the resource group containing the app and its plan. +when-not-to-use: | + Don't use for Function Apps or Container Apps — those have dedicated Skill Templates. +--- + +# Azure App Service Health + +## What this Skill Template does + +This Skill Template provides Tools for… + +## Runbooks + +- **App Service Plan Health** — checks CPU/memory pressure and scale events on the underlying Plan. +- **Web App Configuration Audit** — flags risky settings (HTTPS-only off, missing slot settings, expired certs). +- … + +## Monitors + +- **App Service 5xx Rate** — emits a 0-1 health value based on the percentage of 5xx responses over a 10-minute window. + +## Required user variables + +- `RESOURCE_GROUP_NAME` — the Azure Resource Group containing the app. +- `WEB_APP_NAME` — the Web App's name. + +## Required secrets + +- `azure-credentials` + +## Notes + +… +``` + +Decisions to lock down during Phase 2 design: + +| Question | Default | Alternatives | +|---|---|---| +| Frontmatter format | YAML | TOML (Anthropic uses YAML — stay aligned) | +| `name` value relationship to `meta.yaml` `name` | Must match | Could allow override (probably no) | +| Required vs optional sections | `name`, `description`, `when-to-use` required; rest optional | All-optional (weaker contract) | +| Markdown flavor | CommonMark + GitHub tables | Strict CommonMark only | +| Image embedding | Relative paths to repo files | Disallowed (text-only) | +| Max body length | 16 KB suggested, hard cap 64 KB | No cap | + +## Schema changes + +```sql +ALTER TABLE codebundles + ADD COLUMN skill_md_content TEXT, -- raw markdown body (without frontmatter) + ADD COLUMN skill_md_frontmatter JSONB, -- parsed YAML frontmatter + ADD COLUMN skill_md_present BOOLEAN NOT NULL DEFAULT FALSE, + ADD COLUMN skill_md_validation_errors JSONB; -- spec-validator findings, NULL if clean +``` + +Plus a vector table column or sub-document for the embedded skill body. + +Migration plan: + +1. Alembic migration adds the columns with defaults. +2. Backfill is non-blocking: Skill Templates without `SKILL.md` keep their existing auto-generated description as the rendering fallback. +3. No data loss / rollback risk — pure additive change. + +## Parser changes + +`backend/app/tasks/registry_tasks.py` (the parse step in the sync→parse→enhance→embed pipeline) gains: + +1. Detect `SKILL.md` in `codebundles/{slug}/SKILL.md`. +2. Split frontmatter (YAML between `---` fences) from body. +3. Validate frontmatter against a Pydantic `SkillFrontmatter` model. +4. Persist `skill_md_content`, `skill_md_frontmatter`, `skill_md_present`, `skill_md_validation_errors`. +5. Emit a structured log line per Skill Template summarizing parse outcome (used by the dashboards described below). + +## Indexing changes + +Vector embedding pipeline (`backend/app/tasks/indexing_tasks.py`): + +1. When building the embedded text for a Skill Template, prepend the SKILL.md `description` + `when-to-use` + the first ~1.5 KB of body if `skill_md_present` is true. +2. Re-embed any Skill Template whose `skill_md_content` changes (use a content hash to detect drift). +3. Optionally store a second, SKILL.md-only embedding so `find_codebundle` can be biased toward intent matches. + +## UI rendering + +`CodeBundleDetail.tsx` gains a top section: + +- If `skill_md_present` is `true` and no validation errors → render the SKILL.md body via the existing Markdown renderer, above the Tools tabs. +- If validation errors exist → render the body anyway but show a non-blocking warning ("This Skill Template's SKILL.md has 3 validation warnings"). The warning is admin-visible only on the public site. +- If `skill_md_present` is `false` → keep the current auto-generated description as today (no regression). + +Search/list pages get a small badge ("Skill" or a green checkmark icon) on Skill Templates that ship a real `SKILL.md`, so users can spot first-class authored Skill Templates. + +## MCP integration + +- `get_codebundle_details` returns a new `skill_md` field with the parsed content + frontmatter. +- `find_codebundle` and `search_codebundles` rerank to prefer Skill Templates with valid SKILL.md content, breaking ties in favor of authored intent. +- The chat system prompt is amended: "If a Skill Template has a SKILL.md `when-to-use` block, use that to decide whether to recommend it." + +## Authoring tooling + +### LLM-assisted starter generator + +CLI command (lives in `codecollection-devtools` or `cc-registry-v2/scripts/`): + +```bash +generate-skill-md codebundles/azure-appservice-webapp-ops/ +``` + +Reads `meta.yaml`, `runbook.robot`, `sli.robot`, and `README.md` (if any), then calls Azure OpenAI to draft a starter `SKILL.md` matching the spec. The output is **a draft**, never committed automatically — authors review and refine before checking in. + +### Spec validator + +`scripts/validate-skill-md.py` (runs in PR-CI for each codecollection repo, and at indexing time on the server): + +- Parses frontmatter, checks required fields. +- Lints body for: required H2 sections, max length, no absolute image URLs unless allow-listed. +- Emits non-zero exit code only on hard errors (missing required field, malformed YAML). Warnings (over-length section, missing recommended section) are surfaced but don't block. + +## Rollout plan + +| Step | Owner | Gate | +|---|---|---| +| 1. Finalize the SKILL.md contract (frontmatter schema, required sections) | Registry team | Design review | +| 2. Land Alembic migration + parser + indexer changes (server-side, gated by feature flag `SKILL_MD_INGEST_ENABLED`) | Registry team | Migration deploys cleanly to nonprod | +| 3. Ship UI rendering behind a frontend flag | Registry team | UAT on nonprod | +| 4. Pilot: author SKILL.md for **5 high-traffic Skill Templates** (Kubernetes, Azure App Service, AWS EKS, Postgres, GCP Cloud Run) | CodeCollection owners | Author sign-off on pilot pages | +| 5. Enable flags in prod | Registry team + ops | Manual approval | +| 6. Backfill remaining Skill Templates with LLM-assisted starter drafts; owners review and merge | Distributed (per repo) | Tracked via a public dashboard "% of Skill Templates with SKILL.md" | +| 7. Once coverage > 80%, the chat assistant starts preferring SKILL.md `when-to-use` over auto-generated descriptions | Registry team | Coverage threshold met | + +## Success metrics + +- **Coverage:** % of active Skill Templates with a valid SKILL.md. +- **Search quality:** A/B compare `find_codebundle` precision before vs. after SKILL.md is included in embeddings. +- **Chat quality:** Chat-Debug "thumbs up" rate on responses that cite SKILL.md-equipped Skill Templates. +- **Authoring effort:** Median time from "generate starter" to "merged" per Skill Template (rough sense of friction). + +## Open questions + +1. Should `SKILL.md` live at `codebundles/{slug}/SKILL.md` (alongside `runbook.robot`) or at the CodeCollection level (`SKILL.md` per repo)? Default: per Skill Template — matches Anthropic's per-skill granularity. +2. What does `allowed-tools` mean operationally? Just metadata, or do we enforce that the Skill Template only uses the listed RW libraries at runtime? +3. Do we expose a public "SKILL.md only" mode of the registry where each Skill Template is rendered as a portable Anthropic-spec skill package (zip with `SKILL.md` + supporting files) for direct download into Claude? Probably yes — fits the broader "Skill Template" framing. +4. How do we handle multi-language Skill Templates (Robot + Python helper)? The SKILL.md `allowed-tools` enumerates RW libraries, but `tools` in the Anthropic spec usually maps to MCP tools. Need a glossary in the contract. + +--- + +This Phase 2 plan is intentionally lighter than Phase 1 because the heavy semantic work — defining the new vocabulary — is already done. Phase 2 is about *operationalizing* the vocabulary by putting authored skill artifacts inside each Skill Template and surfacing them everywhere the registry communicates with users and agents. diff --git a/mcp-server/utils/terminology.py b/mcp-server/utils/terminology.py new file mode 100644 index 000000000000..b44b742f6aac --- /dev/null +++ b/mcp-server/utils/terminology.py @@ -0,0 +1,69 @@ +"""Display-label helpers for MCP server output text. + +Phase 1 of the cosmetic naming convention realignment (2026) renames the +user-facing surface to align with industry-standard automation + agentic +vocabulary, while leaving every internal identifier (DB columns, JSON +``type`` enum values, MCP tool function names, API paths, class names) +byte-identical to the previous schema. + +Mapping (internal -> display): + Task -> Tool + CodeBundle -> Skill Template + SLI -> Monitor (scheduled, continuous, numeric output) + TaskSet -> Runbook (on-demand, event-triggered, findings) + +Lifecycle distinction: + - A **Skill Template** is the registry-side, parameterised package + (formerly "CodeBundle"). Vars and secrets are unresolved placeholders. + - A **Skill** is the runtime instantiation of a Skill Template inside + a workspace, with vars/secrets materialised against real infra. + The registry only stores Skill Templates; Skills only exist at + runtime in a workspace. "Skill" is used colloquially as an umbrella + term in user-facing copy (e.g. "All Skills" page titles). + +The MCP server consumes the registry's REST API and renders markdown for +LLM consumers. The REST API still returns ``type: "TaskSet" | "SLI" | +"CodeBundle"`` verbatim; this module is what translates those values to +their new display labels in returned markdown. +""" + +from typing import Literal + +InternalType = Literal["TaskSet", "SLI", "CodeBundle"] + +TYPE_LABELS: dict[str, dict[str, str]] = { + "TaskSet": {"singular": "Runbook", "plural": "Runbooks"}, + "SLI": {"singular": "Monitor", "plural": "Monitors"}, + "CodeBundle": {"singular": "Skill Template", "plural": "Skill Templates"}, +} + +CONCEPTS: dict[str, dict[str, str]] = { + "TASK": {"singular": "Tool", "plural": "Tools"}, + "CODEBUNDLE": {"singular": "Skill Template", "plural": "Skill Templates"}, + # Runtime instantiation of a Skill Template (vars/secrets materialised + # inside a workspace). Used colloquially as an umbrella term in page titles. + "SKILL": {"singular": "Skill", "plural": "Skills"}, + "CODECOLLECTION": {"singular": "CodeCollection", "plural": "CodeCollections"}, + "SLI": {"singular": "Monitor", "plural": "Monitors"}, + "TASKSET": {"singular": "Runbook", "plural": "Runbooks"}, +} + + +def label_for_type(type_value: str, plural: bool = False) -> str: + """Resolve a display label for an internal ``type`` value. + + Returns the raw input unchanged if the type is unknown, so debugging + unexpected enum values stays straightforward. + """ + if type_value in TYPE_LABELS: + return TYPE_LABELS[type_value]["plural" if plural else "singular"] + return type_value + + +def label_with_count(type_value: str, count: int) -> str: + """Return a count-friendly label like ``"Runbook (3)"``. + + Pluralises automatically when ``count`` is not 1. + """ + label = label_for_type(type_value, plural=count != 1) + return f"{label} ({count})" From b346b45d8e5657b0897ed86ec4fe803a554324a9 Mon Sep 17 00:00:00 2001 From: stewartshea Date: Fri, 22 May 2026 14:02:42 -0400 Subject: [PATCH 2/4] Update terminology across documentation, templates, and UI components to reflect the new vocabulary for AI Agent Guidelines. Replace instances of "CodeBundle" with "Skill Template," "Task" with "Tool," "TaskSet" with "Runbook," and "SLI" with "Monitor." Ensure backward compatibility in API paths and internal identifiers while promoting the new user-facing terms in all relevant surfaces. --- .github/ISSUE_TEMPLATE/codebundle-wanted.yaml | 28 +++-- Agents.md | 21 +++- cc-registry-v2/AGENTS.md | 47 ++++++-- cc-registry-v2/backend/app/main.py | 13 +- .../backend/app/routers/mcp_chat.py | 112 ++++++++++-------- cc-registry-v2/backend/openapi.yaml | 67 +++++++---- cc-registry-v2/docs/ARCHITECTURE.md | 16 +-- cc-registry-v2/docs/MCP_WORKFLOW.md | 22 ++-- cc-registry-v2/docs/README.md | 1 + .../frontend/src/components/Header.tsx | 4 +- .../src/components/TaskGrowthChart.tsx | 4 +- .../frontend/src/pages/AllTasks.tsx | 23 ++-- cc-registry-v2/frontend/src/pages/Chat.tsx | 14 +-- .../frontend/src/pages/CodeBundleDetail.tsx | 45 +++---- .../frontend/src/pages/CodeBundles.tsx | 16 +-- cc-registry-v2/frontend/src/pages/Home.tsx | 18 +-- .../frontend/src/pages/IntakeWizard.tsx | 12 +- cc-registry-v2/sources.yaml | 56 +++++---- .../templates/codebundle-index-template.j2 | 12 +- mcp-server/docs.yaml | 14 ++- mcp-server/server.py | 45 +++---- mcp-server/tools/codebundle_tools.py | 69 ++++++----- mcp-server/tools/github_issue.py | 45 ++++--- 23 files changed, 420 insertions(+), 284 deletions(-) diff --git a/.github/ISSUE_TEMPLATE/codebundle-wanted.yaml b/.github/ISSUE_TEMPLATE/codebundle-wanted.yaml index a1b7384c5270..f7efed8f9313 100644 --- a/.github/ISSUE_TEMPLATE/codebundle-wanted.yaml +++ b/.github/ISSUE_TEMPLATE/codebundle-wanted.yaml @@ -1,5 +1,5 @@ -name: CodeBundle Wanted -description: Request a new CodeBundle from the Community +name: Skill Template Wanted +description: Request a new Skill Template (formerly "CodeBundle") from the community title: "[new-codebundle-request] - " labels: [new-codebundle-request"] assignees: @@ -8,17 +8,19 @@ body: - type: markdown attributes: value: | - Hello there 🎉! We're excited that you want RunWhen's libraries to expand. Your request for a contribution will make a big difference in improving the community's experience with Kubernetes and cloud environments. Feel free to add as much or as little detail below. - + Hello there 🎉! We're excited that you want RunWhen's libraries to expand. Your request for a contribution will make a big difference in improving the community's experience with Kubernetes and cloud environments. Feel free to add as much or as little detail below. + Each and every request is highly appreciated! Let's make navigating complex environments easier together! - + + > **Heads up — terminology:** a **Skill Template** is what we used to call a **CodeBundle** (a reusable package of automation Tools). A **Tool** is what we used to call a **Task** — Runbooks run on demand, Monitors run on a schedule. Issue title prefix `[new-codebundle-request]` and label `new-codebundle-request` are kept for backward compatibility with existing workflows. + If you're open to being contacted with follow-up questions, please place an [x] beside 'yes, please' at the end of the form. 😊 - type: textarea id: codebundle-request attributes: label: What cloud platform(s) should this support? - description: Please describe, as best as you can, what this CodeBundle should do - including which cloud resources it should interact with. + description: Please describe, as best as you can, what this Skill Template should do - including which cloud resources it should interact with. placeholder: ex. Kubernetes on Azure (AKS) validations: required: true @@ -26,13 +28,13 @@ body: - type: textarea id: task-titles attributes: - label: What are some key tasks that should be performed? - description: Please outline a 3-7 key tasks that should be automated, along with any issues that should be raised if the result is not "healthy". + label: What are some key Tools (Runbooks / Monitors) that should be performed? + description: Please outline 3-7 key Tools that should be automated, along with any issues that should be raised if the result is not "healthy". placeholder: | ex. - 1. Trace Namespace Errors - Raise issue if Warning or Error events in last 10 minutes - 2. Fetch Unready Pods - Raise issue if more than 0 pods are unready - 3. List all Namespace Resources and Add to Report + 1. Trace Namespace Errors (Runbook) - Raise issue if Warning or Error events in last 10 minutes + 2. Fetch Unready Pods (Runbook) - Raise issue if more than 0 pods are unready + 3. List all Namespace Resources and Add to Report (Runbook) validations: required: true @@ -40,7 +42,7 @@ body: id: additional-context attributes: label: Any other helpful context? - description: Provide any additional context surrounding this Codebundle, such as specific circumstances or dependencies that make it particularly useful. + description: Provide any additional context surrounding this Skill Template, such as specific circumstances or dependencies that make it particularly useful. placeholder: ex. We run a multi-cluster istio setup, so it's important to support multiple contexts/clusters. validations: required: false @@ -58,4 +60,4 @@ body: - type: markdown attributes: value: | - You're done🎉! Woohoo! Thanks for taking the time to share your troubleshooting needs with the community! We appreciate your request! \ No newline at end of file + You're done🎉! Woohoo! Thanks for taking the time to share your troubleshooting needs with the community! We appreciate your request! diff --git a/Agents.md b/Agents.md index e69735f7fefd..11cfc47131ea 100644 --- a/Agents.md +++ b/Agents.md @@ -1,5 +1,24 @@ # AI Agent Guidelines for CodeCollection Registry +## 🗣️ Terminology (2026 — read this first) + +The registry uses **two parallel vocabularies**: + +| Internal (unchanged) | New display name | +|---|---| +| `Task` (registry concept) | **Tool** | +| `CodeBundle` | **Skill Template** (registry artifact — vars/secrets unresolved) | +| (no internal equivalent — runtime only) | **Skill** (runtime instantiation of a Skill Template inside a workspace; also used colloquially as the umbrella term in page titles like "All Skills") | +| `SLI` (`type: "SLI"`) | **Monitor** — Tool that runs on a schedule, emits 0–1 numeric value | +| `TaskSet` (`type: "TaskSet"`) | **Runbook** — Tool that runs on demand, emits structured findings | +| `CodeCollection` | **CodeCollection** (unchanged) | + +A workspace **renders** a Skill Template into a Skill at runtime (vars + secrets substituted in). The registry only ever stores Skill Templates; Skills only exist inside workspaces. + +Use the **new vocabulary** in all user-facing surfaces (UI, MCP markdown output, chat replies, docs). Leave internal identifiers (DB columns, JSON `type` enums, MCP tool function names like `find_codebundle`, API paths like `/api/v1/codebundles`) as-is for backward compatibility. Canonical mapping table and "where each vocabulary applies" matrix live in [`cc-registry-v2/AGENTS.md`](cc-registry-v2/AGENTS.md#terminology). + +--- + ## 📋 General Rules ### Documentation File Policy @@ -316,7 +335,7 @@ POST /api/v1/chat/query 4. ❌ Don't commit `az.secret` or other credential files 5. ❌ Don't run database operations in request handlers (use Celery tasks) 6. ❌ Don't show raw database IDs in UI (use slugs) -7. ❌ Don't mix terminology (use CodeCollections, CodeBundles, Tasks - not "code bundles", "bundles", etc.) +7. ❌ Don't mix vocabularies in display copy. Use the new vocabulary (Skill Templates, Tools, Monitors, Runbooks) in **all user-facing surfaces** — UI labels, MCP markdown output, chat replies, docs. Internal identifiers (DB columns `tasks`/`slis`, JSON `type: "TaskSet" | "SLI" | "CodeBundle"`, MCP tool function names like `find_codebundle`, API paths `/api/v1/codebundles`) stay as legacy names for backward compatibility. See `cc-registry-v2/AGENTS.md` § Terminology for the full mapping table. --- diff --git a/cc-registry-v2/AGENTS.md b/cc-registry-v2/AGENTS.md index e1b4f8bda1d0..13a3d119a231 100644 --- a/cc-registry-v2/AGENTS.md +++ b/cc-registry-v2/AGENTS.md @@ -6,7 +6,7 @@ Instructions for AI coding agents working in this codebase. ## Project Overview -The CodeCollection Registry is a public-facing web app for browsing, searching, and configuring RunWhen automation (CodeBundles). It consists of 8 Docker services: +The CodeCollection Registry is a public-facing web app for browsing, searching, and configuring RunWhen automation (Skill Templates, formerly "CodeBundles"). It consists of 8 Docker services: | Service | Stack | Port | Purpose | |---------|-------|------|---------| @@ -23,15 +23,48 @@ The CodeCollection Registry is a public-facing web app for browsing, searching, ## Terminology -Use these exact terms — never abbreviate or paraphrase: +The codecollection-registry uses **two parallel vocabularies**: a new user-facing vocabulary that aligns with industry/agent terminology, and a legacy internal vocabulary that remains in source code, JSON `type` enums, DB columns, MCP tool function names, and API paths. **All display surfaces — UI, MCP markdown output, chat replies, docs, GitHub issue templates — should use the new vocabulary.** Internal identifiers stay byte-identical for backward compatibility with existing integrations (workspace platform, MCP clients, runner, external scripts). + +### Vocabulary mapping (2026) + +| Internal name (unchanged) | New display name | Behavioral definition | +|---|---|---| +| `Task` (registry concept) | **Tool** | Any invocable unit. Parent concept covering both sub-types. Maps to MCP/OpenAI/Anthropic "Tool". | +| `CodeBundle` | **Skill Template** | Reusable, parameterizable package containing one or more Tools. Lives in the registry. Vars and secrets are unresolved placeholders. | +| (no internal equivalent — runtime concept) | **Skill** | The runtime instantiation of a Skill Template inside a workspace, with vars/secrets materialized against real infrastructure. The registry itself never holds Skills — only Skill Templates. "Skill" is also used colloquially as the umbrella word in user-facing page titles (e.g. "All Skills") because it reads naturally and aligns with Anthropic Agent Skills / industry usage. | +| `SLI` (`type: "SLI"`) | **Monitor** | A Tool that runs on a schedule, continuously, in the background. Emits a 0–1 numeric value. | +| `TaskSet` (`type: "TaskSet"`) | **Runbook** | A Tool that is invoked on demand in response to an event or request. Emits structured findings with next-steps. | +| `CodeCollection` | **CodeCollection** (unchanged) | Git-repo-level grouping of Skill Templates. | + +Tagline (for chat/docs/intro copy): *"A Skill Template packages Tools. Workspaces render Skill Templates into Skills at runtime. Monitors are Tools that run themselves on a schedule. Runbooks are Tools that run on demand."* + +#### Skill vs Skill Template — when to use which + +- Use **Skill Template** when referring to the registry-side artifact: search results, browse pages, "request a new Skill Template" copy, GitHub issue templates, OpenAPI descriptions, MCP markdown output that describes what the registry holds. +- Use **Skill** when referring to the runtime/workspace artifact, or as the colloquial umbrella term in short page titles (e.g. "All Skills"). When in doubt in long-form copy, prefer **Skill Template** for precision. + +### Where each vocabulary applies + +| Surface | Vocabulary | Notes | +|---|---|---| +| React UI labels, page titles, badges, tabs, hero copy | **NEW** | Routed through `frontend/src/lib/terminology.ts` | +| MCP server markdown output (`get_codebundle_details`, `find_codebundle`, etc.) | **NEW** | Strings are user-facing in chat clients | +| Chat system prompt + LLM-generated replies | **NEW** (with legacy aliases) | System prompt teaches both vocabularies so legacy queries still resolve | +| GitHub issue templates (`codebundle-wanted.yaml`) user-facing copy | **NEW** | "Request a Skill Template" | +| Docs (`AGENTS.md`, `ARCHITECTURE.md`, `MCP_WORKFLOW.md`, `sources.yaml`, indexed glossaries) | **NEW** (with parenthetical legacy term on first mention) | Feeds chat indexing | +| OpenAPI summaries/descriptions | **NEW** (with parenthetical legacy term) | Paths and schemas unchanged | +| **MCP tool function names** (`find_codebundle`, `list_codebundles`, `search_codebundles`, `get_codebundle_details`, `request_codebundle`) | **LEGACY** | External AI integrations depend on these identifiers | +| **API paths** (`/api/v1/codebundles`, `/api/v1/registry/tasks`, `/collections/{slug}/codebundles/{slug}`) | **LEGACY** | Client compatibility | +| **DB tables/columns** (`codebundles`, `codecollections`, `vector_codebundles`, `tasks`, `slis`, `task_count`, `sli_count`, `task_index`, `sli_path`) | **LEGACY** | Schema stability; requires alembic migration to rename | +| **JSON `type` enum values** (`"TaskSet"`, `"SLI"`, `"CodeBundle"`) | **LEGACY** | Frontend `TYPE_LABELS` maps these to display names at render time | +| Python class names, TypeScript interface names, route paths | **LEGACY** | Internal-only | + +### Other unchanged terms -- **CodeCollection** — a git repo containing multiple CodeBundles -- **CodeBundle** — a folder within a CodeCollection containing automation tasks -- **Task** — an individual automation script (either `TaskSet` or `SLI` type) - **RunWhen Platform** — the orchestration platform (not "RunWhen Core") - **Workspace Chat** — the AI chat feature (not "AI Chat" or "Eager Edgar Chat") -- **Support Tags** — metadata tags on CodeBundles (e.g., `kubernetes`, `aws`, `azure`) -- **Data Tags** — per-task data classification tags (`data:config`, `data:logs-regexp`, etc.) +- **Support Tags** — metadata tags on Skill Templates (e.g., `kubernetes`, `aws`, `azure`) +- **Data Tags** — per-Tool data classification tags (`data:config`, `data:logs-regexp`, etc.) --- diff --git a/cc-registry-v2/backend/app/main.py b/cc-registry-v2/backend/app/main.py index ca6b4bf403f3..202e858257ee 100644 --- a/cc-registry-v2/backend/app/main.py +++ b/cc-registry-v2/backend/app/main.py @@ -263,7 +263,12 @@ async def get_all_tasks( limit: int = 100, offset: int = 0 ): - """Get all tasks with filtering and pagination""" + """Search Tools (formerly "tasks") across all Skill Templates (codebundles) with filtering and pagination. + + The path `/api/v1/registry/tasks` and the JSON field `tasks[]` are kept for backward + compatibility. Each returned item carries a `type` field of `"TaskSet"` (Runbook) or + `"SLI"` (Monitor). User-facing surfaces (UI, MCP markdown, chat) map these to the + new vocabulary (Skill Template, Tool, Runbook, Monitor).""" try: from app.core.database import SessionLocal from app.models import CodeCollection, Codebundle @@ -274,7 +279,7 @@ async def get_all_tasks( try: from app.core.visibility import public_only # Build the query — always join CodeCollection so we can scope to - # public-visibility collections (hidden CCs and their codebundles + # public-visibility collections (hidden CCs and their Skill Templates # do not appear on the public registry website). query = ( db.query(Codebundle) @@ -804,7 +809,9 @@ async def get_recent_codebundles(): @app.get("/api/v1/registry/recent-tasks") async def get_recent_tasks(): - """Get the 10 most recently added tasks based on git update date""" + """Get the 10 most recently added Tools (Runbooks / Monitors) based on git update date. + + Path and response field names retained for backward compatibility; `tasks` → `Tools`.""" try: from app.core.database import SessionLocal from app.models import CodeCollection, Codebundle diff --git a/cc-registry-v2/backend/app/routers/mcp_chat.py b/cc-registry-v2/backend/app/routers/mcp_chat.py index 0547c989338e..985e03f72ce0 100644 --- a/cc-registry-v2/backend/app/routers/mcp_chat.py +++ b/cc-registry-v2/backend/app/routers/mcp_chat.py @@ -315,16 +315,20 @@ async def query_codecollections( I have access to: -1. **CodeBundles** - Automation scripts for troubleshooting and managing infrastructure: +1. **Skill Templates** (formerly "CodeBundles") - Automation packages containing Tools for troubleshooting and managing infrastructure: - Kubernetes (pods, deployments, services, ingress, etc.) - AWS (EC2, EKS, RDS, Lambda, S3, etc.) - Azure (AKS, App Service, VMs, databases, etc.) - GCP (GKE, Cloud Run, Cloud SQL, etc.) - Databases (PostgreSQL, Redis, MongoDB, etc.) + Each Skill Template ships **Tools** of two flavors: + - **Runbooks** (formerly "TaskSets") run on demand in response to an event or request. + - **Monitors** (formerly "SLIs") run on a schedule, continuously, emitting a 0–1 numeric health value. + 2. **Documentation** - I can answer questions using RunWhen docs: - RunWhen Local installation and configuration - - CodeBundle development guides + - Skill Template (CodeBundle) development guides - Cloud discovery setup (Kubernetes, AWS, Azure, GCP) - Robot Framework syntax and library references (RW.CLI, RW.Core, RW.K8s) - Best practices, troubleshooting, and FAQs @@ -333,10 +337,10 @@ async def query_codecollections( **Ask me things like:** - "How do I install runwhen-local?" -- "What codebundles do you have for Kubernetes?" +- "What Skill Templates do you have for Kubernetes?" - "How do I troubleshoot Azure App Service?" - "How do I configure cloud discovery?" -- "How do I create a new CodeBundle?" +- "How do I create a new Skill Template?" """ relevant_tasks = [] sources_used = ["System Information"] @@ -721,8 +725,8 @@ async def get_example_queries(): "category": "Development Help", "icon": "code", "queries": [ - "I'm new to writing codebundles, how do I run kubectl commands?", - "What's the difference between SLI and TaskSet codebundles?", + "I'm new to writing Skill Templates, how do I run kubectl commands?", + "What's the difference between Monitors and Runbooks in a Skill Template?", "How do I configure secrets and credentials for my workspace?", "Can you show me how to parse JSON output in Robot Framework?" ] @@ -741,10 +745,10 @@ async def get_example_queries(): "category": "Getting Started", "icon": "rocket", "queries": [ - "I'm new here, what are the most useful codebundles for SRE work?", + "I'm new here, what are the most useful Skill Templates for SRE work?", "Show me some basic health check examples I can learn from", - "What tasks can I run with minimal cloud permissions?", - "Can you give me an overview of all the codecollections?" + "What Tools can I run with minimal cloud permissions?", + "Can you give me an overview of all the CodeCollections?" ] } ] @@ -890,17 +894,27 @@ async def _generate_llm_answer( # Build context from tasks task_context = _build_task_context(relevant_tasks) - system_prompt = """You are a helpful assistant that helps users find and use RunWhen CodeBundles, documentation, and guides. + system_prompt = """You are a helpful assistant that helps users find and use RunWhen Skill Templates (also known as "CodeBundles"), documentation, and guides. + +VOCABULARY (2026 — accept either set of terms from users): +- **Tool** = an invocable unit (formerly "Task"). +- **Skill Template** = a reusable, parameterised package of Tools that lives in the registry (formerly "CodeBundle"). Has placeholder vars and unresolved secrets. +- **Skill** = the RUNTIME instantiation of a Skill Template inside a workspace, with vars/secrets materialised against real infrastructure. The registry only stores Skill Templates; Skills only exist at runtime in a workspace. The umbrella word "Skill" appears in user-facing page titles (e.g. "All Skills") as a colloquial shorthand, but when users ask about the artifacts you can recommend from the registry, they are asking about **Skill Templates**. +- **Monitor** = a Tool that runs on a schedule, continuously, emitting a 0–1 numeric value (formerly "SLI" / "Service Level Indicator"). +- **Runbook** = a Tool that runs on demand in response to an event or request, emitting structured findings (formerly "TaskSet"). +- **CodeCollection** = a git-repo-level grouping of Skill Templates (unchanged). + +Users may use either the new or legacy vocabulary interchangeably. Treat "Skill Template" and "CodeBundle" as synonyms. Treat "Monitor" and "SLI" as synonyms. Treat "Runbook" and "TaskSet" as synonyms. Treat "Tool" and "Task" as synonyms. When a user says just "Skill" in a registry-browsing context, they almost always mean a Skill Template — clarify only if it matters. In your replies, PREFER the new vocabulary (Skill Template, Tool, Monitor, Runbook) but legacy terms are also acceptable. Internal JSON `type` values still emit "TaskSet", "SLI", and "CodeBundle" for backward compatibility — that is expected and not a bug. -CodeBundles are automation scripts for troubleshooting and managing infrastructure (Kubernetes, AWS, Azure, GCP, databases, etc.). +Skill Templates are automation packages for troubleshooting and managing infrastructure (Kubernetes, AWS, Azure, GCP, databases, etc.). You have access to TWO key sources of knowledge: -1. **CodeBundles** - automation scripts for specific operational tasks (troubleshooting, monitoring, scaling, etc.) -2. **Documentation** - guides, tutorials, installation instructions, configuration references, FAQs, and conceptual explanations about RunWhen products, runwhen-local, generation rules, secrets, SLIs, tasks, etc. +1. **Skill Templates** (formerly "CodeBundles") - automation packages containing Tools for specific operational needs (troubleshooting, monitoring, scaling, etc.) +2. **Documentation** - guides, tutorials, installation instructions, configuration references, FAQs, and conceptual explanations about RunWhen products, runwhen-local, generation rules, secrets, Monitors, Tools, etc. Additionally: 3. Libraries - Robot Framework keyword libraries (RW.CLI, RW.K8s, etc.) -4. Examples - sample codebundles and configurations +4. Examples - sample Skill Templates and configurations CRITICAL: ANSWERING FROM DOCUMENTATION - When documentation results are provided, READ THEM CAREFULLY and use their CONTENT to answer the question directly @@ -910,22 +924,22 @@ async def _generate_llm_answer( - If the docs contain step-by-step instructions, reproduce or summarize the key steps in your answer FORMATTING RULES: -- Always use **bold** for CodeBundle names (e.g., **azure-appservice-webapp-ops**) -- Use bullet points for listing tasks or capabilities +- Always use **bold** for Skill Template names (e.g., **azure-appservice-webapp-ops**) +- Use bullet points for listing Tools or capabilities - Keep responses focused and scannable CRITICAL RULES: 1. ONLY recommend resources that DIRECTLY ADDRESS the user's specific question 2. For "how to" questions about installation, configuration, setup, or development of RunWhen itself: PRIORITIZE DOCUMENTATION -3. For questions about troubleshooting, monitoring, or managing cloud/infrastructure resources (Azure, AWS, GCP, Kubernetes, databases, etc.): ALWAYS recommend relevant codebundles — these ARE our product -4. For mixed questions: provide BOTH documentation answers AND relevant codebundles +3. For questions about troubleshooting, monitoring, or managing cloud/infrastructure resources (Azure, AWS, GCP, Kubernetes, databases, etc.): ALWAYS recommend relevant Skill Templates — these ARE our product +4. For mixed questions: provide BOTH documentation answers AND relevant Skill Templates 5. Be STRICT about relevance - fewer accurate recommendations are better than many tangential ones 6. IGNORE results that don't match the user's platform (e.g., don't show Kubernetes results for Azure App Service questions) -7. REMEMBER the conversation history - if the user refers to "this codebundle" or "it", they mean the one discussed previously -8. If the user asks about YOU or what YOU can do, answer about your capabilities, DON'T search for codebundles -9. When you see kubectl output or command output, IMMEDIATELY ask clarifying questions before recommending specific codebundles +7. REMEMBER the conversation history - if the user refers to "this Skill Template" / "this codebundle" or "it", they mean the one discussed previously +8. If the user asks about YOU or what YOU can do, answer about your capabilities, DON'T search for Skill Templates +9. When you see kubectl output or command output, IMMEDIATELY ask clarifying questions before recommending specific Skill Templates 10. For Kubernetes troubleshooting, always consider BOTH the workload level (Deployment/StatefulSet) AND pod level - don't assume one without asking -11. If codebundles are provided in the search results that relate to the user's infrastructure question, you MUST mention them — do NOT say "no matching codebundle" when related ones exist +11. If Skill Templates are provided in the search results that relate to the user's infrastructure question, you MUST mention them — do NOT say "no matching Skill Template" when related ones exist ASK CLARIFYING QUESTIONS PROACTIVELY when context is missing: - If kubectl output shows pods in error state (CrashLoopBackOff, Error, etc.), ask: "Are these standalone Pods or part of a Deployment, StatefulSet, or DaemonSet?" @@ -937,21 +951,21 @@ async def _generate_llm_answer( - ASK IMMEDIATELY in your first response if critical context is missing - don't wait for follow-ups When recommending: -- Always use **bold** for CodeBundle names +- Always use **bold** for Skill Template names - Explain what each resource does in plain language - For documentation: EXPLAIN what the docs say (don't just link) and include the URL as a reference -- For codebundles: mention the SPECIFIC TASKS it contains that are relevant +- For Skill Templates: mention the SPECIFIC Tools (Runbooks / Monitors) it contains that are relevant - Be conversational and keep responses concise but informative - If multiple layers of troubleshooting exist (e.g., Pod-level AND Deployment-level), mention both options -- For Kubernetes issues, consider both workload-level (Deployment, StatefulSet) and resource-level (Pod, Container) codebundles +- For Kubernetes issues, consider both workload-level (Deployment, StatefulSet) and resource-level (Pod, Container) Skill Templates -If ZERO codebundles were provided in the search results above: +If ZERO Skill Templates were provided in the search results above: - Start your response with exactly: "[NO_MATCHING_CODEBUNDLE]" -- Be honest: "I couldn't find a codebundle specifically for [user's need]" -- Tell them they can request this automation by clicking the "Request CodeBundle" button below +- Be honest: "I couldn't find a Skill Template specifically for [user's need]" +- Tell them they can request this automation by clicking the "Request Skill Template" button below - Keep the response short since the button will handle the request -IMPORTANT: If codebundles ARE listed in the search results and they relate to the user's topic (even if they don't do exactly what was asked), you MUST recommend them. For example, if the user asks about scaling Azure App Service and you see an "App Service Plan Health" codebundle that provides scaling recommendations — that IS relevant and should be recommended.""" +IMPORTANT: If Skill Templates ARE listed in the search results and they relate to the user's topic (even if they don't do exactly what was asked), you MUST recommend them. For example, if the user asks about scaling Azure App Service and you see an "App Service Plan Health" Skill Template that provides scaling recommendations — that IS relevant and should be recommended.""" # Build messages array with conversation history messages = [{"role": "system", "content": system_prompt}] @@ -970,11 +984,11 @@ async def _generate_llm_answer( user_prompt = f"""User Question: {question} IMPORTANT - THIS IS A FOLLOW-UP QUESTION: -The user is asking about CodeBundles we JUST discussed in the conversation above. +The user is asking about Skill Templates we JUST discussed in the conversation above. -- Look at the conversation history to find the CodeBundle names, links, and details -- If they're asking for a link, the CodeBundle slug/name is in the format: `/collections/COLLECTION-SLUG/codebundles/CODEBUNDLE-SLUG` -- If they're asking "how to use" or "more info", refer to the CodeBundle we already mentioned +- Look at the conversation history to find the Skill Template names, links, and details +- If they're asking for a link, the Skill Template slug/name is in the format: `/collections/COLLECTION-SLUG/codebundles/CODEBUNDLE-SLUG` (the URL path keeps the legacy `codebundles` segment) +- If they're asking "how to use" or "more info", refer to the Skill Template we already mentioned - DO NOT say "I couldn't find" - we literally just discussed it! - Answer directly from the conversation context @@ -992,22 +1006,22 @@ async def _generate_llm_answer( user_prompt = f"""User Question: {question} -## Available CodeBundles from search (sorted by relevance score): +## Available Skill Templates from search (sorted by relevance score): {task_context} {doc_section} -ANSWER SOURCE CLASSIFICATION - You MUST start your response with exactly one of these tags: -- [SOURCE:codebundles] — if CodeBundles from the search results are relevant to the user's question (DEFAULT when codebundles are listed) -- [SOURCE:documentation] — ONLY if no codebundles are listed AND the answer comes from documentation +ANSWER SOURCE CLASSIFICATION - You MUST start your response with exactly one of these tags (the internal tag tokens are unchanged so downstream systems still recognize them): +- [SOURCE:codebundles] — if Skill Templates from the search results are relevant to the user's question (DEFAULT when Skill Templates are listed) +- [SOURCE:documentation] — ONLY if no Skill Templates are listed AND the answer comes from documentation - [SOURCE:libraries] — if your answer is about Robot Framework keyword libraries (RW.CLI, RW.K8s, etc.) -- [SOURCE:mixed] — if your answer uses BOTH documentation content AND CodeBundle recommendations +- [SOURCE:mixed] — if your answer uses BOTH documentation content AND Skill Template recommendations RULES: -- When CodeBundles are listed in search results that relate to the user's topic, use [SOURCE:codebundles] or [SOURCE:mixed] -- Mention the most relevant CodeBundle(s) by name, explain what they do, and list their key tasks +- When Skill Templates are listed in search results that relate to the user's topic, use [SOURCE:codebundles] or [SOURCE:mixed] +- Mention the most relevant Skill Template(s) by name, explain what they do, and list their key Tools (Runbooks / Monitors) - Quality over quantity - 1-2 good matches is better than 5 mediocre ones -- If the user is asking a follow-up about a previously mentioned codebundle, answer based on the conversation history -- Only use [SOURCE:documentation] when NO codebundles are available and docs answer the question""" +- If the user is asking a follow-up about a previously mentioned Skill Template, answer based on the conversation history +- Only use [SOURCE:documentation] when NO Skill Templates are available and docs answer the question""" messages.append({"role": "user", "content": user_prompt}) @@ -1040,11 +1054,11 @@ def _build_task_context(tasks: List[RelevantTask]) -> str: ] if task.description: task_info.append(f"Description: {task.description}") - # Include actual tasks/capabilities - this is what users search for + # Include actual Tools/capabilities - this is what users search for if task.tasks: - task_info.append(f"Available Tasks: {', '.join(task.tasks[:8])}") + task_info.append(f"Available Runbooks (Tools): {', '.join(task.tasks[:8])}") if task.slis: - task_info.append(f"Available SLIs: {', '.join(task.slis[:5])}") + task_info.append(f"Available Monitors: {', '.join(task.slis[:5])}") if task.support_tags: task_info.append(f"Tags: {', '.join(task.support_tags)}") task_info.append(f"Relevance: {task.relevance_score:.0%}") @@ -1056,12 +1070,12 @@ def _build_task_context(tasks: List[RelevantTask]) -> str: def _generate_fallback_answer(question: str, tasks: List[RelevantTask]) -> str: """Generate a simple fallback answer when LLM is not available""" if not tasks: - return f"""I couldn't find any tasks matching your question: "{question}" + return f"""I couldn't find any Tools matching your question: "{question}" -Would you like to request these tasks be added to the registry? You can create a GitHub issue to request new automation tasks.""" +Would you like to request these Tools be added to the registry? You can create a GitHub issue to request new automation Skill Templates.""" answer_parts = [ - f"Here are the most relevant tasks for: **{question}**\n" + f"Here are the most relevant Tools for: **{question}**\n" ] for i, task in enumerate(tasks[:3], 1): @@ -1070,7 +1084,7 @@ def _generate_fallback_answer(question: str, tasks: List[RelevantTask]) -> str: answer_parts.append(f" {task.description[:200]}...") answer_parts.append("") - answer_parts.append("\nSee the detailed results below for more information on each task.") + answer_parts.append("\nSee the detailed results below for more information on each Tool.") return "\n".join(answer_parts) diff --git a/cc-registry-v2/backend/openapi.yaml b/cc-registry-v2/backend/openapi.yaml index 3adb2942d08d..5f03c755153e 100644 --- a/cc-registry-v2/backend/openapi.yaml +++ b/cc-registry-v2/backend/openapi.yaml @@ -2,8 +2,26 @@ openapi: 3.1.0 info: title: RunWhen CodeCollection Registry API description: | - Backend API for the RunWhen CodeCollection Registry. Manages codecollections, - codebundles, tasks, documentation, AI enhancement, Helm charts, and chat. + Backend API for the RunWhen CodeCollection Registry. Manages CodeCollections, + Skill Templates (formerly "codebundles"), Tools (formerly "tasks"), + documentation, AI enhancement, Helm charts, and chat. + + ## Terminology + + The API path segments and JSON schemas still use the legacy vocabulary for + backward compatibility — internal/external clients depend on these identifiers. + The new user-facing vocabulary maps as follows: + + | API path / JSON field (legacy, unchanged) | New display name | + |---|---| + | `/api/v1/codebundles`, `codebundles[]`, `codebundle` | **Skill Template** | + | `/api/v1/registry/tasks`, `tasks[]`, `task` | **Tool** | + | `type: "TaskSet"`, `/api/v1/tasksets` | **Runbook** (on-demand Tool) | + | `type: "SLI"`, `slis[]` | **Monitor** (scheduled Tool, 0-1 numeric output) | + | `codecollections[]`, `/api/v1/codecollections` | **CodeCollection** (unchanged) | + + Treat the two vocabularies as synonyms. Endpoint summaries below use the + new vocabulary where it adds clarity; paths and schemas are stable. ## Architecture @@ -20,7 +38,7 @@ info: ## Data Flow ``` - codecollections.yaml → Seed → Sync (git clone) → Parse (codebundles) → Enhance (AI) → Serve + codecollections.yaml → Seed → Sync (git clone) → Parse (Skill Templates) → Enhance (AI) → Serve ``` version: 2.0.0 @@ -41,19 +59,19 @@ tags: - name: Health description: Health checks and root info - name: Registry - description: Public endpoints for browsing collections, codebundles, and tasks + description: Public endpoints for browsing CodeCollections, Skill Templates (codebundles), and Tools (tasks) - name: Chat description: MCP-powered semantic search and conversational chat - name: Analytics - description: Task growth metrics and analytics + description: Tool growth metrics and analytics - name: Versions - description: Collection version management + description: CodeCollection version management - name: Helm Charts description: Helm chart versions, schemas, and validation - name: GitHub - description: GitHub issue creation for codebundle requests + description: GitHub issue creation for Skill Template (codebundle) requests - name: Admin - Collections - description: CRUD operations for codecollections (requires auth) + description: CRUD operations for CodeCollections (requires auth) - name: Admin - Inventory description: Detailed inventory views (requires auth) - name: Admin - Operations @@ -144,10 +162,11 @@ paths: /api/v1/codebundles: get: tags: [Registry] - summary: List/search codebundles + summary: List/search Skill Templates (codebundles) description: | - List codebundles with full-text search, filtering, and pagination. + List Skill Templates (formerly "codebundles") with full-text search, filtering, and pagination. The `search` parameter searches across name, display_name, description, and doc fields. + The path segment `/codebundles` and response field `codebundles` are kept for backward compatibility. operationId: listCodebundles parameters: - name: limit @@ -182,7 +201,7 @@ paths: schema: { type: string, enum: [name, updated, tasks], default: name } responses: "200": - description: Paginated codebundle list + description: Paginated Skill Template (codebundle) list content: application/json: schema: @@ -199,7 +218,7 @@ paths: /api/v1/collections/{collection_slug}/codebundles/{codebundle_slug}: get: tags: [Registry] - summary: Get codebundle by slug + summary: Get Skill Template (codebundle) by slug operationId: getCodebundle parameters: - $ref: "#/components/parameters/CollectionSlug" @@ -209,19 +228,23 @@ paths: schema: { type: string } responses: "200": - description: Full codebundle details + description: Full Skill Template details content: application/json: schema: $ref: "#/components/schemas/CodeBundleFull" "404": - description: Codebundle not found + description: Skill Template (codebundle) not found /api/v1/registry/tasks: get: tags: [Registry] - summary: Search tasks - description: Search tasks across all codebundles with tag and text filtering. + summary: Search Tools (tasks) + description: | + Search Tools (formerly "tasks") — both Runbooks (TaskSets) and Monitors (SLIs) — + across all Skill Templates (codebundles) with tag and text filtering. The + JSON response field name `tasks` is kept for backward compatibility; each + item carries a `type` of "TaskSet" (Runbook) or "SLI" (Monitor). operationId: searchTasks parameters: - name: support_tags @@ -242,7 +265,7 @@ paths: schema: { type: integer, default: 0 } responses: "200": - description: Task search results + description: Tool (task) search results content: application/json: schema: @@ -258,12 +281,12 @@ paths: /api/v1/registry/recent-codebundles: get: tags: [Registry] - summary: Recent codebundles - description: Get the 20 most recently updated codebundles. + summary: Recent Skill Templates (codebundles) + description: Get the 20 most recently updated Skill Templates. operationId: recentCodebundles responses: "200": - description: Recent codebundles + description: Recent Skill Templates content: application/json: schema: @@ -274,11 +297,11 @@ paths: /api/v1/registry/recent-tasks: get: tags: [Registry] - summary: Recent tasks + summary: Recent Tools (tasks) operationId: recentTasks responses: "200": - description: Recent tasks + description: Recent Tools content: application/json: schema: diff --git a/cc-registry-v2/docs/ARCHITECTURE.md b/cc-registry-v2/docs/ARCHITECTURE.md index 02ab783af7d3..485080c440d7 100644 --- a/cc-registry-v2/docs/ARCHITECTURE.md +++ b/cc-registry-v2/docs/ARCHITECTURE.md @@ -8,7 +8,7 @@ The registry runs as 8 Docker services coordinated by `docker-compose.yml`. | Service | Image / Stack | Port | Role | |---|---|---|---| -| **frontend** | React 19 + TypeScript + MUI v7 | 3000 | SPA for browsing and managing CodeBundles | +| **frontend** | React 19 + TypeScript + MUI v7 | 3000 | SPA for browsing and managing Skill Templates (formerly "CodeBundles") | | **backend** | FastAPI + SQLAlchemy 2.0 | 8001 | REST API (`/api/v1/`), business logic, AI enhancement, embedding generation | | **mcp-server** | FastAPI (separate repo: `../mcp-server`) | 8000 | Stateless MCP tool server, delegates all queries to backend API | | **worker** | Celery (shares backend image) | -- | Background task processing (sync, parse, enhance, embed) | @@ -63,8 +63,8 @@ Worker: sync_parse_enhance_workflow_task │ ├── Step 2: parse_all_codebundles_task │ Parse meta.yaml, *.robot files, README.md - │ Extract tasks, SLIs, metadata, support tags - │ INSERT/UPDATE codebundles in PostgreSQL + │ Extract Tools — Runbooks (TaskSets) and Monitors (SLIs) — plus metadata and support tags + │ INSERT/UPDATE Skill Templates (DB table: codebundles) in PostgreSQL │ ├── Step 3: enhance_pending_codebundles_task │ AI-enhance NEW codebundles only (pending/NULL status) @@ -179,14 +179,14 @@ The database image is `pgvector/pgvector:pg15`. The pgvector extension is enable | Table | Purpose | |---|---| -| `codecollections` | Collection metadata (name, slug, git_url, owner) | -| `codebundles` | CodeBundle details (name, slug, description, tasks, SLIs, AI metadata) | -| `tasks` | Individual task definitions extracted from codebundles | +| `codecollections` | CodeCollection metadata (name, slug, git_url, owner) | +| `codebundles` | Skill Template details (name, slug, description, Tools, Monitors, AI metadata) — table name kept for backward compatibility | +| `tasks` | Individual Tool (Runbook / Monitor) definitions extracted from Skill Templates — table name kept for backward compatibility | | `metrics` | Collection-level metrics and statistics | | `ai_enhancement_log` | AI enhancement audit trail | | `helm_charts` | Helm chart versions and templates | -| `analytics` | Task growth metrics | -| `task_executions` | Celery task execution history | +| `analytics` | Tool growth metrics | +| `task_executions` | Celery task execution history (background-job tasks, not Tools) | ### Vector tables (created by `006_add_pgvector.sql`) diff --git a/cc-registry-v2/docs/MCP_WORKFLOW.md b/cc-registry-v2/docs/MCP_WORKFLOW.md index 4792aa485175..92e65b5d2734 100644 --- a/cc-registry-v2/docs/MCP_WORKFLOW.md +++ b/cc-registry-v2/docs/MCP_WORKFLOW.md @@ -7,8 +7,8 @@ How data ingestion, embedding generation, and search work in the CodeCollection There is **one pipeline** for all environments. The backend Celery worker: 1. Syncs CodeCollection repos from GitHub -2. Parses codebundles from Robot files -3. AI-enhances metadata for new codebundles +2. Parses Skill Templates (formerly "CodeBundles") from Robot files +3. AI-enhances metadata for new Skill Templates 4. Generates embeddings and stores them in pgvector The MCP server is a **stateless HTTP proxy** that delegates all queries to the backend API. @@ -32,28 +32,28 @@ Step 1: sync_all_collections_task │ ▼ Step 2: parse_all_codebundles_task - - For each collection repo: + - For each CodeCollection repo: - Walk directory tree looking for meta.yaml + *.robot files - Parse meta.yaml: extract name, description, tags - - Parse *.robot files: extract tasks, SLIs, keywords, variables + - Parse *.robot files: extract Tools — Runbooks (TaskSets) and Monitors (SLIs) — plus keywords and variables - Parse README.md for documentation content - - INSERT or UPDATE codebundle rows in PostgreSQL + - INSERT or UPDATE Skill Template rows in PostgreSQL (table name: `codebundles`) │ ▼ Step 3: enhance_pending_codebundles_task - - Query codebundles WHERE enhancement_status IS NULL or 'pending' - - For each unenhanced codebundle: + - Query Skill Templates WHERE enhancement_status IS NULL or 'pending' + - For each unenhanced Skill Template: - Send to Azure OpenAI GPT for analysis - Generate: improved description, platform classification, access level, IAM requirements, data classifications - - UPDATE the codebundle row + - UPDATE the Skill Template row │ ▼ Step 4: index_codebundles_task - - Query all active codebundles and codecollections from PostgreSQL - - Build document text for each (name + description + tags + tasks + readme) + - Query all active Skill Templates and CodeCollections from PostgreSQL + - Build document text for each (name + description + tags + Tools + readme) - Generate embeddings via Azure OpenAI text-embedding-3-small - - Upsert into vector_codebundles and vector_codecollections (pgvector) + - Upsert into vector_codebundles and vector_codecollections (pgvector — table names kept for backward compatibility) ``` ### Documentation indexing diff --git a/cc-registry-v2/docs/README.md b/cc-registry-v2/docs/README.md index 157996f1065e..4f412c175811 100644 --- a/cc-registry-v2/docs/README.md +++ b/cc-registry-v2/docs/README.md @@ -8,6 +8,7 @@ All project documentation, organized by topic. - **[CCV.md](CCV.md)** - CodeCollection Version catalog: tag-schema contract, image-source plugins, `/api/v1/catalog` endpoints, PAPI integration - **[MCP_WORKFLOW.md](MCP_WORKFLOW.md)** - Document indexing pipeline, embedding generation, vector store, and search flow - **[CHAT.md](CHAT.md)** - Chat system architecture, dual search pipeline, LLM synthesis, follow-up detection +- **[PHASE_2_SKILL_MD.md](PHASE_2_SKILL_MD.md)** - Phase 2 plan: add `SKILL.md` authoring + rendering per Anthropic Agent Skills spec (follow-up to the 2026 cosmetic terminology realignment) ## Setup and Configuration diff --git a/cc-registry-v2/frontend/src/components/Header.tsx b/cc-registry-v2/frontend/src/components/Header.tsx index 8842d68b40ce..315ee1eb6af7 100644 --- a/cc-registry-v2/frontend/src/components/Header.tsx +++ b/cc-registry-v2/frontend/src/components/Header.tsx @@ -173,10 +173,10 @@ const Header: React.FC = () => { CodeCollections handleMenuNavigate('/codebundles')}> - CodeBundles + Skill Templates handleMenuNavigate('/all-tasks')}> - All Tasks + All Skills diff --git a/cc-registry-v2/frontend/src/components/TaskGrowthChart.tsx b/cc-registry-v2/frontend/src/components/TaskGrowthChart.tsx index 686f5695b8d7..148569effbe2 100644 --- a/cc-registry-v2/frontend/src/components/TaskGrowthChart.tsx +++ b/cc-registry-v2/frontend/src/components/TaskGrowthChart.tsx @@ -98,7 +98,7 @@ const TaskGrowthChart: React.FC = () => { - Task Library Growth + Tool Library Growth @@ -124,7 +124,7 @@ const TaskGrowthChart: React.FC = () => { tickFormatter={(value) => value.toLocaleString()} /> [`${(value ?? 0).toLocaleString()} tasks`, 'Total Tasks']} + formatter={(value: number | undefined) => [`${(value ?? 0).toLocaleString()} Tools`, 'Total Tools']} contentStyle={{ backgroundColor: isDark ? '#2a2a2a' : 'rgba(255, 255, 255, 0.95)', border: `1px solid ${isDark ? '#444' : '#ccc'}`, diff --git a/cc-registry-v2/frontend/src/pages/AllTasks.tsx b/cc-registry-v2/frontend/src/pages/AllTasks.tsx index 96dd72e2aaf0..a712ba99985a 100644 --- a/cc-registry-v2/frontend/src/pages/AllTasks.tsx +++ b/cc-registry-v2/frontend/src/pages/AllTasks.tsx @@ -32,6 +32,7 @@ import { } from '@mui/icons-material'; import { apiService, Task, TasksResponse } from '../services/api'; import { useCart } from '../contexts/CartContext'; +import { labelForType } from '../lib/terminology'; type ViewMode = 'grouped' | 'presentation'; type SortOrder = 'alpha' | 'diverse' | 'codebundle'; @@ -263,10 +264,10 @@ const AllTasks: React.FC = () => { - All Tasks + All Skills - {filteredTasks.length} tasks across {Object.keys(groupedTasks).length} CodeBundles + {filteredTasks.length} Tools across {Object.keys(groupedTasks).length} Skill Templates @@ -282,7 +283,7 @@ const AllTasks: React.FC = () => { > Alphabetical Platform Diversity - By CodeBundle + By Skill Template )} @@ -307,7 +308,7 @@ const AllTasks: React.FC = () => { setTaskSearch(e.target.value)} InputProps={{ @@ -463,7 +464,7 @@ const AllTasks: React.FC = () => { ) : ( - No tasks found + No Tools found Try adjusting your search criteria or clearing filters. )} @@ -484,7 +485,7 @@ const AllTasks: React.FC = () => { - {Object.keys(groupedTasks).length} CodeBundle{Object.keys(groupedTasks).length !== 1 ? 's' : ''} • {filteredTasks.length} task{filteredTasks.length !== 1 ? 's' : ''} + {Object.keys(groupedTasks).length} Skill Template{Object.keys(groupedTasks).length !== 1 ? 's' : ''} • {filteredTasks.length} Tool{filteredTasks.length !== 1 ? 's' : ''} {selectedSupportTags.length > 0 && ` • ${selectedSupportTags.length} tag${selectedSupportTags.length > 1 ? 's' : ''}`} {selectedCollection && ` • ${selectedCollection}`} @@ -510,7 +511,7 @@ const AllTasks: React.FC = () => { {group.codebundle.name} - {group.codebundle.collection_name} • {group.tasks.filter(t => t.type === 'TaskSet').length} tasks • {group.tasks.filter(t => t.type === 'SLI').length} SLIs + {group.codebundle.collection_name} • {group.tasks.filter(t => t.type === 'TaskSet').length} Runbooks • {group.tasks.filter(t => t.type === 'SLI').length} Monitors @@ -540,7 +541,7 @@ const AllTasks: React.FC = () => { } }} > - {isInCart(group.codebundle.id) ? "Remove" : "Select CodeBundle"} + {isInCart(group.codebundle.id) ? "Remove" : "Select Skill Template"} )} {/* Show source indicator for all tool types */} @@ -541,7 +541,7 @@ const Chat: React.FC = () => { message.response.answer_source === 'documentation' ? 'Documentation' : message.response.answer_source === 'libraries' ? 'Libraries' : message.response.answer_source === 'system' ? 'System Info' : - message.response.answer_source === 'mixed' ? 'Docs + CodeBundles' : + message.response.answer_source === 'mixed' ? 'Docs + Skill Templates' : message.response.answer_source }`} size="small" @@ -594,12 +594,12 @@ const Chat: React.FC = () => { } }} > - Request CodeBundle + Request Skill Template } > - Can't find what you're looking for? Request a new CodeBundle for this use case. + Can't find what you're looking for? Request a new Skill Template for this use case. @@ -624,7 +624,7 @@ const Chat: React.FC = () => { )} - {message.response.relevant_tasks.length} related codebundle{message.response.relevant_tasks.length > 1 ? 's' : ''} + {message.response.relevant_tasks.length} related Skill Template{message.response.relevant_tasks.length > 1 ? 's' : ''} diff --git a/cc-registry-v2/frontend/src/pages/CodeBundleDetail.tsx b/cc-registry-v2/frontend/src/pages/CodeBundleDetail.tsx index 7981621090c5..031573044b12 100644 --- a/cc-registry-v2/frontend/src/pages/CodeBundleDetail.tsx +++ b/cc-registry-v2/frontend/src/pages/CodeBundleDetail.tsx @@ -48,6 +48,7 @@ import { import { useParams, Link, useNavigate } from 'react-router-dom'; import { apiService, CodeBundle } from '../services/api'; import { useCart } from '../contexts/CartContext'; +import { labelForType } from '../lib/terminology'; const CodeBundleDetail: React.FC = () => { const { collectionSlug, codebundleSlug } = useParams<{ collectionSlug: string; codebundleSlug: string }>(); @@ -97,7 +98,7 @@ const CodeBundleDetail: React.FC = () => { if (!codebundle) { return ( - CodeBundle not found + Skill Template not found ); } @@ -142,7 +143,7 @@ const CodeBundleDetail: React.FC = () => { } onClick={() => { // Create context string with codebundle details - const context = `I have a question about the "${codebundle.display_name}" CodeBundle from the ${codebundle.codecollection?.name || 'unknown'} collection.\n\nCodeBundle Details:\n- Description: ${codebundle.description || 'N/A'}\n- Platform: ${codebundle.discovery_platform || 'N/A'}\n- Tasks: ${codebundle.task_count || 0}\n- Access Level: ${codebundle.access_level || 'N/A'}`; + const context = `I have a question about the "${codebundle.display_name}" Skill Template from the ${codebundle.codecollection?.name || 'unknown'} collection.\n\nSkill Template Details:\n- Description: ${codebundle.description || 'N/A'}\n- Platform: ${codebundle.discovery_platform || 'N/A'}\n- Tools: ${codebundle.task_count || 0}\n- Access Level: ${codebundle.access_level || 'N/A'}`; navigate('/chat', { state: { @@ -424,24 +425,24 @@ const CodeBundleDetail: React.FC = () => { - Total Tasks + Total Tools {(codebundle.task_count || 0) + (codebundle.sli_count || 0)} {codebundle.task_count > 0 && codebundle.sli_count > 0 && ( - ({codebundle.task_count} TaskSet + {codebundle.sli_count} SLI) + ({codebundle.task_count} {labelForType('TaskSet')} + {codebundle.sli_count} {labelForType('SLI')}) )} {codebundle.task_count > 0 && !codebundle.sli_count && ( - (TaskSet) + ({labelForType('TaskSet')}) )} {!codebundle.task_count && codebundle.sli_count > 0 && ( - (SLI) + ({labelForType('SLI')}) )} @@ -513,7 +514,7 @@ const CodeBundleDetail: React.FC = () => { setMainTab(newValue)}> - + @@ -574,9 +575,9 @@ const CodeBundleDetail: React.FC = () => { - TaskSet ({codebundle.tasks.length}) + {labelForType('TaskSet')} ({codebundle.tasks.length}) @@ -589,9 +590,9 @@ const CodeBundleDetail: React.FC = () => { - SLI ({codebundle.slis.length}) + {labelForType('SLI')} ({codebundle.slis.length}) @@ -663,7 +664,7 @@ const CodeBundleDetail: React.FC = () => { ) : ( - No tasks or SLIs defined for this codebundle. + No Tools defined for this Skill Template. )} @@ -717,7 +718,7 @@ const CodeBundleDetail: React.FC = () => { No User Variables Documented - This CodeBundle may not require user-configured variables, or they have not been extracted yet. + This Skill Template may not require user-configured variables, or they have not been extracted yet. Check the source code on GitHub for the complete configuration requirements. {codebundle.codecollection?.git_url && ( @@ -769,10 +770,10 @@ const CodeBundleDetail: React.FC = () => { {codebundle.access_level === 'read-only' - ? 'This CodeBundle requires read-only access to resources. It will not make changes to your infrastructure.' + ? 'This Skill Template requires read-only access to resources. It will not make changes to your infrastructure.' : codebundle.access_level === 'read-write' - ? 'This CodeBundle requires read-write access and may modify resources in your infrastructure.' - : 'Access level requirements for this CodeBundle.'} + ? 'This Skill Template requires read-write access and may modify resources in your infrastructure.' + : 'Access level requirements for this Skill Template.'} )} @@ -793,7 +794,7 @@ const CodeBundleDetail: React.FC = () => { /> - The following IAM permissions are required to execute this CodeBundle: + The following IAM permissions are required to execute this Skill Template: { {!codebundle.access_level && (!codebundle.minimum_iam_requirements || codebundle.minimum_iam_requirements.length === 0) && ( - No specific security requirements have been documented for this CodeBundle. + No specific security requirements have been documented for this Skill Template. )} @@ -880,9 +881,9 @@ const CodeBundleDetail: React.FC = () => { - Tasks: {codebundle.task_count} task{codebundle.task_count !== 1 ? 's' : ''} - {codebundle.tasks && codebundle.tasks.length > 0 && ` (${codebundle.tasks.length} TaskSet)`} - {codebundle.slis && codebundle.slis.length > 0 && ` + ${codebundle.slis.length} SLI`} + Tools: {codebundle.task_count} Tool{codebundle.task_count !== 1 ? 's' : ''} + {codebundle.tasks && codebundle.tasks.length > 0 && ` (${codebundle.tasks.length} ${labelForType('TaskSet', codebundle.tasks.length !== 1)})`} + {codebundle.slis && codebundle.slis.length > 0 && ` + ${codebundle.slis.length} ${labelForType('SLI', codebundle.slis.length !== 1)}`} {codebundle.configuration_type?.platform && codebundle.configuration_type.platform !== 'Unknown' && ( @@ -926,7 +927,7 @@ const CodeBundleDetail: React.FC = () => { - Enhanced Task Details ({codebundle.ai_enhanced_metadata.enhanced_tasks.length}) + Enhanced Tool Details ({codebundle.ai_enhanced_metadata.enhanced_tasks.length}) diff --git a/cc-registry-v2/frontend/src/pages/CodeBundles.tsx b/cc-registry-v2/frontend/src/pages/CodeBundles.tsx index 95b47bcd16e8..d3a97c31d318 100644 --- a/cc-registry-v2/frontend/src/pages/CodeBundles.tsx +++ b/cc-registry-v2/frontend/src/pages/CodeBundles.tsx @@ -103,7 +103,7 @@ const CodeBundles: React.FC = () => { setCodebundles(codebundlesData.codebundles); setTotalCount(codebundlesData.total_count); } catch (err) { - setError('Failed to load codebundles'); + setError('Failed to load Skill Templates'); console.error('Error fetching data:', err); } finally { setInitialLoading(false); @@ -156,12 +156,12 @@ const CodeBundles: React.FC = () => { - All CodeBundles + All Skill Templates {searching && } - {searching ? 'Searching...' : `${totalCount} codebundle${totalCount !== 1 ? 's' : ''} found`} + {searching ? 'Searching...' : `${totalCount} Skill Template${totalCount !== 1 ? 's' : ''} found`} @@ -182,7 +182,7 @@ const CodeBundles: React.FC = () => { {/* Row 1: Search and Collection */} { setSearchTerm(e.target.value); setPage(1); }} InputProps={{ @@ -228,7 +228,7 @@ const CodeBundles: React.FC = () => { > Name (A-Z) Recently Updated - Most Tasks + Most Tools @@ -340,10 +340,10 @@ const CodeBundles: React.FC = () => { - {(codebundle.task_count || 0) + (codebundle.sli_count || 0)} task{((codebundle.task_count || 0) + (codebundle.sli_count || 0)) !== 1 ? 's' : ''} + {(codebundle.task_count || 0) + (codebundle.sli_count || 0)} Tool{((codebundle.task_count || 0) + (codebundle.sli_count || 0)) !== 1 ? 's' : ''} {codebundle.sli_count > 0 && ( - ({codebundle.sli_count} SLI) + ({codebundle.sli_count} Monitor{codebundle.sli_count !== 1 ? 's' : ''}) )} @@ -363,7 +363,7 @@ const CodeBundles: React.FC = () => { {codebundles.length === 0 && !searching && ( - No codebundles found + No Skill Templates found Try adjusting your filters or search terms diff --git a/cc-registry-v2/frontend/src/pages/Home.tsx b/cc-registry-v2/frontend/src/pages/Home.tsx index a88d3d3b14e2..32a4b7c2db41 100644 --- a/cc-registry-v2/frontend/src/pages/Home.tsx +++ b/cc-registry-v2/frontend/src/pages/Home.tsx @@ -320,18 +320,18 @@ const Home: React.FC = () => { {[ { icon: CollectionIcon, label: 'CodeCollections', count: stats?.collections || 0, to: '/collections', - desc: 'Groups of bundles by provider', - tooltip: 'CodeCollections group related CodeBundles by technology or provider — like aws-codecollection or k8s-codecollection. Each collection is backed by a Git repository maintained by the community.', + desc: 'Groups of Skill Templates by provider', + tooltip: 'CodeCollections group related Skill Templates by technology or provider — like aws-codecollection or k8s-codecollection. Each collection is backed by a Git repository maintained by the community.', }, { - icon: BundleIcon, label: 'CodeBundles', count: stats?.codebundles || 0, to: '/codebundles', + icon: BundleIcon, label: 'Skill Templates', count: stats?.codebundles || 0, to: '/codebundles', desc: 'Scripted automation packages', - tooltip: 'A CodeBundle is a self-contained automation package that targets a specific service or resource — like "Postgres Health" or "AKS Triage." Each bundle contains one or more executable tasks, configuration variables, and documentation.', + tooltip: 'A Skill Template is a self-contained automation package that targets a specific service or resource — like "Postgres Health" or "AKS Triage." Each Skill Template contains one or more executable Tools, configuration variables, and documentation.', }, { - icon: TaskIcon, label: 'Tasks', count: stats?.tasks || 0, to: '/all-tasks', + icon: TaskIcon, label: 'Tools', count: stats?.tasks || 0, to: '/all-tasks', desc: 'CLI & API actions to run', - tooltip: 'Tasks are the runnable units inside a CodeBundle. Each task is a scripted action — CLI commands, API calls, or queries — that performs a specific operation like "Check Pod Restarts" or "Query Connection Pool." Tasks run on private runners in your environment.', + tooltip: 'Tools are the runnable units inside a Skill Template. Each Tool is a scripted action — CLI commands, API calls, or queries — that performs a specific operation like "Check Pod Restarts" or "Query Connection Pool." Tools are either Runbooks (run on demand in response to an event) or Monitors (run on a schedule, emit a 0-1 health score). They execute on private runners in your environment.', }, { icon: DocsIcon, label: 'Docs', count: null, to: '/chat', @@ -608,7 +608,7 @@ const Home: React.FC = () => { letterSpacing: '-0.2px' }} > - Recently Updated CodeBundles + Recently Updated Skill Templates @@ -737,7 +737,7 @@ const Home: React.FC = () => { letterSpacing: '-0.2px' }} > - Recently Updated Tasks + Recently Updated Tools @@ -881,7 +881,7 @@ const Home: React.FC = () => { } }} > - Browse All CodeBundles + Browse All Skill Templates - We search existing CodeBundles first, then create your request with the results attached for the designer. + We search existing Skill Templates first, then create your request with the results attached for the designer. diff --git a/cc-registry-v2/sources.yaml b/cc-registry-v2/sources.yaml index 1cf742a77891..50527ce1285a 100644 --- a/cc-registry-v2/sources.yaml +++ b/cc-registry-v2/sources.yaml @@ -36,12 +36,15 @@ sources: - variables priority: medium - - name: Task and SLI Development + - name: Tool Development (Runbooks and Monitors) url: https://docs.runwhen.com/authors/codebundle-basics - description: Creating tasks for automation and SLIs (Service Level Indicators) for monitoring + description: Creating Tools for automation — Runbooks (formerly "TaskSets", on-demand) and Monitors (formerly "SLIs" / Service Level Indicators, scheduled, 0-1 numeric output) topics: - tasks + - tools + - runbooks - slis + - monitors - metrics - monitoring - health-checks @@ -49,7 +52,7 @@ sources: - name: Generation Rules and Discovery url: https://docs.runwhen.com/authors/generation-rules - description: How to configure CodeBundles for automatic discovery and generation of workspace items + description: How to configure Skill Templates (formerly "CodeBundles") for automatic discovery and generation of workspace items topics: - discovery - automation @@ -325,25 +328,29 @@ sources: - tasks priority: high - - name: SLI Development Guide + - name: Monitor (SLI) Development Guide url: https://docs.runwhen.com/public/runwhen-authors/codebundle-development/sli-development - description: Guide to creating Service Level Indicator (SLI) CodeBundles that measure metrics and return numeric values for monitoring + description: Guide to creating Monitors (formerly "SLIs" / Service Level Indicators) - Tools that measure metrics on a schedule and return numeric 0-1 health values for continuous monitoring topics: - sli + - monitor - service-level-indicator - metrics - monitoring + - scheduled - sli.robot priority: high - - name: TaskSet Development Guide + - name: Runbook (TaskSet) Development Guide url: https://docs.runwhen.com/public/runwhen-authors/codebundle-development/taskset-development - description: Guide to creating TaskSet CodeBundles for automated runbooks with multiple tasks for troubleshooting and remediation + description: Guide to creating Runbooks (formerly "TaskSets") - on-demand Skill Templates containing multiple Tools for troubleshooting and remediation topics: - taskset - runbook - automation - tasks + - tools + - on-demand - remediation - runbook.robot priority: high @@ -449,7 +456,7 @@ sources: For GCP: Use the gcp-service-account secret type For Azure: Use the azure-credentials secret type - These are automatically injected into your CodeBundle's environment. + These are automatically injected into your Skill Template's (CodeBundle's) environment. topics: - credentials - aws @@ -457,27 +464,30 @@ sources: - azure - secrets - - question: How do I create an SLI vs a Task? + - question: How do I create a Monitor vs a Runbook? answer: | - SLIs (Service Level Indicators) return a numeric metric value (0-1 or percentage). - Tasks perform actions and may return success/failure. + Monitors (formerly "SLIs" / Service Level Indicators) return a numeric metric value (0-1 or percentage) and run on a schedule. + Runbooks (formerly "TaskSets") run on demand in response to events and emit structured findings with next steps. In your robot file: - - SLI: Use the `sli.robot` filename and return a numeric value - - Task: Use `runbook.robot` or `taskset.robot` and perform automation + - Monitor: Use the `sli.robot` filename and return a numeric value (the on-disk filename stays `sli.robot` for backward compatibility) + - Runbook: Use `runbook.robot` and perform automation topics: - sli - - task + - monitor + - taskset + - runbook + - tool - monitoring - automation - - question: How do I debug a CodeBundle? + - question: How do I debug a Skill Template? answer: | - Tips for debugging CodeBundles: + Tips for debugging Skill Templates (formerly "CodeBundles"): 1. Use Log statements to output variable values 2. Test locally with: robot --variable NAMESPACE:default sli.robot 3. Check the RunSession logs in the RunWhen platform - 4. Use RunWhen Local to test CodeBundles against real infrastructure + 4. Use RunWhen Local to test Skill Templates against real infrastructure 5. Add RW.Core.Add Pre To Report for detailed output topics: - debug @@ -486,15 +496,15 @@ sources: - logs - testing - - question: What is the difference between SLI and TaskSet? + - question: What is the difference between a Monitor and a Runbook? answer: | - SLI (Service Level Indicator) CodeBundles measure a metric and return a numeric value (0-1 or percentage). - They are used for continuous monitoring and alerting. + Monitors (formerly "SLIs" / Service Level Indicators) measure a metric and return a numeric value (0-1 or percentage). + They are Tools that run on a schedule, continuously, in the background. Used for monitoring and alerting. - TaskSet CodeBundles run automated runbooks with multiple tasks that can be triggered on-demand or - automatically. They are used for remediation and troubleshooting. + Runbooks (formerly "TaskSets") run on demand in response to an event or request, containing one or more Tools + for troubleshooting and remediation. They emit structured findings with next-steps. - Use SLIs for monitoring, TaskSets for remediation. + Use Monitors for continuous scheduled measurement, Runbooks for on-demand remediation. topics: - sli - taskset diff --git a/cc-registry/templates/codebundle-index-template.j2 b/cc-registry/templates/codebundle-index-template.j2 index ec3709d6b547..909faa27c3ef 100644 --- a/cc-registry/templates/codebundle-index-template.j2 +++ b/cc-registry/templates/codebundle-index-template.j2 @@ -9,32 +9,32 @@ ## Available Pages {% endif %} {% if tasks %} -## Tasks +## Runbooks (Tools) {% else %} -_No tasks available._ +_No Runbooks available._ {% endif %} {% if slis %} -## Service Level Indicators (SLIs) +## Monitors {% else %} -_No SLIs available._ +_No Monitors available._ {% endif %} diff --git a/mcp-server/docs.yaml b/mcp-server/docs.yaml index fe003753b90f..36c3ccf65770 100644 --- a/mcp-server/docs.yaml +++ b/mcp-server/docs.yaml @@ -6,41 +6,47 @@ documentation: codebundle_development: - name: CodeBundle Development Guide url: https://docs.runwhen.com/public/runwhen-authors/codebundle-development - description: Complete guide to developing RunWhen CodeBundles including structure, syntax, and best practices + description: Complete guide to developing RunWhen Skill Templates (formerly "CodeBundles") including structure, syntax, and best practices keywords: - development - best-practices - getting-started - structure - codebundle + - skill-template - name: Robot Framework Basics url: https://docs.runwhen.com/public/runwhen-authors/codebundle-development/robot-framework-basics - description: Introduction to Robot Framework syntax for CodeBundle development + description: Introduction to Robot Framework syntax for Skill Template (formerly "CodeBundle") development keywords: - robot - robot-framework - syntax - keywords - tasks + - tools - name: SLI Development url: https://docs.runwhen.com/public/runwhen-authors/codebundle-development/sli-development - description: Guide to creating Service Level Indicator (SLI) CodeBundles + description: Guide to creating Monitors (formerly "SLIs" / Service Level Indicators) - Tools that run on a schedule and emit a 0-1 numeric health value keywords: - sli + - monitor - service-level-indicator - metrics - monitoring + - scheduled - name: TaskSet Development url: https://docs.runwhen.com/public/runwhen-authors/codebundle-development/taskset-development - description: Guide to creating TaskSet CodeBundles for automated runbooks + description: Guide to creating Runbooks (formerly "TaskSets") - Tools that run on demand in response to events and emit structured findings keywords: - taskset - runbook - automation - tasks + - tools + - on-demand libraries: - name: RW.CLI Library diff --git a/mcp-server/server.py b/mcp-server/server.py index f625f562d599..e7fc482aa68c 100755 --- a/mcp-server/server.py +++ b/mcp-server/server.py @@ -33,7 +33,7 @@ async def list_tools() -> List[Tool]: Tool( name="list_codebundles", description=( - "List all codebundles and codecollections. " + "List all Skill Templates (formerly 'CodeBundles') and CodeCollections. " "Supports filtering by collection and output formatting." ), inputSchema={ @@ -47,7 +47,7 @@ async def list_tools() -> List[Tool]: }, "collection_slug": { "type": "string", - "description": "Filter by codecollection slug (optional)" + "description": "Filter by CodeCollection slug (optional)" } } } @@ -55,8 +55,8 @@ async def list_tools() -> List[Tool]: Tool( name="search_codebundles", description=( - "Search for codebundles by keywords, tags, or use case. " - "Returns relevant codebundles with relevance scoring." + "Search for Skill Templates (formerly 'CodeBundles') by keywords, tags, or use case. " + "Returns relevant Skill Templates with relevance scoring." ), inputSchema={ "type": "object", @@ -85,13 +85,13 @@ async def list_tools() -> List[Tool]: ), Tool( name="get_codebundle_details", - description="Get detailed information about a specific codebundle", + description="Get detailed information about a specific Skill Template (formerly 'CodeBundle')", inputSchema={ "type": "object", "properties": { "slug": { "type": "string", - "description": "Codebundle slug" + "description": "Skill Template slug" }, "collection_slug": { "type": "string", @@ -103,7 +103,7 @@ async def list_tools() -> List[Tool]: ), Tool( name="list_codecollections", - description="List all available codecollections", + description="List all available CodeCollections", inputSchema={ "type": "object", "properties": { @@ -208,14 +208,14 @@ async def handle_list_codebundles(arguments: Dict[str, Any]) -> List[TextContent elif format_type == "summary": result = f"# RunWhen Registry Summary\n\n" result += f"**Total CodeCollections:** {len(collections)}\n" - result += f"**Total CodeBundles:** {len(codebundles)}\n\n" + result += f"**Total Skill Templates:** {len(codebundles)}\n\n" for cc in collections: cc_bundles = [cb for cb in codebundles if cb.get("collection_slug") == cc["slug"]] - result += f"- **{cc['name']}** ({cc['slug']}): {len(cc_bundles)} codebundles\n" + result += f"- **{cc['name']}** ({cc['slug']}): {len(cc_bundles)} Skill Templates\n" else: # markdown - result = "# RunWhen CodeCollections and CodeBundles\n\n" + result = "# RunWhen CodeCollections and Skill Templates\n\n" # Group codebundles by collection for cc in collections: @@ -225,7 +225,7 @@ async def handle_list_codebundles(arguments: Dict[str, Any]) -> List[TextContent result += f"**Slug:** `{cc['slug']}`\n\n" result += f"**Description:** {cc.get('description', 'N/A')}\n\n" result += f"**Repository:** {cc.get('git_url', 'N/A')}\n\n" - result += f"**CodeBundles ({len(cc_bundles)}):**\n\n" + result += f"**Skill Templates ({len(cc_bundles)}):**\n\n" if cc_bundles: for cb in cc_bundles: @@ -237,14 +237,14 @@ async def handle_list_codebundles(arguments: Dict[str, Any]) -> List[TextContent result += f"- **Use Cases:** {', '.join(cb.get('use_cases', []))}\n" if cb.get('tasks'): - result += f"- **Tasks:** {len(cb['tasks'])} task(s)\n" + result += f"- **Tools:** {len(cb['tasks'])} Runbook(s)\n" if cb.get('documentation_url'): result += f"- **Documentation:** {cb['documentation_url']}\n" result += "\n" else: - result += "*No codebundles found*\n\n" + result += "*No Skill Templates found*\n\n" return [TextContent(type="text", text=result)] @@ -270,10 +270,10 @@ async def handle_search_codebundles(arguments: Dict[str, Any]) -> List[TextConte # Format results if not results: - return [TextContent(type="text", text=f"No codebundles found matching query: {query}")] + return [TextContent(type="text", text=f"No Skill Templates found matching query: {query}")] output = f"# Search Results for: {query}\n\n" - output += f"Found {len(results)} relevant codebundle(s):\n\n" + output += f"Found {len(results)} relevant Skill Template(s):\n\n" for i, cb in enumerate(results, 1): output += f"## {i}. {cb.get('display_name', cb.get('name'))}\n\n" @@ -286,8 +286,8 @@ async def handle_search_codebundles(arguments: Dict[str, Any]) -> List[TextConte output += f"- **Access Level:** {cb.get('access_level', 'unknown')}\n" if cb.get('tasks'): - output += f"- **Tasks ({len(cb['tasks'])}):**\n" - for task in cb['tasks'][:3]: # Show first 3 tasks + output += f"- **Runbooks ({len(cb['tasks'])}):**\n" + for task in cb['tasks'][:3]: # Show first 3 Runbooks task_name = task.get('name', task) if isinstance(task, dict) else task output += f" - {task_name}\n" if len(cb['tasks']) > 3: @@ -313,7 +313,7 @@ async def handle_get_codebundle_details(arguments: Dict[str, Any]) -> List[TextC cb = data_loader.get_codebundle_by_slug(slug, collection_slug) if not cb: - return [TextContent(type="text", text=f"Codebundle not found: {slug}")] + return [TextContent(type="text", text=f"Skill Template not found: {slug}")] # Format detailed output output = f"# {cb.get('display_name', cb.get('name'))}\n\n" @@ -328,8 +328,11 @@ async def handle_get_codebundle_details(arguments: Dict[str, Any]) -> List[TextC output += f"- **Support Tags:** {', '.join(cb.get('support_tags', []))}\n" output += f"- **Use Cases:** {', '.join(cb.get('use_cases', []))}\n\n" + # Internal field names `tasks` and `slis` are kept for backward + # compatibility; the markdown labels use the new display vocabulary + # (Runbook = TaskSet, Monitor = SLI). See mcp-server/utils/terminology.py. if cb.get('tasks'): - output += f"## Tasks ({len(cb['tasks'])})\n\n" + output += f"## Runbooks ({len(cb['tasks'])})\n\n" for task in cb['tasks']: if isinstance(task, dict): output += f"### {task.get('name')}\n\n" @@ -341,7 +344,7 @@ async def handle_get_codebundle_details(arguments: Dict[str, Any]) -> List[TextC output += "\n" if cb.get('slis'): - output += f"## SLIs (Service Level Indicators)\n\n" + output += f"## Monitors\n\n" for sli in cb['slis']: output += f"- {sli}\n" output += "\n" @@ -391,7 +394,7 @@ async def handle_list_codecollections(arguments: Dict[str, Any]) -> List[TextCon result += f"- **Owner:** {cc.get('owner', 'N/A')}\n" result += f"- **Primary Language:** {cc.get('primary_language', 'N/A')}\n" result += f"- **Tags:** {', '.join(cc.get('tags', []))}\n" - result += f"- **Codebundle Count:** {cc.get('codebundle_count', 0)}\n\n" + result += f"- **Skill Template Count:** {cc.get('codebundle_count', 0)}\n\n" return [TextContent(type="text", text=result)] diff --git a/mcp-server/tools/codebundle_tools.py b/mcp-server/tools/codebundle_tools.py index f2fed62e7f4a..a654664c6f2f 100644 --- a/mcp-server/tools/codebundle_tools.py +++ b/mcp-server/tools/codebundle_tools.py @@ -1,8 +1,10 @@ """ -CodeBundle Tools +Skill Template Tools (internal class names preserved for backward compatibility). -Tools for finding, listing, and getting details about CodeBundles. -All data is fetched from the Registry API. +Tools for finding, listing, and getting details about Skill Templates +(internally still called ``CodeBundle`` everywhere — see Phase 1 cosmetic +rename notes in ``mcp-server/utils/terminology.py``). All data is fetched +from the Registry API. """ import json import logging @@ -50,8 +52,8 @@ def _extract_search_keywords(query: str) -> str: class FindCodeBundleTool(BaseTool): """ - Search to find codebundles matching natural language queries. - Delegates search to the Registry API. + Search to find Skill Templates (formerly "CodeBundles") matching + natural language queries. Delegates search to the Registry API. """ def __init__(self, registry_client): @@ -61,7 +63,7 @@ def __init__(self, registry_client): def definition(self) -> ToolDefinition: return ToolDefinition( name="find_codebundle", - description="Find codebundles for your use case. Describe what you need in natural language. Examples: 'troubleshoot Kubernetes pods', 'monitor AWS EKS', 'check database health'", + description="Find Skill Templates (formerly 'CodeBundles') for your use case. A Skill Template is a reusable package of Tools — Runbooks that run on demand and Monitors that run on a schedule. Describe what you need in natural language. Examples: 'troubleshoot Kubernetes pods', 'monitor AWS EKS', 'check database health'.", category="search", parameters=[ ToolParameter( @@ -131,7 +133,7 @@ async def execute( pass if not results: - return f"No codebundles found matching: {query}\n\nTry rephrasing your query or using broader terms." + return f"No Skill Templates found matching: {query}\n\nTry rephrasing your query or using broader terms." # Compute relevance scores. The backend already sorts by weighted # field relevance, so we use position-based scoring that preserves @@ -140,8 +142,8 @@ async def execute( # matched via a long description field). search_kws = [w.lower() for w in search_terms.split() if len(w) >= 2] - output = f"# CodeBundles for: {query}\n\n" - output += f"Found {len(results)} matching codebundle(s):\n\n" + output = f"# Skill Templates for: {query}\n\n" + output += f"Found {len(results)} matching Skill Template(s):\n\n" for i, cb in enumerate(results, 1): display_name = cb.get('display_name') or cb.get('name') or cb.get('slug', 'Unknown') @@ -174,9 +176,14 @@ async def execute( if description: output += f"**Description:** {description[:500]}\n\n" + # The Registry API's `tasks` field contains the Runbook entries + # parsed from runbook.robot (TaskSet type). SLI / Monitor entries + # live in a separate `slis` field. Internal field names are kept + # for backward compatibility; the markdown label uses the new + # display vocabulary. tasks = cb.get('tasks', []) if tasks: - output += "**Tasks:**\n" + output += "**Runbooks:**\n" for task in tasks[:8]: task_name = task if isinstance(task, str) else task.get('name', str(task)) output += f"- {task_name}\n" @@ -199,7 +206,7 @@ async def execute( class ListCodeBundlesTool(BaseTool): - """List all codebundles, optionally filtered by collection.""" + """List all Skill Templates (formerly "CodeBundles"), optionally filtered by collection.""" def __init__(self, registry_client): self._client = registry_client @@ -208,7 +215,7 @@ def __init__(self, registry_client): def definition(self) -> ToolDefinition: return ToolDefinition( name="list_codebundles", - description="List all codebundles and codecollections. Supports filtering by collection and output formatting.", + description="List all Skill Templates (formerly 'CodeBundles') and CodeCollections. Supports filtering by collection and output formatting.", category="info", parameters=[ ToolParameter( @@ -233,7 +240,7 @@ async def execute( format: str = "markdown", collection_slug: Optional[str] = None ) -> str: - """List codebundles from the Registry API.""" + """List Skill Templates from the Registry API.""" try: codebundles = await self._client.search_codebundles( collection_slug=collection_slug, @@ -241,7 +248,7 @@ async def execute( ) except Exception as e: logger.error(f"Registry API list failed: {e}") - return f"Failed to list codebundles: {e}" + return f"Failed to list Skill Templates: {e}" if format == "json": return json.dumps({"codebundles": codebundles, "count": len(codebundles)}, indent=2, default=str) @@ -254,14 +261,14 @@ async def execute( by_collection[coll] = [] by_collection[coll].append(cb) - output = f"# CodeBundle Summary\n\n" - output += f"Total: {len(codebundles)} codebundles in {len(by_collection)} collections\n\n" + output = f"# Skill Template Summary\n\n" + output += f"Total: {len(codebundles)} Skill Templates in {len(by_collection)} CodeCollections\n\n" for coll, cbs in sorted(by_collection.items()): - output += f"## {coll} ({len(cbs)} codebundles)\n\n" + output += f"## {coll} ({len(cbs)} Skill Templates)\n\n" return output # Markdown format - output = f"# Available CodeBundles ({len(codebundles)})\n\n" + output = f"# Available Skill Templates ({len(codebundles)})\n\n" for cb in codebundles[:50]: display_name = cb.get('display_name') or cb.get('name') or cb.get('slug') output += f"### **{display_name}**\n" @@ -278,7 +285,7 @@ async def execute( class SearchCodeBundlesTool(BaseTool): - """Keyword-based search for codebundles.""" + """Keyword-based search for Skill Templates (formerly "CodeBundles").""" def __init__(self, registry_client): self._client = registry_client @@ -287,7 +294,7 @@ def __init__(self, registry_client): def definition(self) -> ToolDefinition: return ToolDefinition( name="search_codebundles", - description="Search for codebundles by keywords, tags, or platform.", + description="Search for Skill Templates (formerly 'CodeBundles') by keywords, tags, or platform.", category="search", parameters=[ ToolParameter( @@ -340,7 +347,7 @@ async def execute( return f"Search unavailable: {e}" if not results: - return f"No codebundles found matching: {query}" + return f"No Skill Templates found matching: {query}" output = f"# Search Results: {query}\n\n" output += f"Found {len(results)} result(s):\n\n" @@ -362,7 +369,7 @@ async def execute( class GetCodeBundleDetailsTool(BaseTool): - """Get detailed information about a specific codebundle.""" + """Get detailed information about a specific Skill Template (formerly "CodeBundle").""" def __init__(self, registry_client): self._client = registry_client @@ -371,13 +378,13 @@ def __init__(self, registry_client): def definition(self) -> ToolDefinition: return ToolDefinition( name="get_codebundle_details", - description="Get detailed information about a specific codebundle", + description="Get detailed information about a specific Skill Template (formerly 'CodeBundle')", category="info", parameters=[ ToolParameter( name="slug", type="string", - description="CodeBundle slug", + description="Skill Template slug", required=True ), ToolParameter( @@ -394,7 +401,7 @@ async def execute( slug: str, collection_slug: Optional[str] = None ) -> str: - """Get codebundle details from the Registry API.""" + """Get Skill Template details from the Registry API.""" cb = None # Try direct lookup if we have both slugs @@ -402,7 +409,7 @@ async def execute( try: cb = await self._client.get_codebundle(collection_slug, slug) except Exception as e: - logger.warning(f"Direct codebundle lookup failed: {e}") + logger.warning(f"Direct Skill Template lookup failed: {e}") # Fall back to search if not cb: @@ -413,11 +420,11 @@ async def execute( cb = r break except Exception as e: - logger.error(f"Codebundle search failed: {e}") - return f"Failed to fetch codebundle: {e}" + logger.error(f"Skill Template search failed: {e}") + return f"Failed to fetch Skill Template: {e}" if not cb: - return f"CodeBundle not found: {slug}" + return f"Skill Template not found: {slug}" display_name = cb.get('display_name') or cb.get('name') or cb.get('slug') output = f"# **{display_name}**\n\n" @@ -432,9 +439,11 @@ async def execute( if description: output += f"## Description\n\n{description}\n\n" + # Internal field name `tasks` is kept for backward compatibility; the + # markdown label uses the new display vocabulary. tasks = cb.get('tasks', []) if tasks: - output += f"## Tasks ({len(tasks)})\n\n" + output += f"## Runbooks ({len(tasks)})\n\n" for task in tasks: task_name = task if isinstance(task, str) else task.get('name', str(task)) output += f"- {task_name}\n" diff --git a/mcp-server/tools/github_issue.py b/mcp-server/tools/github_issue.py index 09ad466fe851..39bd7827bbba 100644 --- a/mcp-server/tools/github_issue.py +++ b/mcp-server/tools/github_issue.py @@ -1,8 +1,10 @@ """ GitHub Issue Tools -Creates CodeBundle request issues on GitHub when semantic search -fails to find matching codebundles. +Creates Skill Template request issues on GitHub when semantic search +fails to find matching Skill Templates (internally still called +``CodeBundle`` for backward compatibility -- see Phase 1 cosmetic +rename notes in ``mcp-server/utils/terminology.py``). Uses the codebundle-wanted.yaml template format from: https://github.com/runwhen-contrib/codecollection-registry/blob/main/.github/ISSUE_TEMPLATE/codebundle-wanted.yaml @@ -31,9 +33,13 @@ @dataclass class CodeBundleRequest: - """Data for a new CodeBundle request issue.""" + """Data for a new Skill Template (formerly "CodeBundle") request issue. + + Class name is preserved for backward compatibility with existing + callers; the user-facing vocabulary is "Skill Template". + """ platform: str # What cloud platform(s) should this support? - tasks: List[str] # Key tasks that should be performed + tasks: List[str] # Key Tools that should be performed original_query: Optional[str] = None # The user's original search query context: Optional[str] = None # Any other helpful context contact_ok: bool = False # Willing to be contacted? @@ -167,9 +173,9 @@ def is_configured(self) -> bool: return bool(self._app_mgr and self._app_mgr.available) or bool(self.token) def _format_tasks(self, tasks: List[str]) -> str: - """Format tasks as a numbered list.""" + """Format Tools as a numbered list.""" if not tasks: - return "No specific tasks provided" + return "No specific Tools provided" return "\n".join(f"{i+1}. {task}" for i, task in enumerate(tasks)) def _build_issue_body(self, request: CodeBundleRequest) -> str: @@ -183,8 +189,8 @@ def _build_issue_body(self, request: CodeBundleRequest) -> str: # Cloud platform(s) sections.append(f"## What cloud platform(s) should this support?\n{request.platform}") - # Key tasks - sections.append(f"## What are some key tasks that should be performed?\n{self._format_tasks(request.tasks)}") + # Key Tools (Runbooks/Monitors) + sections.append(f"## What are some key Tools that should be performed?\n{self._format_tasks(request.tasks)}") # Additional context if request.context: @@ -320,15 +326,16 @@ def get_github_tool() -> GitHubIssueClient: class RequestCodeBundleTool(BaseTool): """ - Request a new CodeBundle by creating a GitHub issue. - Use this when no existing CodeBundle matches the user's needs. + Request a new Skill Template (formerly "CodeBundle") by creating a + GitHub issue. Use this when no existing Skill Template matches the + user's needs. """ @property def definition(self) -> ToolDefinition: return ToolDefinition( name="request_codebundle", - description="Request a new CodeBundle from the community by creating a GitHub issue. Use this when no existing CodeBundle matches the user's needs.", + description="Request a new Skill Template (formerly 'CodeBundle') from the community by creating a GitHub issue. Use this when no existing Skill Template matches the user's needs.", category="action", parameters=[ ToolParameter( @@ -340,7 +347,7 @@ def definition(self) -> ToolDefinition: ToolParameter( name="tasks", type="array", - description="List of key tasks that should be performed", + description="List of key Tools (Runbooks or Monitors) that should be performed", required=True, items="string" ), @@ -374,7 +381,7 @@ async def execute( context: Optional[str] = None, contact_ok: bool = False ) -> str: - """Create a GitHub issue for a new CodeBundle request""" + """Create a GitHub issue for a new Skill Template request""" client = get_github_client() if not client.is_configured(): @@ -391,7 +398,7 @@ async def execute( result = client.create_issue(request) if result["success"]: - return f"""# CodeBundle Request Created! + return f"""# Skill Template Request Created! Your request has been submitted successfully. @@ -413,13 +420,13 @@ async def execute( class CheckExistingRequestsTool(BaseTool): - """Check if there are existing CodeBundle requests similar to what the user needs.""" + """Check if there are existing Skill Template (formerly "CodeBundle") requests similar to what the user needs.""" @property def definition(self) -> ToolDefinition: return ToolDefinition( name="check_existing_requests", - description="Check if there are existing CodeBundle requests similar to what the user needs", + description="Check if there are existing Skill Template (formerly 'CodeBundle') requests similar to what the user needs", category="info", parameters=[ ToolParameter( @@ -432,13 +439,13 @@ def definition(self) -> ToolDefinition: ) async def execute(self, search_term: str) -> str: - """Check for existing CodeBundle requests""" + """Check for existing Skill Template requests""" client = get_github_client() existing = client.check_existing_issues(search_term) if existing: - output = f"# Existing CodeBundle Requests for: {search_term}\n\n" + output = f"# Existing Skill Template Requests for: {search_term}\n\n" output += f"Found {len(existing)} related open issue(s):\n\n" for issue in existing: @@ -448,4 +455,4 @@ async def execute(self, search_term: str) -> str: output += "\nConsider commenting on an existing issue if it matches your needs, or create a new request if yours is different." return output else: - return f"No existing open requests found for '{search_term}'.\n\nYou can create a new CodeBundle request using the request_codebundle tool." + return f"No existing open requests found for '{search_term}'.\n\nYou can create a new Skill Template request using the request_codebundle tool." From ac3346ca09ac81dbfdc8e0f97e20c5dd55647b55 Mon Sep 17 00:00:00 2001 From: stewartshea Date: Fri, 22 May 2026 23:35:07 -0400 Subject: [PATCH 3/4] Update .gitignore to un-ignore frontend source tree for lib directory - Explicitly un-ignored the `frontend/src/lib/` directory to ensure that any files added under this path are committed, preventing accidental exclusion during version control. - This change addresses potential issues with the bare `lib/` and `lib64/` rules that previously matched unintended paths. --- cc-registry-v2/.gitignore | 7 ++ .../frontend/src/lib/terminology.ts | 86 +++++++++++++++++++ 2 files changed, 93 insertions(+) create mode 100644 cc-registry-v2/frontend/src/lib/terminology.ts diff --git a/cc-registry-v2/.gitignore b/cc-registry-v2/.gitignore index 7d4f4e44396c..6fe21bfd32d0 100644 --- a/cc-registry-v2/.gitignore +++ b/cc-registry-v2/.gitignore @@ -70,6 +70,13 @@ frontend/.env.development.local frontend/.env.test.local frontend/.env.production.local +# The bare `lib/` and `lib64/` rules above (Python setuptools build dirs) +# are unanchored, so they accidentally match `frontend/src/lib/`. Un-ignore +# the frontend source tree explicitly. Anything we add under +# `frontend/src/lib/` (e.g. terminology.ts) must be committed. +!frontend/src/lib/ +!frontend/src/lib/** + # Testing .coverage .pytest_cache/ diff --git a/cc-registry-v2/frontend/src/lib/terminology.ts b/cc-registry-v2/frontend/src/lib/terminology.ts new file mode 100644 index 000000000000..bf3d23dbf4c7 --- /dev/null +++ b/cc-registry-v2/frontend/src/lib/terminology.ts @@ -0,0 +1,86 @@ +/** + * Centralised display-label map for the codecollection registry. + * + * Phase 1 of the cosmetic naming convention realignment (2026) renames the + * user-facing surface to align with industry-standard automation + agentic + * vocabulary, while leaving every internal identifier (DB columns, JSON + * `type` enum values, MCP tool function names, API paths, class names) + * byte-identical to the previous schema. + * + * Mapping (internal -> display): + * - Task -> Tool + * - CodeBundle -> Skill Template + * - SLI -> Monitor (scheduled, continuous, numeric output) + * - TaskSet -> Runbook (on-demand, event-triggered, findings) + * - CodeCollection (unchanged) + * + * Lifecycle distinction: + * - A **Skill Template** is the registry-side, parameterised package + * (formerly "CodeBundle"). Vars and secrets are unresolved placeholders. + * - A **Skill** is the runtime instantiation of a Skill Template inside a + * workspace, with vars/secrets materialised against real infrastructure. + * The registry itself never holds Skills — only Skill Templates — but the + * umbrella word "Skill" is used colloquially in user-facing page titles + * (e.g. "All Skills") because it reads naturally and aligns with + * industry usage (Anthropic Agent Skills, OpenAI tools, etc.). + * + * This module is the SINGLE source of truth for those display labels. Any + * new user-facing string that references one of the renamed concepts must + * either import a label from here or be added to this file. + */ + +export type InternalType = "TaskSet" | "SLI" | "CodeBundle"; + +interface LabelPair { + singular: string; + plural: string; +} + +/** + * Display labels keyed by the JSON `type` enum value that the backend emits + * on `/api/v1/registry/tasks` and friends. The backend still returns + * `"TaskSet"`, `"SLI"`, or `"CodeBundle"` verbatim; the UI translates here. + */ +export const TYPE_LABELS: Record = { + TaskSet: { singular: "Runbook", plural: "Runbooks" }, + SLI: { singular: "Monitor", plural: "Monitors" }, + CodeBundle: { singular: "Skill Template", plural: "Skill Templates" }, +} as const; + +/** + * Higher-level concept labels used in page titles, navigation, and prose. + * These are referenced directly by components instead of hard-coding + * "Tasks"/"CodeBundles" string literals. + */ +export const CONCEPTS = { + TASK: { singular: "Tool", plural: "Tools" }, + CODEBUNDLE: { singular: "Skill Template", plural: "Skill Templates" }, + // Runtime instantiation of a Skill Template (vars/secrets materialised + // inside a workspace). The registry itself only stores Skill Templates, + // but "Skill" is the umbrella word used in user-facing page titles. + SKILL: { singular: "Skill", plural: "Skills" }, + CODECOLLECTION: { singular: "CodeCollection", plural: "CodeCollections" }, + SLI: { singular: "Monitor", plural: "Monitors" }, + TASKSET: { singular: "Runbook", plural: "Runbooks" }, +} as const; + +/** + * Resolve the display label for a given internal `type` value. Returns the + * raw input if the type is unknown so unexpected values stay debuggable + * rather than rendering blank. + */ +export const labelForType = (type: InternalType | string, plural = false): string => { + if (type in TYPE_LABELS) { + return TYPE_LABELS[type as InternalType][plural ? "plural" : "singular"]; + } + return type; +}; + +/** + * Convenience helper that returns the label as a count-friendly string like + * "Runbook (3)" or "Monitors (12)". Pluralises automatically when count != 1. + */ +export const labelWithCount = (type: InternalType | string, count: number): string => { + const label = labelForType(type, count !== 1); + return `${label} (${count})`; +}; From 54fe40f979c237c5b5f76c4b430f565ea58f9d40 Mon Sep 17 00:00:00 2001 From: stewartshea Date: Fri, 22 May 2026 23:58:27 -0400 Subject: [PATCH 4/4] Update documentation and codebase to reflect rebranding from CodeCollection Registry to RunWhen Skills Registry. This includes changes to terminology, project structure, and various components across the frontend and backend, ensuring consistency in naming and functionality. Notable updates include renaming "CodeBundle" to "Skill Template" and adjusting references in API documentation, scripts, and user interfaces to align with the new branding. --- Agents.md | 6 ++++-- README.md | 8 +++++--- cc-registry-v2/AGENTS.md | 6 ++++-- cc-registry-v2/README.md | 6 ++++-- cc-registry-v2/backend/app/core/config.py | 2 +- cc-registry-v2/backend/app/main.py | 4 ++-- cc-registry-v2/backend/app/routers/github_issues.py | 2 +- cc-registry-v2/backend/app/routers/intake.py | 2 +- cc-registry-v2/backend/openapi.yaml | 4 ++-- cc-registry-v2/backend/start.sh | 2 +- cc-registry-v2/database/init/01-init.sql | 4 ++-- cc-registry-v2/docs/ARCHITECTURE.md | 2 +- cc-registry-v2/docs/CONFIGURATION.md | 2 +- cc-registry-v2/docs/MCP_WORKFLOW.md | 2 +- cc-registry-v2/docs/README.md | 2 +- cc-registry-v2/docs/archive/AI_ENHANCEMENT_README.md | 2 +- cc-registry-v2/frontend/public/index.html | 8 ++++---- cc-registry-v2/frontend/public/manifest.json | 4 ++-- cc-registry-v2/frontend/simple-admin.html | 2 +- cc-registry-v2/frontend/src/pages/ConfigBuilder.tsx | 2 +- cc-registry-v2/frontend/src/pages/Home.tsx | 4 ++-- cc-registry-v2/frontend/src/pages/WorkspaceBuilder.tsx | 2 +- cc-registry-v2/start.sh | 4 ++-- cc-registry/mkdocs.yml | 2 +- cc-registry/templates/home-template.j2 | 2 +- mcp-server/README.md | 5 +++-- mcp-server/client_test.py | 4 ++-- mcp-server/interactive_client.py | 4 ++-- mcp-server/openapi.yaml | 6 +++--- mcp-server/server.py | 8 ++++---- mcp-server/server_http.py | 10 +++++----- mcp-server/tools/github_issue.py | 2 +- mcp-server/utils/registry_client.py | 4 ++-- 33 files changed, 69 insertions(+), 60 deletions(-) diff --git a/Agents.md b/Agents.md index 11cfc47131ea..f8cd647a4ab6 100644 --- a/Agents.md +++ b/Agents.md @@ -1,4 +1,6 @@ -# AI Agent Guidelines for CodeCollection Registry +# AI Agent Guidelines for RunWhen Skills Registry + +Note: the directory and repo retain the legacy `codecollection-registry` identifier for path/URL stability. The product itself is now branded **RunWhen Skills Registry**. ## 🗣️ Terminology (2026 — read this first) @@ -85,7 +87,7 @@ codecollection-registry/ ## 🏗️ Project Structure -### CodeCollection Registry v2 Architecture +### RunWhen Skills Registry v2 Architecture ``` codecollection-registry/ diff --git a/README.md b/README.md index 808435badeb9..51c57bfd12a2 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,8 @@ -# CodeCollection Registry +# RunWhen Skills Registry -A registry for RunWhen CodeCollections -- browsing, searching, and configuring automation CodeBundles. +A registry of safe-for-production Skills for AI agents -- browsing, searching, and configuring Skill Templates (formerly "CodeBundles") backed by RunWhen CodeCollections. + +> Note: the GitHub repo retains the legacy `codecollection-registry` name for URL stability. The product is **RunWhen Skills Registry**. ## Repository Structure @@ -27,7 +29,7 @@ See [cc-registry-v2/README.md](cc-registry-v2/README.md) for setup, configuratio ### [mcp-server/](mcp-server/) -- MCP Server -A standalone FastAPI server that exposes MCP tools for querying the CodeCollection Registry. Delegates all data access to the backend API. Includes an offline indexer for generating vector embeddings. +A standalone FastAPI server that exposes MCP tools for querying the RunWhen Skills Registry. Delegates all data access to the backend API. Includes an offline indexer for generating vector embeddings. ```bash cd mcp-server/ diff --git a/cc-registry-v2/AGENTS.md b/cc-registry-v2/AGENTS.md index 13a3d119a231..79cfa89e3051 100644 --- a/cc-registry-v2/AGENTS.md +++ b/cc-registry-v2/AGENTS.md @@ -1,12 +1,14 @@ -# AGENTS.md — CodeCollection Registry v2 +# AGENTS.md — RunWhen Skills Registry v2 Instructions for AI coding agents working in this codebase. +Note: the directory name (`cc-registry-v2`) and GitHub repo (`codecollection-registry`) retain the legacy "codecollection" identifier for path/URL stability. The product itself is now branded **RunWhen Skills Registry**. + --- ## Project Overview -The CodeCollection Registry is a public-facing web app for browsing, searching, and configuring RunWhen automation (Skill Templates, formerly "CodeBundles"). It consists of 8 Docker services: +The RunWhen Skills Registry is a public-facing web app for browsing, searching, and configuring RunWhen automation (Skill Templates, formerly "CodeBundles"). It consists of 8 Docker services: | Service | Stack | Port | Purpose | |---------|-------|------|---------| diff --git a/cc-registry-v2/README.md b/cc-registry-v2/README.md index 0c06b6e5c719..0f5b13ca971e 100644 --- a/cc-registry-v2/README.md +++ b/cc-registry-v2/README.md @@ -1,6 +1,8 @@ -# CodeCollection Registry v2 - Microservices Architecture +# RunWhen Skills Registry v2 - Microservices Architecture -A modern, scalable registry for RunWhen CodeCollections with AI-powered enhancement capabilities. +A modern, scalable registry of safe-for-production Skills (Skill Templates and Tools) for AI agents, with AI-powered enhancement capabilities. + +> Note: the directory name (`cc-registry-v2`) retains the legacy "codecollection" identifier for path stability. The product is **RunWhen Skills Registry**. ## Architecture Overview diff --git a/cc-registry-v2/backend/app/core/config.py b/cc-registry-v2/backend/app/core/config.py index 439a3b3e3b9e..834ec0424879 100644 --- a/cc-registry-v2/backend/app/core/config.py +++ b/cc-registry-v2/backend/app/core/config.py @@ -68,7 +68,7 @@ class Settings(BaseSettings): # API Settings API_V1_STR: str = "/api/v1" - PROJECT_NAME: str = "CodeCollection Registry" + PROJECT_NAME: str = "RunWhen Skills Registry" # Config-file paths (codecollections.yaml, schedules.yaml, sources.yaml). # diff --git a/cc-registry-v2/backend/app/main.py b/cc-registry-v2/backend/app/main.py index 202e858257ee..7784e2cc1a02 100644 --- a/cc-registry-v2/backend/app/main.py +++ b/cc-registry-v2/backend/app/main.py @@ -26,7 +26,7 @@ # /docs against a local-only backend; update bookmarks to /api/docs. app = FastAPI( title=settings.PROJECT_NAME, - description="Interactive CodeCollection Registry API — see /api/openapi.yaml for the full spec.", + description="Interactive RunWhen Skills Registry API — see /api/openapi.yaml for the full spec.", version="2.0.0", docs_url="/api/docs", redoc_url="/api/redoc", @@ -78,7 +78,7 @@ async def openapi_yaml(): async def root(): """Root endpoint""" return { - "message": "CodeCollection Registry API", + "message": "RunWhen Skills Registry API", "version": "2.0.0", "docs": "/api/docs", "redoc": "/api/redoc", diff --git a/cc-registry-v2/backend/app/routers/github_issues.py b/cc-registry-v2/backend/app/routers/github_issues.py index 4c54bb272d66..dd47e4e2b176 100644 --- a/cc-registry-v2/backend/app/routers/github_issues.py +++ b/cc-registry-v2/backend/app/routers/github_issues.py @@ -71,7 +71,7 @@ async def create_task_request_issue(request: TaskRequestIssue): "- [ ] Test the codebundle functionality", "", "---", - "*This issue was automatically created from the CodeCollection Registry chat interface.*" + "*This issue was automatically created from the RunWhen Skills Registry chat interface.*" ]) body = "\n".join(body_parts) diff --git a/cc-registry-v2/backend/app/routers/intake.py b/cc-registry-v2/backend/app/routers/intake.py index 3b4a70a48193..2550893a08bb 100644 --- a/cc-registry-v2/backend/app/routers/intake.py +++ b/cc-registry-v2/backend/app/routers/intake.py @@ -315,7 +315,7 @@ def _build_minimal_issue_body(req: SubmitRequest) -> str: parts.extend([ "---", - f"*Created via CodeCollection Registry intake at {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M UTC')}.*", + f"*Created via RunWhen Skills Registry intake at {datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M UTC')}.*", ]) return "\n".join(parts) diff --git a/cc-registry-v2/backend/openapi.yaml b/cc-registry-v2/backend/openapi.yaml index 5f03c755153e..f8e7e9b61093 100644 --- a/cc-registry-v2/backend/openapi.yaml +++ b/cc-registry-v2/backend/openapi.yaml @@ -1,8 +1,8 @@ openapi: 3.1.0 info: - title: RunWhen CodeCollection Registry API + title: RunWhen Skills Registry API description: | - Backend API for the RunWhen CodeCollection Registry. Manages CodeCollections, + Backend API for the RunWhen Skills Registry. Manages CodeCollections, Skill Templates (formerly "codebundles"), Tools (formerly "tasks"), documentation, AI enhancement, Helm charts, and chat. diff --git a/cc-registry-v2/backend/start.sh b/cc-registry-v2/backend/start.sh index d3a2d179bbeb..8121db0740d7 100644 --- a/cc-registry-v2/backend/start.sh +++ b/cc-registry-v2/backend/start.sh @@ -2,7 +2,7 @@ set -e echo "============================================================" -echo "Starting CodeCollection Registry Backend" +echo "Starting RunWhen Skills Registry Backend" echo "============================================================" # Run database migrations diff --git a/cc-registry-v2/database/init/01-init.sql b/cc-registry-v2/database/init/01-init.sql index e74fd4c655e1..cf4fc530b3a8 100644 --- a/cc-registry-v2/database/init/01-init.sql +++ b/cc-registry-v2/database/init/01-init.sql @@ -1,4 +1,4 @@ --- Initialize CodeCollection Registry Database +-- Initialize RunWhen Skills Registry Database -- This script runs when the PostgreSQL container starts for the first time -- Create database (already created by POSTGRES_DB env var) @@ -12,5 +12,5 @@ CREATE EXTENSION IF NOT EXISTS vector; -- pgvector for semantic search GRANT ALL PRIVILEGES ON DATABASE codecollection_registry TO "user"; -- Log initialization -SELECT 'CodeCollection Registry database initialized successfully (with pgvector)' AS status; +SELECT 'RunWhen Skills Registry database initialized successfully (with pgvector)' AS status; diff --git a/cc-registry-v2/docs/ARCHITECTURE.md b/cc-registry-v2/docs/ARCHITECTURE.md index 485080c440d7..9efcd75041b3 100644 --- a/cc-registry-v2/docs/ARCHITECTURE.md +++ b/cc-registry-v2/docs/ARCHITECTURE.md @@ -1,6 +1,6 @@ # Architecture -System architecture for the CodeCollection Registry v2. +System architecture for the RunWhen Skills Registry v2. ## Service Overview diff --git a/cc-registry-v2/docs/CONFIGURATION.md b/cc-registry-v2/docs/CONFIGURATION.md index 5e2a18fd337c..a408c1d7d089 100644 --- a/cc-registry-v2/docs/CONFIGURATION.md +++ b/cc-registry-v2/docs/CONFIGURATION.md @@ -1,6 +1,6 @@ # Configuration Guide -Environment variables, secrets, and configuration files for the CodeCollection Registry. +Environment variables, secrets, and configuration files for the RunWhen Skills Registry. ## Secrets File (`az.secret`) diff --git a/cc-registry-v2/docs/MCP_WORKFLOW.md b/cc-registry-v2/docs/MCP_WORKFLOW.md index 92e65b5d2734..95b59f0dc4b0 100644 --- a/cc-registry-v2/docs/MCP_WORKFLOW.md +++ b/cc-registry-v2/docs/MCP_WORKFLOW.md @@ -1,6 +1,6 @@ # MCP Server Workflow: Search and Indexing -How data ingestion, embedding generation, and search work in the CodeCollection Registry. +How data ingestion, embedding generation, and search work in the RunWhen Skills Registry. ## Unified Pipeline diff --git a/cc-registry-v2/docs/README.md b/cc-registry-v2/docs/README.md index 4f412c175811..408b544e677d 100644 --- a/cc-registry-v2/docs/README.md +++ b/cc-registry-v2/docs/README.md @@ -1,4 +1,4 @@ -# CodeCollection Registry v2 Documentation +# RunWhen Skills Registry v2 Documentation All project documentation, organized by topic. diff --git a/cc-registry-v2/docs/archive/AI_ENHANCEMENT_README.md b/cc-registry-v2/docs/archive/AI_ENHANCEMENT_README.md index d5138d60369d..3824ca2b1ae8 100644 --- a/cc-registry-v2/docs/archive/AI_ENHANCEMENT_README.md +++ b/cc-registry-v2/docs/archive/AI_ENHANCEMENT_README.md @@ -1,6 +1,6 @@ # AI CodeBundle Enhancement Framework -This document describes the AI-powered enhancement framework for CodeBundles in the CodeCollection Registry v2. +This document describes the AI-powered enhancement framework for Skill Templates (formerly "CodeBundles") in the RunWhen Skills Registry v2. ## Overview diff --git a/cc-registry-v2/frontend/public/index.html b/cc-registry-v2/frontend/public/index.html index fc5ad06b65fa..69a91bf33cfe 100644 --- a/cc-registry-v2/frontend/public/index.html +++ b/cc-registry-v2/frontend/public/index.html @@ -7,11 +7,11 @@ - - + + @@ -31,7 +31,7 @@ work correctly both with client-side routing and a non-root public URL. Learn how to configure a non-root public URL by running `npm run build`. --> - RunWhen Registry – Tools for AI SRE Agents + RunWhen Skills Registry – Safe-for-Production Skills for AI Agents