diff --git a/.github/ISSUE_TEMPLATE/bug_template.yml b/.github/ISSUE_TEMPLATE/bug_template.yml index 0dd6a28..7f864be 100644 --- a/.github/ISSUE_TEMPLATE/bug_template.yml +++ b/.github/ISSUE_TEMPLATE/bug_template.yml @@ -1,6 +1,6 @@ # SPDX-FileCopyrightText: 2024 PNED G.I.E. # -# SPDX-License-Identifier: Apache-2.0 +# SPDX-License-Identifier: CC-BY-4.0 name: "🐞 Bug Report" description: Report the issue you are having diff --git a/.github/ISSUE_TEMPLATE/feature_template.yml b/.github/ISSUE_TEMPLATE/feature_template.yml index 784a944..76406ee 100644 --- a/.github/ISSUE_TEMPLATE/feature_template.yml +++ b/.github/ISSUE_TEMPLATE/feature_template.yml @@ -1,6 +1,6 @@ # SPDX-FileCopyrightText: 2024 PNED G.I.E. # -# SPDX-License-Identifier: Apache-2.0 +# SPDX-License-Identifier: CC-BY-4.0 name: "✨ Feature Request" description: Suggest an idea for this project diff --git a/.github/ISSUE_TEMPLATE/story_template.yml b/.github/ISSUE_TEMPLATE/story_template.yml index d8781f4..236d57a 100644 --- a/.github/ISSUE_TEMPLATE/story_template.yml +++ b/.github/ISSUE_TEMPLATE/story_template.yml @@ -1,6 +1,6 @@ # SPDX-FileCopyrightText: 2024 PNED G.I.E. # -# SPDX-License-Identifier: Apache-2.0 +# SPDX-License-Identifier: CC-BY-4.0 name: "📝 User Story" description: Provide a detailed user story including what needs to be done, why, the tasks involved, and the acceptance criteria. diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 5d0756d..3116974 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,6 +1,6 @@ - + ## 🚀 Pull Request Checklist diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index b65d54d..6af1785 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -1,6 +1,6 @@ -# SPDX-FileCopyrightText: 2024 PNED G.I.E. +# SPDX-FileCopyrightText: 2026 PNED G.I.E. # -# SPDX-License-Identifier: Apache-2.0 +# SPDX-License-Identifier: CC-BY-4.0 name: Publish main @@ -27,19 +27,24 @@ env: jobs: build: - name: Build site + name: Assemble site if: github.event_name == 'workflow_dispatch' || github.event.workflow_run.conclusion == 'success' runs-on: ubuntu-latest steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 with: ref: ${{ env.SHA }} - - name: Check FitSM data and page script + - uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0 + with: + node-version: 22 + - name: Check FitSM content, map and scripts run: node scripts/check.js + # No build step: the deployed files are the files in the repository. - name: Assemble site run: | mkdir _site - cp index.html fitsm-data.js _site/ + cp index.html styles.css _site/ + cp -r src content _site/ - uses: actions/configure-pages@45bfe0192ca1faeb007ade9deae92b16b8254a0d # v6.0.0 - uses: actions/upload-pages-artifact@fc324d3547104276b827a68afc52ff2a11cc49c9 # v5.0.0 with: diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index ffcb66f..432634a 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -1,6 +1,6 @@ -# SPDX-FileCopyrightText: 2024 PNED G.I.E. +# SPDX-FileCopyrightText: 2026 PNED G.I.E. # -# SPDX-License-Identifier: Apache-2.0 +# SPDX-License-Identifier: CC-BY-4.0 name: Publish release @@ -22,14 +22,18 @@ jobs: contents: write steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - - name: Check FitSM data and page script + - uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0 + with: + node-version: 22 + - name: Check FitSM content, map and scripts run: node scripts/check.js - name: Package site run: | - mkdir -p "fitsm-process-map-${GITHUB_REF_NAME}" - cp index.html fitsm-data.js README.md "fitsm-process-map-${GITHUB_REF_NAME}/" - cp -r LICENSES "fitsm-process-map-${GITHUB_REF_NAME}/" - zip -r "fitsm-process-map-${GITHUB_REF_NAME}.zip" "fitsm-process-map-${GITHUB_REF_NAME}" + dir="fitsm-process-map-${GITHUB_REF_NAME}" + mkdir -p "$dir" + cp index.html styles.css README.md CHANGELOG.md "$dir/" + cp -r src content LICENSES "$dir/" + zip -r "$dir.zip" "$dir" - name: Create release env: GH_TOKEN: ${{ github.token }} diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 62da6d1..4fd1fa0 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -1,6 +1,6 @@ -# SPDX-FileCopyrightText: 2024 PNED G.I.E. +# SPDX-FileCopyrightText: 2026 PNED G.I.E. # -# SPDX-License-Identifier: Apache-2.0 +# SPDX-License-Identifier: CC-BY-4.0 name: Run Tests @@ -20,9 +20,23 @@ jobs: - uses: fsfe/reuse-action@676e2d560c9a403aa252096d99fcab3e1132b0f5 # v6.0.0 check: - name: Data and page checks + name: Content checks runs-on: ubuntu-latest steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 - - name: Check FitSM data and page script + - uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0 + with: + node-version: 22 + - name: Check FitSM content, map and scripts run: node scripts/check.js + + unit: + name: Unit tests + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1 + - uses: actions/setup-node@a0853c24544627f65ddf259abe73b1d18a591444 # v5.0.0 + with: + node-version: 22 + - name: Run unit tests + run: node --test diff --git a/.gitignore b/.gitignore index adc5af0..3059643 100644 --- a/.gitignore +++ b/.gitignore @@ -1,10 +1,17 @@ # SPDX-FileCopyrightText: 2026 PNED G.I.E. # -# SPDX-License-Identifier: Apache-2.0 +# SPDX-License-Identifier: CC-BY-4.0 # Local tooling (Claude Code preview config, editor settings) .claude/ .DS_Store -# Site build output (assembled in CI) +# Site output assembled in CI for GitHub Pages _site/ + +# The project has no package-managed dependencies; ignore a stray install anyway +node_modules/ + +# Release zips built locally +fitsm-process-map-v*/ +fitsm-process-map-v*.zip diff --git a/.specify/.gitignore b/.specify/.gitignore new file mode 100644 index 0000000..78f2717 --- /dev/null +++ b/.specify/.gitignore @@ -0,0 +1,12 @@ +# Machine-local Spec Kit state — not meant to be shared. +# Managed by the Specify CLI; safe to edit (your changes are preserved on refresh). + +# Local pointer to the current feature directory. Rewritten every time you +# switch features, so it is per-checkout state rather than something to share. +feature.json + +# Per-machine extension config overrides. +extensions/*/local-config.yml + +# Extension catalog cache written by `specify extension search`; per-machine, re-downloaded on demand. +extensions/.cache/ diff --git a/.specify/init-options.json b/.specify/init-options.json new file mode 100644 index 0000000..d01f03e --- /dev/null +++ b/.specify/init-options.json @@ -0,0 +1,9 @@ +{ + "ai": "claude", + "ai_skills": true, + "feature_numbering": "sequential", + "here": true, + "integration": "claude", + "script": "sh", + "speckit_version": "1.1.1.dev0" +} diff --git a/.specify/integration.json b/.specify/integration.json new file mode 100644 index 0000000..98d691c --- /dev/null +++ b/.specify/integration.json @@ -0,0 +1,15 @@ +{ + "version": "1.1.1.dev0", + "integration_state_schema": 1, + "installed_integrations": [ + "claude" + ], + "integration_settings": { + "claude": { + "script": "sh", + "invoke_separator": "-" + } + }, + "integration": "claude", + "default_integration": "claude" +} diff --git a/.specify/integrations/claude.manifest.json b/.specify/integrations/claude.manifest.json new file mode 100644 index 0000000..2df8802 --- /dev/null +++ b/.specify/integrations/claude.manifest.json @@ -0,0 +1,17 @@ +{ + "integration": "claude", + "version": "1.1.1.dev0", + "installed_at": "2026-10-03T14:19:51.535976+00:00", + "files": { + ".claude/skills/speckit-analyze/SKILL.md": "3237cd827194efaf6bb06ba05ef9bc1a703a223d362f5e34d0558c5a38ae34d0", + ".claude/skills/speckit-clarify/SKILL.md": "164f49ef87cb2e922585316f5281b455a8e1940b1efd25317d517a567acae472", + ".claude/skills/speckit-constitution/SKILL.md": "60c27f3962e78edf204b2b2e7cba91a616980860b61d6bf2051dc6965d483dda", + ".claude/skills/speckit-implement/SKILL.md": "7186d59488f89dcf23abd17baed118b05c242d4f62f1de3f9f44625a2b1728f0", + ".claude/skills/speckit-converge/SKILL.md": "9f93c1d573592f146670202210128ed24a9d75c92133951b19a2bb0e34eac13b", + ".claude/skills/speckit-plan/SKILL.md": "9e97fc0b4ce895c70a1ea720dc0377618c23e27c83ecf4d87b6e0f6c323790a4", + ".claude/skills/speckit-checklist/SKILL.md": "5dc436df0c727e9078bf182dd385e5cb1b60ee67ebe644d3f659ec12e3b78abb", + ".claude/skills/speckit-specify/SKILL.md": "d4d93f2444355136e78bb533988aa2dd560dc4b258f4923f67b1a437e7de38f8", + ".claude/skills/speckit-tasks/SKILL.md": "d148aeda1011260c4465c5f105fa1e045a0b0224ccb3e6e0c1ec32c732cae1ae", + ".claude/skills/speckit-taskstoissues/SKILL.md": "464bbaf464a28ffa371b0452599c18e7cb5799630148d9f945e6a4d7066a1234" + } +} diff --git a/.specify/integrations/speckit.manifest.json b/.specify/integrations/speckit.manifest.json new file mode 100644 index 0000000..d8833e9 --- /dev/null +++ b/.specify/integrations/speckit.manifest.json @@ -0,0 +1,19 @@ +{ + "integration": "speckit", + "version": "1.1.1.dev0", + "installed_at": "2026-10-03T14:19:51.614039+00:00", + "files": { + ".specify/scripts/bash/common.sh": "53cb1c23e349db4586c272436ce35c6e2f36a9c0b5351a85e0b216d9887a26b7", + ".specify/scripts/bash/setup-plan.sh": "d0bd298c026446f3c63167130d65e49e4aa4485de6bef18bcdfd57b19aa0de96", + ".specify/scripts/bash/setup-tasks.sh": "4a33dd1e6c32ddc7d570f4b538572c54069192573eed0ec654d9fb826e31a4fe", + ".specify/scripts/bash/check-prerequisites.sh": "daa377146db4fb69912f42611a7b91c5d55873b3e3e27ed33bd8d67505826344", + ".specify/scripts/bash/resolve-template.sh": "829e227096abc8bf0889889ec9f792f503ca5d395b7836a8a7eb739ee75214e7", + ".specify/scripts/bash/create-new-feature.sh": "972f03ed8ca5ee17b7baad6d56d821d46269d77abc337496beafb0fe85a725f2", + ".specify/templates/constitution-template.md": "ce7549540fa45543cca797a150201d868e64495fdff39dc38246fb17bd4024b3", + ".specify/templates/checklist-template.md": "856532b3cb66171c662cc16f16b31a5856e4655a8666aad1e545bbfc7f603ca1", + ".specify/templates/tasks-template.md": "fc29a233f6f5a27ca31f1aa46b596af6500c627441c6e62b2bc4a1d721525842", + ".specify/templates/spec-template.md": "3945437fc35cd30a5b2bf7beea680337c3516826d3efa5a6b92c4a7eca1ba28e", + ".specify/templates/plan-template.md": "7e637502d41eccf0ca672496636365691fdca62ef37b27ec07fcb412dbfa90d4", + ".specify/.gitignore": "8c908410d177a1ef3d0dee16d7ad55f2ac3333df3104c4d4adee1c9b82f1dbc1" + } +} diff --git a/.specify/memory/.constitution-template.json b/.specify/memory/.constitution-template.json new file mode 100644 index 0000000..2fe4dee --- /dev/null +++ b/.specify/memory/.constitution-template.json @@ -0,0 +1,4 @@ +{ + "sha256": "ce7549540fa45543cca797a150201d868e64495fdff39dc38246fb17bd4024b3", + "source": "core" +} diff --git a/.specify/memory/constitution.md b/.specify/memory/constitution.md new file mode 100644 index 0000000..c85f578 --- /dev/null +++ b/.specify/memory/constitution.md @@ -0,0 +1,140 @@ +# FitSM Process Map Constitution + +This project builds an interactive process map of FitSM, the lightweight IT service management +standard published by ITEMO e.V. It is governed by the same four principles that FitSM applies +to itself, as stated in the foreword of every FitSM document: practicality, consistency, +sufficiency and extendibility. It also applies FitSM's own management approach (clear +responsibilities, documented content and continual improvement) to how the project is run. + +## Core Principles + +### I. Practicality + +FitSM is meant to be usable without a heavy toolset, and so is this map. + +- The site MUST run as static files in a current browser. It MUST NOT need a build step, + bundler, server-side code or account. +- Each part of the standard (process, requirement, role, record, activity, interface) MUST be + reachable within two clicks from the map. Each process MUST be linkable by its FitSM code + (for example `#ISRM`). +- Content MUST be written in plain language for people learning FitSM. Jargon that FitSM does + not itself define MUST be avoided or explained. +- The page MUST be usable with a keyboard and on a phone-width screen. + +Rationale: a learning aid that is hard to open, run or read fails its purpose. + +### II. Consistency with the Standard + +The map MUST say what FitSM says. The source documents are FitSM-0, FitSM-1, FitSM-2 and FitSM-3 +(v3), and the latest edition published at fitsm.eu is the reference. + +- Every item of FitSM content MUST be traceable to a named FitSM document and section, such as + a requirement ID (PR1–PR14), an activity or a role. +- FitSM terms MUST be used with their FitSM-0 meanings, and quoted text MUST NOT be reworded. +- The map MUST show exactly the 14 FitSM processes. It MUST NOT add processes, roles or + requirements that FitSM does not define. +- Anything that is interpretation rather than quotation MUST be labelled on the page. That + includes derived databases, reconciling conflicting tables and colour groupings. +- When FitSM documents disagree, both versions MUST be shown with a note. The map MUST NOT + silently pick one. + +Rationale: users rely on the map to learn the standard. An unlabelled deviation teaches +something FitSM does not say. + +### III. Sufficiency + +FitSM includes only what is necessary, and the map follows the same rule. + +- A feature MUST serve understanding of the standard. Decoration, tracking and features not + tied to FitSM content MUST NOT be added. +- The project MUST NOT add package-managed dependencies (npm, pip and similar) or container + images unless a spec justifies the need and the plan records it. If one is added, a + dependency licence scan and, for images, an image scan MUST be added to CI. +- Each bundled third-party resource (such as a font) MUST be listed in the README with its + licence. + +Rationale: each addition is something to maintain, review and license. The smallest map that +teaches FitSM fully is the right size. + +### IV. Extendibility + +FitSM is designed to be extended, and the map MUST be easy to extend without rework. + +- All FitSM content MUST live in a content store separate from presentation and behaviour. + Correcting or adding content MUST NOT require changes to page code. +- The content model MUST let a later FitSM edition, a translation, or further content (such + as FitSM-4 templates) be added alongside the current content, not on top of it. +- Each item MUST have a stable identifier based on FitSM's own codes, so that links and + cross-references keep working when content is extended. + +Rationale: FitSM evolves, and organisations adapt it. A map that can only show one fixed +edition has a short life. + +### V. Openness and Attribution + +FitSM is free and openly licensed under CC BY 4.0, and the map is distributed under the same +licence. + +- The whole project (code, documentation and FitSM content) is licensed under Creative Commons + Attribution 4.0 International (CC BY 4.0). No other licence MAY be used for the project's + own work. A bundled third-party resource keeps its own open licence and is listed as such. +- FitSM content MUST be credited to ITEMO e.V. under CC BY 4.0 with a link to fitsm.eu, both on + the page and in the content store. +- Every file MUST carry SPDX copyright and licence information, and the repository MUST pass + `reuse lint`. + +Rationale: openness is what lets the map exist and be reused. Using FitSM's own licence for +everything keeps reuse simple and attribution is a licence condition, not a courtesy. + +### VI. Continual Improvement + +FitSM is built on continual improvement (Plan, Do, Check, Act), and the project MUST apply it to +itself. + +- Every change MUST pass the automated consistency checks: all references resolve, no required + content is missing, and the page script parses. New kinds of content MUST come with new + checks. +- Error reports and suggested corrections to FitSM content MUST be handled through GitHub + issues, citing the FitSM source. +- Releases MUST be tagged with a version (`v*`) and recorded in a changelog. + +Rationale: a process map of a quality standard should show the same discipline it describes. + +## Content and Technical Constraints + +- Technology: HTML, CSS and JavaScript without frameworks, served as static files on GitHub + Pages. Node.js is used only for CI checks and is not needed to view the site. +- Content scope: FitSM v3 (FitSM-0 to FitSM-3). Adding another FitSM part or edition needs a + spec of its own. +- Labelling: the page MUST visibly separate quoted FitSM content from interpretation and study + aids. +- Accessibility: text and diagram colours MUST meet WCAG 2.1 AA contrast. Information MUST NOT be + shown by colour alone. +- Supply chain: GitHub Actions MUST be pinned to commit SHAs. + +## Development Workflow and Quality Gates + +- Spec-driven: new features follow the Spec Kit flow (specify, plan, tasks, implement). Each plan + MUST include a Constitution Check against Principles I–VI. +- Content changes MUST cite the FitSM document and section they come from in the pull request. +- Every pull request MUST pass CI (REUSE compliance and the consistency checks) before it is + merged. Only `main` is deployed. +- Reviewers MUST check that interpretation is labelled (Principle II) and that no unnecessary + dependency is added (Principle III). +- Commit messages follow the conventions in `CONTRIBUTING.md`. + +## Governance + +- This constitution takes precedence over other project practices. If guidance conflicts with + it, the constitution applies until it is amended. +- Amendments are made by pull request that changes this file. The pull request MUST state the + reason and the version bump, and it needs maintainer approval. +- Versioning follows semantic versioning: + - MAJOR: a principle is removed or redefined in a way that is not backward compatible. + - MINOR: a principle or section is added, or guidance is materially expanded. + - PATCH: wording is clarified without changing meaning. +- Compliance is reviewed in every pull request, and in full when a new FitSM edition is + published. +- Day-to-day guidance for contributors is in `README.md` and `CONTRIBUTING.md`. + +**Version**: 2.0.1 | **Ratified**: 2026-10-03 | **Last Amended**: 2026-10-03 diff --git a/.specify/scripts/bash/check-prerequisites.sh b/.specify/scripts/bash/check-prerequisites.sh new file mode 100755 index 0000000..a6a8ad8 --- /dev/null +++ b/.specify/scripts/bash/check-prerequisites.sh @@ -0,0 +1,243 @@ +#!/usr/bin/env bash + +# Consolidated prerequisite checking script +# +# This script provides unified prerequisite checking for Spec-Driven Development workflow. +# It replaces the functionality previously spread across multiple scripts. +# +# Usage: ./check-prerequisites.sh [OPTIONS] +# +# OPTIONS: +# --json Output in JSON format +# --require-spec Require spec.md to exist (for analysis phase) +# --require-tasks Require tasks.md to exist (for implementation phase) +# --include-tasks Include tasks.md in AVAILABLE_DOCS list +# --paths-only Only output path variables (no validation) +# --template NAME Include composed template content in JSON output +# --help, -h Show help message +# +# OUTPUTS: +# JSON mode: {"FEATURE_DIR":"...", "AVAILABLE_DOCS":["..."]} +# Text mode: FEATURE_DIR:... \n AVAILABLE_DOCS: \n ✓/✗ file.md +# Paths only: REPO_ROOT: ... \n BRANCH: ... \n FEATURE_DIR: ... etc. + +set -e + +# Parse command line arguments +JSON_MODE=false +REQUIRE_SPEC=false +REQUIRE_TASKS=false +INCLUDE_TASKS=false +PATHS_ONLY=false +TEMPLATE_NAME="" + +while [[ $# -gt 0 ]]; do + case "$1" in + --json) + JSON_MODE=true + ;; + --require-spec) + REQUIRE_SPEC=true + ;; + --require-tasks) + REQUIRE_TASKS=true + ;; + --include-tasks) + INCLUDE_TASKS=true + ;; + --paths-only) + PATHS_ONLY=true + ;; + --template) + shift + if [[ $# -eq 0 ]]; then + echo "ERROR: --template requires a template name" >&2 + exit 1 + fi + TEMPLATE_NAME="$1" + ;; + --help|-h) + cat << 'EOF' +Usage: check-prerequisites.sh [OPTIONS] + +Consolidated prerequisite checking for Spec-Driven Development workflow. + +OPTIONS: + --json Output in JSON format + --require-spec Require spec.md to exist (for analysis phase) + --require-tasks Require tasks.md to exist (for implementation phase) + --include-tasks Include tasks.md in AVAILABLE_DOCS list + --paths-only Only output path variables (no prerequisite validation) + --template NAME Include composed template content in JSON output + --help, -h Show this help message + +EXAMPLES: + # Check task prerequisites (plan.md required) + ./check-prerequisites.sh --json + + # Check implementation prerequisites (plan.md + tasks.md required) + ./check-prerequisites.sh --json --require-tasks --include-tasks + + # Get feature paths only (no validation) + ./check-prerequisites.sh --paths-only + +EOF + exit 0 + ;; + *) + echo "ERROR: Unknown option '$1'. Use --help for usage information." >&2 + exit 1 + ;; + esac + shift +done + +# Source common functions +SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$SCRIPT_DIR/common.sh" + +# Get feature paths. +# In --paths-only mode this is pure resolution, so pass --no-persist to opt out +# of the feature.json write side effect (issue #3025). +if $PATHS_ONLY; then + _paths_output=$(get_feature_paths --no-persist) || { echo "ERROR: Failed to resolve feature paths" >&2; exit 1; } +else + _paths_output=$(get_feature_paths) || { echo "ERROR: Failed to resolve feature paths" >&2; exit 1; } +fi +eval "$_paths_output" +unset _paths_output + +# If paths-only mode, output paths and exit (no validation) +if $PATHS_ONLY; then + if $JSON_MODE; then + # Minimal JSON paths payload (no validation performed) + if has_jq; then + jq -cn \ + --arg repo_root "$REPO_ROOT" \ + --arg branch "$CURRENT_BRANCH" \ + --arg feature_dir "$FEATURE_DIR" \ + --arg feature_spec "$FEATURE_SPEC" \ + --arg impl_plan "$IMPL_PLAN" \ + --arg tasks "$TASKS" \ + '{REPO_ROOT:$repo_root,BRANCH:$branch,FEATURE_DIR:$feature_dir,FEATURE_SPEC:$feature_spec,IMPL_PLAN:$impl_plan,TASKS:$tasks}' + else + printf '{"REPO_ROOT":"%s","BRANCH":"%s","FEATURE_DIR":"%s","FEATURE_SPEC":"%s","IMPL_PLAN":"%s","TASKS":"%s"}\n' \ + "$(json_escape "$REPO_ROOT")" "$(json_escape "$CURRENT_BRANCH")" "$(json_escape "$FEATURE_DIR")" "$(json_escape "$FEATURE_SPEC")" "$(json_escape "$IMPL_PLAN")" "$(json_escape "$TASKS")" + fi + else + echo "REPO_ROOT: $REPO_ROOT" + echo "BRANCH: $CURRENT_BRANCH" + echo "FEATURE_DIR: $FEATURE_DIR" + echo "FEATURE_SPEC: $FEATURE_SPEC" + echo "IMPL_PLAN: $IMPL_PLAN" + echo "TASKS: $TASKS" + fi + exit 0 +fi + +# Validate required directories and files +if [[ ! -d "$FEATURE_DIR" ]]; then + echo "ERROR: Feature directory not found: $FEATURE_DIR" >&2 + echo "Run /speckit-specify first to create the feature structure." >&2 + exit 1 +fi + +if [[ ! -f "$IMPL_PLAN" ]]; then + echo "ERROR: plan.md not found in $FEATURE_DIR" >&2 + echo "Run /speckit-plan first to create the implementation plan." >&2 + exit 1 +fi + +# Check for spec.md if required +if $REQUIRE_SPEC && [[ ! -f "$FEATURE_SPEC" ]]; then + echo "ERROR: spec.md not found in $FEATURE_DIR" >&2 + echo "Run /speckit-specify first to create the feature specification." >&2 + exit 1 +fi + +# Check for tasks.md if required +if $REQUIRE_TASKS && [[ ! -f "$TASKS" ]]; then + echo "ERROR: tasks.md not found in $FEATURE_DIR" >&2 + echo "Run /speckit-tasks first to create the task list." >&2 + exit 1 +fi + +# Build list of available documents +docs=() + +# Always check these optional docs +[[ -f "$RESEARCH" ]] && docs+=("research.md") +[[ -f "$DATA_MODEL" ]] && docs+=("data-model.md") + +# Check contracts directory (only if it exists and has files) +if [[ -d "$CONTRACTS_DIR" ]] && [[ -n "$(ls -A "$CONTRACTS_DIR" 2>/dev/null)" ]]; then + docs+=("contracts/") +fi + +[[ -f "$QUICKSTART" ]] && docs+=("quickstart.md") + +# Include tasks.md if requested and it exists +if $INCLUDE_TASKS && [[ -f "$TASKS" ]]; then + docs+=("tasks.md") +fi + +TEMPLATE_CONTENT="" +if [[ -n "$TEMPLATE_NAME" ]]; then + if TEMPLATE_CONTENT=$(resolve_template_content "$TEMPLATE_NAME" "$REPO_ROOT"; status=$?; printf x; exit "$status"); then + TEMPLATE_CONTENT="${TEMPLATE_CONTENT%x}" + else + echo "ERROR: Could not resolve required $TEMPLATE_NAME from the template override stack for $REPO_ROOT" >&2 + exit 1 + fi +fi + +# Output results +if $JSON_MODE; then + # Build JSON array of documents + if has_jq; then + if [[ ${#docs[@]} -eq 0 ]]; then + json_docs="[]" + else + json_docs=$(printf '%s\n' "${docs[@]}" | jq -R . | jq -s .) + fi + if [[ -n "$TEMPLATE_NAME" ]]; then + jq -cn \ + --arg feature_dir "$FEATURE_DIR" \ + --argjson docs "$json_docs" \ + --arg template_content "$TEMPLATE_CONTENT" \ + '{FEATURE_DIR:$feature_dir,AVAILABLE_DOCS:$docs,TEMPLATE_CONTENT:$template_content}' + else + jq -cn \ + --arg feature_dir "$FEATURE_DIR" \ + --argjson docs "$json_docs" \ + '{FEATURE_DIR:$feature_dir,AVAILABLE_DOCS:$docs}' + fi + else + if [[ ${#docs[@]} -eq 0 ]]; then + json_docs="[]" + else + json_docs=$(for d in "${docs[@]}"; do printf '"%s",' "$(json_escape "$d")"; done) + json_docs="[${json_docs%,}]" + fi + if [[ -n "$TEMPLATE_NAME" ]]; then + printf '{"FEATURE_DIR":"%s","AVAILABLE_DOCS":%s,"TEMPLATE_CONTENT":"%s"}\n' \ + "$(json_escape "$FEATURE_DIR")" "$json_docs" "$(json_escape "$TEMPLATE_CONTENT")" + else + printf '{"FEATURE_DIR":"%s","AVAILABLE_DOCS":%s}\n' "$(json_escape "$FEATURE_DIR")" "$json_docs" + fi + fi +else + # Text output + echo "FEATURE_DIR:$FEATURE_DIR" + echo "AVAILABLE_DOCS:" + + # Show status of each potential document + check_file "$RESEARCH" "research.md" + check_file "$DATA_MODEL" "data-model.md" + check_dir "$CONTRACTS_DIR" "contracts/" + check_file "$QUICKSTART" "quickstart.md" + + if $INCLUDE_TASKS; then + check_file "$TASKS" "tasks.md" + fi +fi diff --git a/.specify/scripts/bash/common.sh b/.specify/scripts/bash/common.sh new file mode 100755 index 0000000..ff18cba --- /dev/null +++ b/.specify/scripts/bash/common.sh @@ -0,0 +1,942 @@ +#!/usr/bin/env bash +# Common functions and variables for all scripts + +# Find repository root by searching upward for .specify directory +# This is the primary marker for spec-kit projects +find_specify_root() { + local dir="${1:-$(pwd)}" + # Normalize to absolute path to prevent infinite loop with relative paths + # Use -- to handle paths starting with - (e.g., -P, -L) + dir="$(cd -- "$dir" 2>/dev/null && pwd)" || return 1 + local prev_dir="" + while true; do + if [ -d "$dir/.specify" ]; then + echo "$dir" + return 0 + fi + # Stop if we've reached filesystem root or dirname stops changing + if [ "$dir" = "/" ] || [ "$dir" = "$prev_dir" ]; then + break + fi + prev_dir="$dir" + dir="$(dirname "$dir")" + done + return 1 +} + +# Resolve an explicit SPECIFY_INIT_DIR project override (the directory that +# *contains* .specify/), for non-interactive / CI use — e.g. running a Spec Kit +# command against a member project from a monorepo root without cd. +# +# Precondition: SPECIFY_INIT_DIR is non-empty. Echoes the validated absolute +# project root, or prints an error and returns 1. Strict by design: the path +# must exist and contain .specify/, with no silent fallback to cwd or the +# script-location default (which would silently write to the wrong project). +# +# This is the single resolver: bundled extensions inherit it by sourcing core +# (e.g. the git extension's create-new-feature-branch) rather than duplicating it. +resolve_specify_init_dir() { + local init_root + # Normalize: relative paths resolve against $(pwd); a trailing slash collapses. + # CDPATH="" so a relative value cannot be resolved against the caller's CDPATH + # (which would also echo to stdout and corrupt the captured path). + if ! init_root="$(CDPATH="" cd -- "$SPECIFY_INIT_DIR" 2>/dev/null && pwd)"; then + echo "ERROR: SPECIFY_INIT_DIR does not point to an existing directory: $SPECIFY_INIT_DIR" >&2 + return 1 + fi + if [[ ! -d "$init_root/.specify" ]]; then + echo "ERROR: SPECIFY_INIT_DIR is not a Spec Kit project (no .specify/ directory): $init_root" >&2 + return 1 + fi + printf '%s\n' "$init_root" +} + +# Get repository root, prioritizing .specify directory +# This prevents using a parent repository when spec-kit is initialized in a subdirectory +get_repo_root() { + # Explicit project override wins (see resolve_specify_init_dir). + if [[ -n "${SPECIFY_INIT_DIR:-}" ]]; then + resolve_specify_init_dir + return + fi + + # First, look for .specify directory (spec-kit's own marker) + local specify_root + if specify_root=$(find_specify_root); then + echo "$specify_root" + return + fi + + # Final fallback to script location + local script_dir="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + (cd "$script_dir/../../.." && pwd) +} + +# Get current feature name from explicit state only. +# Returns the feature identifier or empty string if none is set. +# Feature state is set by SPECIFY_FEATURE (from create-new-feature or +# the git extension) or implicitly via .specify/feature.json. +get_current_branch() { + if [[ -n "${SPECIFY_FEATURE:-}" ]]; then + echo "$SPECIFY_FEATURE" + return + fi + + # No explicit feature set — caller must handle this via feature.json + # in get_feature_paths(). Return empty to signal "unknown". + echo "" +} + +# Safely read .specify/feature.json's "feature_directory" value. +# Prints the raw value (possibly relative) to stdout, or empty string if the file +# is missing, unparseable, or does not contain the key. Always returns 0 so callers +# under `set -e` cannot be aborted by parser failure. +# Parser order mirrors the historical get_feature_paths behavior: jq -> python3 -> grep/sed. +read_feature_json_feature_directory() { + local repo_root="$1" + local fj="$repo_root/.specify/feature.json" + [[ -f "$fj" ]] || { printf '%s' ''; return 0; } + + # Try parsers in order (jq -> python3 -> grep/sed), falling through on + # failure. Selection is by *parse success*, not mere availability: on + # Windows `python3` commonly resolves to the Microsoft Store App Execution + # Alias stub, which passes `command -v` but fails at runtime (exit 49), so + # an availability-gated `elif` would pick python3, swallow its failure, and + # never reach the grep/sed fallback -- leaving feature.json unreadable even + # though it is valid (issue #3304). + local _fd='' + if command -v jq >/dev/null 2>&1; then + if ! _fd=$(jq -r '.feature_directory // empty' "$fj" 2>/dev/null); then + _fd='' + fi + fi + if [[ -z "$_fd" ]] && command -v python3 >/dev/null 2>&1; then + # Use Python so pretty-printed/multi-line JSON still parses correctly. + if ! _fd=$(python3 -c "import json,sys; d=json.load(open(sys.argv[1], encoding='utf-8')); v=d.get('feature_directory'); print(v if v else '')" "$fj" 2>/dev/null); then + _fd='' + fi + fi + if [[ -z "$_fd" ]]; then + # Last-resort single-line grep/sed fallback. The `|| true` guards against + # grep returning 1 (no match) aborting under `set -e` / `pipefail`. + _fd=$( { grep -E '"feature_directory"[[:space:]]*:' "$fj" 2>/dev/null || true; } \ + | head -n 1 \ + | sed -E 's/^[^:]*:[[:space:]]*"([^"]*)".*$/\1/' ) + fi + + printf '%s' "$_fd" + return 0 +} + +# Persist a feature_directory value to .specify/feature.json. +# Writes only when the file is missing or the value differs from what's stored. +# Accepts the raw (possibly relative) path — callers should pass the original +# user-supplied value, not the normalized absolute path. +_persist_feature_json() { + local repo_root="$1" + local feature_dir_value="$2" + local fj="$repo_root/.specify/feature.json" + + # Strip repo_root prefix if the value is absolute and under repo_root + if [[ "$feature_dir_value" == "$repo_root/"* ]]; then + feature_dir_value="${feature_dir_value#"$repo_root/"}" + fi + + # Read current value (if any) and skip write when unchanged + local current_val + current_val=$(read_feature_json_feature_directory "$repo_root") + if [[ "$current_val" == "$feature_dir_value" ]]; then + return 0 + fi + + # Ensure .specify/ directory exists + mkdir -p "$repo_root/.specify" + + # Write feature.json — prefer jq for safe JSON, fall back to printf + if command -v jq >/dev/null 2>&1; then + jq -cn --arg fd "$feature_dir_value" '{feature_directory:$fd}' > "$fj" + else + printf '{"feature_directory":"%s"}\n' "$(json_escape "$feature_dir_value")" > "$fj" + fi +} + +get_feature_paths() { + # Read-only callers (e.g. check-prerequisites.sh --paths-only) pass + # --no-persist so pure path resolution never writes .specify/feature.json, + # which would dirty the working tree or overwrite a pinned value (issue #3025). + local no_persist=false + if [[ "${1:-}" == "--no-persist" ]]; then + no_persist=true + shift + fi + # SPECIFY_FEATURE_NO_PERSIST is the environment-level equivalent of --no-persist, + # letting an orchestrator (multi-agent runner, CI matrix) guarantee that no + # script invocation in the process tree writes .specify/feature.json, even + # scripts that don't pass --no-persist themselves (#4128). + if [[ "${SPECIFY_FEATURE_NO_PERSIST:-}" == "1" || "${SPECIFY_FEATURE_NO_PERSIST:-}" == "true" ]]; then + no_persist=true + fi + + # Split decl/assignment so a SPECIFY_INIT_DIR validation failure in + # get_repo_root propagates as a hard error instead of being masked by `local`. + local repo_root + repo_root=$(get_repo_root) || return 1 + local current_branch + current_branch=$(get_current_branch) + + # Resolve feature directory. Priority: + # 1. SPECIFY_FEATURE_DIRECTORY env var (explicit override) + # 2. .specify/feature.json "feature_directory" key (persisted by specify command) + # 3. Error — no feature context available + local feature_dir + if [[ -n "${SPECIFY_FEATURE_DIRECTORY:-}" ]]; then + feature_dir="$SPECIFY_FEATURE_DIRECTORY" + # Normalize relative paths to absolute under repo root + [[ "$feature_dir" != /* ]] && feature_dir="$repo_root/$feature_dir" + # Persist to feature.json so future sessions without the env var still + # work — unless the caller opted out for read-only resolution (#3025). + if [[ "$no_persist" != true ]]; then + _persist_feature_json "$repo_root" "$SPECIFY_FEATURE_DIRECTORY" + fi + elif [[ -f "$repo_root/.specify/feature.json" ]]; then + local _fd + _fd=$(read_feature_json_feature_directory "$repo_root") + if [[ -n "$_fd" ]]; then + feature_dir="$_fd" + # Normalize relative paths to absolute under repo root + [[ "$feature_dir" != /* ]] && feature_dir="$repo_root/$feature_dir" + else + echo "ERROR: Feature directory not found. Set SPECIFY_FEATURE_DIRECTORY or ensure .specify/feature.json contains feature_directory." >&2 + return 1 + fi + else + echo "ERROR: Feature directory not found. Set SPECIFY_FEATURE_DIRECTORY or run the specify command to create .specify/feature.json." >&2 + return 1 + fi + + # When no branch context exists (no SPECIFY_FEATURE, feature resolved via + # SPECIFY_FEATURE_DIRECTORY or feature.json), fall back to the feature + # directory basename so CURRENT_BRANCH is a usable identifier rather than + # an empty, misleading value (issue #3026). + if [[ -z "$current_branch" ]]; then + local feature_dir_trimmed="${feature_dir%/}" + current_branch="${feature_dir_trimmed##*/}" + fi + + # Use printf '%q' to safely quote values, preventing shell injection + # via crafted branch names or paths containing special characters + printf 'REPO_ROOT=%q\n' "$repo_root" + printf 'CURRENT_BRANCH=%q\n' "$current_branch" + printf 'FEATURE_DIR=%q\n' "$feature_dir" + printf 'FEATURE_SPEC=%q\n' "$feature_dir/spec.md" + printf 'IMPL_PLAN=%q\n' "$feature_dir/plan.md" + printf 'TASKS=%q\n' "$feature_dir/tasks.md" + printf 'RESEARCH=%q\n' "$feature_dir/research.md" + printf 'DATA_MODEL=%q\n' "$feature_dir/data-model.md" + printf 'QUICKSTART=%q\n' "$feature_dir/quickstart.md" + printf 'CONTRACTS_DIR=%q\n' "$feature_dir/contracts" +} + +# Check if jq is available for safe JSON construction +has_jq() { + command -v jq >/dev/null 2>&1 +} + +get_invoke_separator() { + local repo_root="${1:-$(get_repo_root)}" + if [[ "${_SPECIFY_INVOKE_SEPARATOR_CACHE_REPO_ROOT:-}" == "$repo_root" && -n "${_SPECIFY_INVOKE_SEPARATOR_CACHE_VALUE:-}" ]]; then + printf '%s\n' "$_SPECIFY_INVOKE_SEPARATOR_CACHE_VALUE" + return 0 + fi + + local integration_json="$repo_root/.specify/integration.json" + local separator="." + local parsed=0 + + if [[ -f "$integration_json" ]]; then + # Try parsers in order (jq -> python3 -> awk), falling through on + # failure. Selection is by *parse success*, not mere availability: on + # Windows `python3` commonly resolves to the Microsoft Store App + # Execution Alias stub, which passes `command -v` but fails at runtime + # (exit 49). An availability-gated branch would pick python3, swallow + # its failure, and — because this function historically had no text + # fallback — silently return "." even for `-`-separator integrations + # (e.g. forge, cline), yielding wrong command hints (issue #3304). + if command -v jq >/dev/null 2>&1; then + local jq_separator + if jq_separator=$(jq -r '(.default_integration // .integration // "") as $k | if $k == "" then "." else (.integration_settings[$k].invoke_separator // ".") end' "$integration_json" 2>/dev/null); then + case "$jq_separator" in + "."|"-") separator="$jq_separator"; parsed=1 ;; + esac + fi + fi + + if [[ "$parsed" -eq 0 ]] && command -v python3 >/dev/null 2>&1; then + local py_separator + if py_separator=$(python3 - "$integration_json" <<'PY' 2>/dev/null +import json +import sys + +try: + with open(sys.argv[1], encoding="utf-8") as fh: + state = json.load(fh) + key = state.get("default_integration") or state.get("integration") or "" + settings = state.get("integration_settings") + separator = "." + if isinstance(key, str) and isinstance(settings, dict): + entry = settings.get(key) + if isinstance(entry, dict) and entry.get("invoke_separator") in {".", "-"}: + separator = entry["invoke_separator"] + print(separator) +except Exception: + sys.exit(1) +PY +); then + case "$py_separator" in + "."|"-") separator="$py_separator"; parsed=1 ;; + esac + fi + fi + + if [[ "$parsed" -eq 0 ]]; then + # Last-resort text fallback for environments with neither jq nor a + # working python3 (e.g. stock Windows + Git Bash). Reads the active + # integration key (default_integration, else integration) and its + # invoke_separator from within the integration_settings object. + # Handles both pretty-printed (the written form) and compact JSON. + # Accumulate all lines into one buffer in END rather than using + # gawk-only whole-file slurp (RS="^$"), so this stays portable to + # the BSD awk on macOS. + local awk_separator + awk_separator=$(awk ' + function keyval(d, name, v) { + if (match(d, "\"" name "\"[ \t\r\n]*:[ \t\r\n]*\"[^\"]*\"")) { + v=substr(d,RSTART,RLENGTH); sub(/^.*:[ \t\r\n]*"/,"",v); sub(/"$/,"",v); return v + } + return "" + } + { doc = doc $0 "\n" } + END { + key=keyval(doc,"default_integration"); if (key=="") key=keyval(doc,"integration") + sep="." + if (key!="") { + settings=doc + if (match(doc, /"integration_settings"[ \t\r\n]*:[ \t\r\n]*[{]/)) { + settings=substr(doc, RSTART+RLENGTH-1) + } + if (match(settings, "\"" key "\"[ \t\r\n]*:[ \t\r\n]*[{]")) { + start=RSTART+RLENGTH-1 + depth=0 + obj="" + for (i=start; i<=length(settings); i++) { + c=substr(settings,i,1) + obj=obj c + if (c=="{") depth++ + else if (c=="}") { depth--; if (depth==0) break } + } + if (match(obj, /"invoke_separator"[ \t\r\n]*:[ \t\r\n]*"[-.]"/)) { + tok=substr(obj,RSTART,RLENGTH); s=substr(tok,length(tok)-1,1) + if (s=="." || s=="-") sep=s + } + } + } + print sep + } + ' "$integration_json" 2>/dev/null) + case "$awk_separator" in + "."|"-") separator="$awk_separator" ;; + esac + fi + fi + + _SPECIFY_INVOKE_SEPARATOR_CACHE_REPO_ROOT="$repo_root" + _SPECIFY_INVOKE_SEPARATOR_CACHE_VALUE="$separator" + printf '%s\n' "$separator" +} + +format_speckit_command() { + local command_name="$1" + local repo_root="${2:-$(get_repo_root)}" + local separator + if [[ "${_SPECIFY_INVOKE_SEPARATOR_CACHE_REPO_ROOT:-}" == "$repo_root" && -n "${_SPECIFY_INVOKE_SEPARATOR_CACHE_VALUE:-}" ]]; then + separator="$_SPECIFY_INVOKE_SEPARATOR_CACHE_VALUE" + else + separator=$(get_invoke_separator "$repo_root") + _SPECIFY_INVOKE_SEPARATOR_CACHE_REPO_ROOT="$repo_root" + _SPECIFY_INVOKE_SEPARATOR_CACHE_VALUE="$separator" + fi + + command_name="${command_name#/}" + command_name="${command_name#speckit.}" + command_name="${command_name#speckit-}" + command_name="${command_name//./$separator}" + + printf '/speckit%s%s\n' "$separator" "$command_name" +} + +# Escape a string for safe embedding in a JSON value (fallback when jq is unavailable). +# Handles backslash, double-quote, and JSON-required control character escapes (RFC 8259). +json_escape() { + local s="$1" + s="${s//\\/\\\\}" + s="${s//\"/\\\"}" + s="${s//$'\n'/\\n}" + s="${s//$'\t'/\\t}" + s="${s//$'\r'/\\r}" + s="${s//$'\b'/\\b}" + s="${s//$'\f'/\\f}" + # Escape any remaining U+0001-U+001F control characters as \uXXXX. + # (U+0000/NUL cannot appear in bash strings and is excluded.) + # LC_ALL=C ensures ${#s} counts bytes and ${s:$i:1} yields single bytes, + # so multi-byte UTF-8 sequences (first byte >= 0xC0) pass through intact. + local LC_ALL=C + local i char code + for (( i=0; i<${#s}; i++ )); do + char="${s:$i:1}" + printf -v code '%d' "'$char" 2>/dev/null || code=256 + if (( code >= 1 && code <= 31 )); then + printf '\\u%04x' "$code" + else + printf '%s' "$char" + fi + done +} + +check_file() { [[ -f "$1" ]] && echo " ✓ $2" || echo " ✗ $2"; } +check_dir() { [[ -d "$1" && -n $(ls -A "$1" 2>/dev/null) ]] && echo " ✓ $2" || echo " ✗ $2"; } + +_python3_command() { + # SPECKIT_PYTHON_EXECUTABLE is the canonical override; SPECKIT_PYTHON is + # kept as a deprecated fallback (still used by update-agent-context.sh). + local override="${SPECKIT_PYTHON_EXECUTABLE:-${SPECKIT_PYTHON:-}}" + if [[ -n "$override" ]] && command -v "$override" >/dev/null 2>&1 && + "$override" -c 'import sys; raise SystemExit(sys.version_info.major != 3)' >/dev/null 2>&1 && + "$override" -c 'import yaml' >/dev/null 2>&1; then + printf '%s\n' "$override" + elif command -v python3 >/dev/null 2>&1 && + python3 -c 'import sys; raise SystemExit(sys.version_info.major != 3)' >/dev/null 2>&1; then + printf '%s\n' "python3" + elif command -v python >/dev/null 2>&1 && + python -c 'import sys; raise SystemExit(sys.version_info.major != 3)' >/dev/null 2>&1; then + printf '%s\n' "python" + elif command -v py >/dev/null 2>&1 && + py -3 -c 'import sys' >/dev/null 2>&1; then + printf '%s\n' "py" "-3" + else + return 1 + fi +} + +_sorted_extension_ids() { + local ext_dir="$1" + local -a python_cmd=() + local _python_cmd_line + while IFS= read -r _python_cmd_line; do + python_cmd+=("$_python_cmd_line") + done < <(_python3_command) + if [ "${#python_cmd[@]}" -gt 0 ]; then + local py_stderr sorted_ids + py_stderr=$(mktemp) + if sorted_ids=$(SPECKIT_EXTENSIONS="$ext_dir" "${python_cmd[@]}" -c " +import json, os, re, sys +from pathlib import Path + +root = Path(os.environ['SPECKIT_EXTENSIONS']) +registered = {} +registry = root / '.registry' +if os.path.lexists(registry): + if not registry.is_file(): + print('registry_invalid: not a regular file', file=sys.stderr) + sys.exit(1) + try: + data = json.loads(registry.read_text(encoding='utf-8')) + except Exception as exc: + print('registry_invalid: ' + str(exc), file=sys.stderr) + sys.exit(1) + if not isinstance(data, dict): + print('registry_invalid: root must be a mapping', file=sys.stderr) + sys.exit(1) + raw_extensions = data.get('extensions', {}) + if not isinstance(raw_extensions, dict): + print('registry_invalid: extensions must be a mapping', file=sys.stderr) + sys.exit(1) + registered = raw_extensions + +def priority(value): + if isinstance(value, bool): + return 10 + try: + parsed = int(value) + return parsed if parsed >= 1 else 10 + except (TypeError, ValueError, OverflowError): + return 10 + +ranked = [] +for ext_id, meta in registered.items(): + if isinstance(ext_id, str) and re.fullmatch(r'[a-z0-9-]+', ext_id) and isinstance(meta, dict) and bool(meta.get('enabled', True)): + ranked.append((priority(meta.get('priority')), ext_id)) +for path in root.iterdir(): + if path.is_dir() and re.fullmatch(r'[a-z0-9-]+', path.name) and path.name not in registered: + ranked.append((10, path.name)) +for _, ext_id in sorted(ranked): + print(ext_id) +" 2>"$py_stderr"); then + rm -f "$py_stderr" + printf '%s\n' "$sorted_ids" + return 0 + else + echo "Error: invalid extension registry $ext_dir/.registry" >&2 + rm -f "$py_stderr" + return 1 + fi + fi + + if [ -e "$ext_dir/.registry" ] || [ -L "$ext_dir/.registry" ]; then + if [ ! -f "$ext_dir/.registry" ] || [ ! -r "$ext_dir/.registry" ]; then + echo "Error: invalid extension registry $ext_dir/.registry" >&2 + return 1 + fi + echo "Error: Python 3 is required to honor the extension registry" >&2 + return 2 + fi + + local ext extension_id + for ext in "$ext_dir"/*/; do + [ -d "$ext" ] || continue + extension_id=$(basename "$ext") + case "$extension_id" in *[!a-z0-9-]*) continue ;; esac + printf '%s\n' "$extension_id" + done +} + +# Resolve a template name to a file path using the priority stack: +# 1. .specify/templates/overrides/ +# 2. .specify/presets//templates/ (sorted by priority from .registry) +# 3. .specify/extensions//templates/ +# 4. .specify/templates/ (core) +resolve_template() { + local template_name="$1" + local repo_root="$2" + local base="$repo_root/.specify/templates" + + case "$template_name" in ""|*[!a-z0-9-]*) return 1 ;; esac + + # Priority 1: Project overrides + local override="$base/overrides/${template_name}.md" + [ -f "$override" ] && echo "$override" && return 0 + + # Priority 2: Installed presets (sorted by priority from .registry) + local presets_dir="$repo_root/.specify/presets" + if [ -d "$presets_dir" ]; then + local registry_file="$presets_dir/.registry" + local -a python_cmd=() + local _python_cmd_line + while IFS= read -r _python_cmd_line; do + python_cmd+=("$_python_cmd_line") + done < <(_python3_command) + if [ -f "$registry_file" ] && [ "${#python_cmd[@]}" -gt 0 ]; then + # Read preset IDs sorted by priority (lower number = higher precedence). + # The python3 call is wrapped in an if-condition so that set -e does not + # abort the function when python3 exits non-zero (e.g. invalid JSON). + local sorted_presets="" + if sorted_presets=$(SPECKIT_REGISTRY="$registry_file" "${python_cmd[@]}" -c " +import json, re, sys, os +try: + with open(os.environ['SPECKIT_REGISTRY'], encoding='utf-8') as f: + data = json.load(f) + presets = data.get('presets', {}) + def priority(meta): + if not isinstance(meta, dict) or isinstance(meta.get('priority'), bool): + return 10 + try: + value = int(meta.get('priority', 10)) + return value if value >= 1 else 10 + except (TypeError, ValueError, OverflowError): + return 10 + for pid, meta in sorted(presets.items(), key=lambda x: (priority(x[1]), x[0])): + if isinstance(meta, dict) and bool(meta.get('enabled', True)) and re.fullmatch(r'[a-z0-9-]+', pid): + print(pid) +except Exception: + sys.exit(1) +" 2>/dev/null); then + if [ -n "$sorted_presets" ]; then + # python3 succeeded and returned preset IDs — search in priority order + while IFS= read -r preset_id; do + local candidate="$presets_dir/$preset_id/templates/${template_name}.md" + [ -f "$candidate" ] && echo "$candidate" && return 0 + candidate="$presets_dir/$preset_id/${template_name}.md" + [ -f "$candidate" ] && echo "$candidate" && return 0 + done <<< "$sorted_presets" + fi + # python3 succeeded but registry has no presets — nothing to search + else + # python3 failed (missing, or registry parse error) — fall back to unordered directory scan + for preset in "$presets_dir"/*/; do + [ -d "$preset" ] || continue + local candidate="$preset/templates/${template_name}.md" + [ -f "$candidate" ] && echo "$candidate" && return 0 + candidate="$preset/${template_name}.md" + [ -f "$candidate" ] && echo "$candidate" && return 0 + done + fi + else + # Fallback: alphabetical directory order (no python3 available) + for preset in "$presets_dir"/*/; do + [ -d "$preset" ] || continue + local candidate="$preset/templates/${template_name}.md" + [ -f "$candidate" ] && echo "$candidate" && return 0 + candidate="$preset/${template_name}.md" + [ -f "$candidate" ] && echo "$candidate" && return 0 + done + fi + fi + + # Priority 3: Extension-provided templates + local ext_dir="$repo_root/.specify/extensions" + if [ -d "$ext_dir" ]; then + local sorted_extensions="" + if ! sorted_extensions=$(_sorted_extension_ids "$ext_dir"); then + return 2 + fi + while IFS= read -r extension_id; do + [ -n "$extension_id" ] || continue + local ext="$ext_dir/$extension_id" + local candidate="$ext/templates/${template_name}.md" + [ -f "$candidate" ] || candidate="$ext/${template_name}.md" + [ -f "$candidate" ] && echo "$candidate" && return 0 + done <<< "$sorted_extensions" + fi + + # Priority 4: Core templates + local core="$base/${template_name}.md" + [ -f "$core" ] && echo "$core" && return 0 + + # Template not found in any location. + # Return 1 so callers can distinguish "not found" from "found". + # Callers running under set -e should use: TEMPLATE=$(resolve_template ...) || true + return 1 +} + +# Resolve a template name to composed content using composition strategies. +# Reads strategy metadata from preset manifests and composes content +# from multiple layers using prepend, append, or wrap strategies. +# +# Usage: CONTENT=$(resolve_template_content "template-name" "$REPO_ROOT") +# Returns composed content string on stdout; exit code 1 if not found. +resolve_template_content() { + local template_name="$1" + local repo_root="$2" + local base="$repo_root/.specify/templates" + + case "$template_name" in ""|*[!a-z0-9-]*) return 1 ;; esac + + # Collect all layers (highest priority first) + local -a layer_paths=() + local -a layer_strategies=() + + # Priority 1: Project overrides (always "replace") + local override="$base/overrides/${template_name}.md" + if [ -f "$override" ]; then + if ! cat "$override"; then + echo "Error: failed to read template layer $override" >&2 + return 2 + fi + return 0 + fi + + local effective_base_found=false + + # Priority 2: Installed presets (sorted by priority from .registry) + local presets_dir="$repo_root/.specify/presets" + if [ -d "$presets_dir" ]; then + local registry_file="$presets_dir/.registry" + local sorted_presets="" + local registry_parsed=false + local -a python_cmd=() + local _python_cmd_line + while IFS= read -r _python_cmd_line; do + python_cmd+=("$_python_cmd_line") + done < <(_python3_command) + if [ -f "$registry_file" ] && [ "${#python_cmd[@]}" -gt 0 ]; then + if sorted_presets=$(SPECKIT_REGISTRY="$registry_file" "${python_cmd[@]}" -c " +import json, re, sys, os +try: + with open(os.environ['SPECKIT_REGISTRY'], encoding='utf-8') as f: + data = json.load(f) + presets = data.get('presets', {}) + def priority(meta): + if not isinstance(meta, dict) or isinstance(meta.get('priority'), bool): + return 10 + try: + value = int(meta.get('priority', 10)) + return value if value >= 1 else 10 + except (TypeError, ValueError, OverflowError): + return 10 + for pid, meta in sorted(presets.items(), key=lambda x: (priority(x[1]), x[0])): + if isinstance(meta, dict) and bool(meta.get('enabled', True)) and re.fullmatch(r'[a-z0-9-]+', pid): + print(pid) +except Exception: + sys.exit(1) +" 2>/dev/null); then + registry_parsed=true + fi + fi + if [ "$registry_parsed" = false ]; then + for preset in "$presets_dir"/*/; do + [ -d "$preset" ] || continue + local fallback_id + fallback_id=$(basename "$preset") + case "$fallback_id" in *[!a-z0-9-]*) continue ;; esac + sorted_presets+="${sorted_presets:+$'\n'}$fallback_id" + done + fi + + if [ -n "$sorted_presets" ]; then + while IFS= read -r preset_id; do + local strategy="replace" + local manifest_file="" + local manifest="$presets_dir/$preset_id/preset.yml" + local manifest_declared=false + if [ -f "$manifest" ]; then + if [ "${#python_cmd[@]}" -eq 0 ]; then + echo "Error: Python 3 and PyYAML are required to resolve preset template composition" >&2 + return 2 + fi + local result + local py_stderr + local parse_status + py_stderr=$(mktemp) + if result=$(SPECKIT_MANIFEST="$manifest" SPECKIT_TMPL="$template_name" "${python_cmd[@]}" -c " +import sys, os +try: + import yaml +except ImportError: + print('yaml_missing', file=sys.stderr) + sys.exit(2) +try: + with open(os.environ['SPECKIT_MANIFEST'], encoding='utf-8') as f: + data = yaml.safe_load(f) + if not isinstance(data, dict): + raise ValueError('manifest root must be a mapping') + if 'provides' not in data: + raise ValueError('manifest missing provides section') + provides = data['provides'] + if not isinstance(provides, dict): + raise ValueError('manifest provides must be a mapping') + if 'templates' not in provides: + raise ValueError('manifest provides missing templates') + templates = provides['templates'] + if not isinstance(templates, list): + raise ValueError('manifest templates must be a list') + if not templates: + raise ValueError('manifest must provide at least one template') + valid_types = ('template', 'command', 'script') + valid_strategies = ('replace', 'prepend', 'append', 'wrap') + for t in templates: + if not isinstance(t, dict): + raise ValueError('manifest template entries must be mappings') + if 'type' not in t or 'name' not in t or 'file' not in t: + raise ValueError('manifest template entry missing type, name, or file') + for field in ('type', 'name', 'file'): + if not isinstance(t[field], str): + raise ValueError('manifest template ' + field + ' must be a string') + if t['type'] not in valid_types: + raise ValueError('invalid manifest template type') + strategy = t.get('strategy', 'replace') + if not isinstance(strategy, str): + raise ValueError('manifest template strategy must be a string') + strategy = strategy.lower() + if strategy not in valid_strategies: + raise ValueError('invalid manifest template strategy') + if t['type'] == 'script' and strategy not in ('replace', 'wrap'): + raise ValueError('invalid manifest script strategy') + for t in templates: + if t.get('name') == os.environ['SPECKIT_TMPL'] and t.get('type', 'template') == 'template': + file_value = t.get('file', '') + strategy = t.get('strategy', 'replace') + print('found\t' + strategy + '\t' + file_value) + sys.exit(0) + print('absent\treplace\t') +except Exception as exc: + print(f'manifest_invalid: {exc}', file=sys.stderr) + sys.exit(3) +" 2>"$py_stderr"); then + parse_status=0 + else + parse_status=$? + fi + if [ "$parse_status" -ne 0 ]; then + if [ "$parse_status" -eq 2 ]; then + echo "Error: PyYAML is required to resolve preset template composition" >&2 + else + echo "Error: invalid preset manifest $manifest" >&2 + fi + rm -f "$py_stderr" + return 2 + fi + if [ -n "$result" ]; then + local declaration + IFS=$'\t' read -r declaration strategy manifest_file <<< "$result" + [ "$declaration" = "found" ] && manifest_declared=true + strategy=$(printf '%s' "$strategy" | tr '[:upper:]' '[:lower:]') + fi + rm -f "$py_stderr" + fi + + local candidate="" + if [ -n "$manifest_file" ]; then + case "$manifest_file" in + /*|*../*) manifest_file="" ;; + esac + fi + if [ -n "$manifest_file" ]; then + local mf="$presets_dir/$preset_id/$manifest_file" + [ -f "$mf" ] && candidate="$mf" + fi + if [ -z "$candidate" ] && [ "$manifest_declared" = false ]; then + local cf="$presets_dir/$preset_id/templates/${template_name}.md" + [ -f "$cf" ] && candidate="$cf" + if [ -z "$candidate" ]; then + cf="$presets_dir/$preset_id/${template_name}.md" + [ -f "$cf" ] && candidate="$cf" + fi + fi + if [ -n "$candidate" ]; then + layer_paths+=("$candidate") + layer_strategies+=("$strategy") + if [ "$strategy" = "replace" ]; then + effective_base_found=true + break + fi + fi + done <<< "$sorted_presets" + fi + fi + + # Priority 3: Extension-provided templates (always "replace") + local ext_dir="$repo_root/.specify/extensions" + if [ "$effective_base_found" = false ] && [ -d "$ext_dir" ]; then + local sorted_extensions="" + if ! sorted_extensions=$(_sorted_extension_ids "$ext_dir"); then + return 2 + fi + while IFS= read -r extension_id; do + [ -n "$extension_id" ] || continue + local ext="$ext_dir/$extension_id" + local candidate="$ext/templates/${template_name}.md" + [ -f "$candidate" ] || candidate="$ext/${template_name}.md" + if [ -f "$candidate" ]; then + layer_paths+=("$candidate") + layer_strategies+=("replace") + effective_base_found=true + break + fi + done <<< "$sorted_extensions" + fi + + # Priority 4: Core templates (always "replace") + local core="$base/${template_name}.md" + if [ "$effective_base_found" = false ] && [ -f "$core" ]; then + layer_paths+=("$core") + layer_strategies+=("replace") + fi + + local count=${#layer_paths[@]} + [ "$count" -eq 0 ] && return 1 + + # Check if any layer uses a non-replace strategy + local has_composition=false + for s in "${layer_strategies[@]}"; do + [ "$s" != "replace" ] && has_composition=true && break + done + + # If the top (highest-priority) layer is replace, it wins entirely — + # lower layers are irrelevant regardless of their strategies. + if [ "${layer_strategies[0]}" = "replace" ]; then + if ! cat "${layer_paths[0]}"; then + echo "Error: failed to read template layer ${layer_paths[0]}" >&2 + return 2 + fi + return 0 + fi + + if [ "$has_composition" = false ]; then + if ! cat "${layer_paths[0]}"; then + echo "Error: failed to read template layer ${layer_paths[0]}" >&2 + return 2 + fi + return 0 + fi + + # Find the effective base: scan from highest priority (index 0) downward + # to find the nearest replace layer. Only compose layers above that base. + local base_idx=-1 + local i + for (( i=0; i&2 + return 2 + fi + + # Read the base content; compose layers above the base (higher priority) + local content + if ! content=$(cat "${layer_paths[$base_idx]}"; status=$?; printf x; exit "$status"); then + echo "Error: failed to read template layer ${layer_paths[$base_idx]}" >&2 + return 2 + fi + content="${content%x}" + + for (( i=base_idx-1; i>=0; i-- )); do + local path="${layer_paths[$i]}" + local strat="${layer_strategies[$i]}" + local layer_content + # Preserve trailing newlines + if ! layer_content=$(cat "$path"; status=$?; printf x; exit "$status"); then + echo "Error: failed to read template layer $path" >&2 + return 2 + fi + layer_content="${layer_content%x}" + + case "$strat" in + replace) content="$layer_content" ;; + prepend) + content=$(printf '%s\n\n%s' "$layer_content" "$content"; printf x) + content="${content%x}" + ;; + append) + content=$(printf '%s\n\n%s' "$content" "$layer_content"; printf x) + content="${content%x}" + ;; + wrap) + case "$layer_content" in + *'{CORE_TEMPLATE}'*) ;; + *) echo "Error: wrap strategy missing {CORE_TEMPLATE} placeholder" >&2; return 2 ;; + esac + # Consume the wrapper left to right instead of rewriting it in + # place. Rewriting re-scanned the string just modified, so base + # content holding a literal {CORE_TEMPLATE} reintroduced the + # token every pass and the loop never terminated. Advancing over + # ``rest`` bounds the work by the tokens in the original wrapper + # and leaves inserted content untouched, matching the single-pass + # semantics of .Replace()/.replace() in the PowerShell and Python + # ports. + local wrapped="" rest="$layer_content" + while [[ "$rest" == *'{CORE_TEMPLATE}'* ]]; do + wrapped="${wrapped}${rest%%\{CORE_TEMPLATE\}*}${content}" + rest="${rest#*\{CORE_TEMPLATE\}}" + done + content="${wrapped}${rest}" + ;; + *) echo "Error: unknown strategy '$strat'" >&2; return 2 ;; + esac + done + + printf '%s' "$content" + return 0 +} diff --git a/.specify/scripts/bash/create-new-feature.sh b/.specify/scripts/bash/create-new-feature.sh new file mode 100755 index 0000000..3ce2f90 --- /dev/null +++ b/.specify/scripts/bash/create-new-feature.sh @@ -0,0 +1,504 @@ +#!/usr/bin/env bash + +set -e + +JSON_MODE=false +DRY_RUN=false +ALLOW_EXISTING=false +SHORT_NAME="" +BRANCH_NUMBER="" +USE_TIMESTAMP=false +NUMBER_EXPLICIT=false +ARGS=() +i=1 +while [ $i -le $# ]; do + arg="${!i}" + case "$arg" in + --json) + JSON_MODE=true + ;; + --dry-run) + DRY_RUN=true + ;; + --allow-existing-branch) + ALLOW_EXISTING=true + ;; + --short-name) + if [ $((i + 1)) -gt $# ]; then + echo 'Error: --short-name requires a value' >&2 + exit 1 + fi + i=$((i + 1)) + next_arg="${!i}" + # Check if the next argument is another option (starts with --) + if [[ "$next_arg" == --* ]]; then + echo 'Error: --short-name requires a value' >&2 + exit 1 + fi + SHORT_NAME="$next_arg" + ;; + --number) + if [ $((i + 1)) -gt $# ]; then + echo 'Error: --number requires a value' >&2 + exit 1 + fi + i=$((i + 1)) + next_arg="${!i}" + if [[ "$next_arg" == --* ]]; then + echo 'Error: --number requires a value' >&2 + exit 1 + fi + BRANCH_NUMBER="$next_arg" + if [ -n "$BRANCH_NUMBER" ]; then + NUMBER_EXPLICIT=true + fi + ;; + --timestamp) + USE_TIMESTAMP=true + ;; + --help|-h) + echo "Usage: $0 [--json] [--dry-run] [--allow-existing-branch] [--short-name ] [--number N] [--timestamp] " + echo "" + echo "Options:" + echo " --json Output in JSON format" + echo " --dry-run Compute feature name and paths without creating directories or files" + echo " --allow-existing-branch Reuse an existing feature directory if it already exists" + echo " --short-name Provide a custom short name (2-4 words) for the feature" + echo " --number N Prefer a feature number (auto-corrected if its specs prefix exists)" + echo " --timestamp Use timestamp prefix (YYYYMMDD-HHMMSS) instead of sequential numbering" + echo " --help, -h Show this help message" + echo "" + echo "Examples:" + echo " $0 'Add user authentication system' --short-name 'user-auth'" + echo " $0 'Implement OAuth2 integration for API' --number 5" + echo " $0 --timestamp --short-name 'user-auth' 'Add user authentication'" + exit 0 + ;; + *) + ARGS+=("$arg") + ;; + esac + i=$((i + 1)) +done + +FEATURE_DESCRIPTION="${ARGS[*]}" +if [ -z "$FEATURE_DESCRIPTION" ]; then + echo "Usage: $0 [--json] [--dry-run] [--allow-existing-branch] [--short-name ] [--number N] [--timestamp] " >&2 + exit 1 +fi + +# Trim whitespace and validate description is not empty (e.g., user passed only whitespace) +FEATURE_DESCRIPTION=$(echo "$FEATURE_DESCRIPTION" | sed -E 's/^[[:space:]]+|[[:space:]]+$//g') +if [ -z "$FEATURE_DESCRIPTION" ]; then + echo "Error: Feature description cannot be empty or contain only whitespace" >&2 + exit 1 +fi + +MAX_FEATURE_NUMBER=9223372036854775807 +MAX_BRANCH_LENGTH=244 + +is_feature_number_in_range() { + local value="$1" + local normalized="${value#"${value%%[!0]*}"}" + [ -n "$normalized" ] || normalized=0 + [ ${#normalized} -lt ${#MAX_FEATURE_NUMBER} ] && return 0 + [ ${#normalized} -gt ${#MAX_FEATURE_NUMBER} ] && return 1 + # Equal-length digit strings must be compared without arithmetic overflow. + # shellcheck disable=SC2071 + [[ "$normalized" < "$MAX_FEATURE_NUMBER" || "$normalized" == "$MAX_FEATURE_NUMBER" ]] +} + +# Function to get highest number from specs directory +get_highest_from_specs() { + local specs_dir="$1" + local highest=0 + + if [ -d "$specs_dir" ]; then + for dir in "$specs_dir"/*; do + [ -d "$dir" ] || continue + dirname=$(basename "$dir") + # Match sequential prefixes (>=3 digits), but skip timestamp dirs. + if echo "$dirname" | grep -Eq '^[0-9]{3,}-' && ! echo "$dirname" | grep -Eq '^[0-9]{8}-[0-9]{6}-'; then + number=$(echo "$dirname" | grep -Eo '^[0-9]+') + if is_feature_number_in_range "$number"; then + number=$((10#$number)) + if [ "$number" -gt "$highest" ]; then + highest=$number + fi + fi + fi + done + fi + + echo "$highest" +} + +# Return success when a spec directory owns the given numeric prefix. +spec_prefix_exists() { + local specs_dir="$1" + local feature_num="$2" + + for spec_path in "$specs_dir/${feature_num}-"*; do + [ -d "$spec_path" ] && return 0 + done + return 1 +} + +# Function to clean and format a branch name +# +# Three details keep this consistent with the Python and PowerShell twins: +# * Unicode classification uses Python: POSIX [:alnum:] differs by platform. +# * `--*` instead of the GNU-only `\+`, which POSIX/BSD sed reads as a literal +# '+', leaving repeated separators uncollapsed on macOS. +# * printf instead of echo, so a name of "-n"/"-e"/"-E" is text, not options. +contains_non_ascii() { + LC_ALL=C grep -q '[^[:print:][:cntrl:]]' +} + +UNICODE_LOCALE="" +locale_candidates=(C.UTF-8 C.utf8 en_US.UTF-8 en_US.utf8 "${LC_CTYPE:-${LANG:-}}") +if [ -n "${LC_ALL:-}" ]; then + locale_candidates=("$LC_ALL") +fi +for candidate in "${locale_candidates[@]}"; do + if [ -n "$candidate" ] && [ "$(printf 'é。' | LC_ALL="$candidate" sed 's/[^[:alnum:]]/-/g' 2>/dev/null)" = 'é-' ]; then + UNICODE_LOCALE="$candidate" + break + fi +done + +if [ -z "$UNICODE_LOCALE" ]; then + UNICODE_LOCALE=C + if printf '%s' "${SHORT_NAME:-$FEATURE_DESCRIPTION}" | contains_non_ascii; then + if [ -n "${LC_ALL:-}" ]; then + echo "Error: A UTF-8 locale is required to create a Unicode feature name; LC_ALL=$LC_ALL is not usable" >&2 + else + echo "Error: A UTF-8 locale is required to create a Unicode feature name" >&2 + fi + exit 1 + fi +fi + +unicode_words() { + local name="${1//$'\n'/ }" + local separator="$2" + if printf '%s' "$name" | contains_non_ascii; then + local -a python_cmd=() + local override="${SPECKIT_PYTHON_EXECUTABLE:-${SPECKIT_PYTHON:-}}" + if [ -n "$override" ] && command -v "$override" >/dev/null 2>&1 && + "$override" -c 'import sys; raise SystemExit(sys.version_info.major != 3)' >/dev/null 2>&1; then + python_cmd=("$override") + else + local python_line + while IFS= read -r python_line; do + python_cmd+=("$python_line") + done < <(_python3_command) + fi + if [ "${#python_cmd[@]}" -eq 0 ]; then + echo "Error: Python 3 is required to create a Unicode feature name" >&2 + return 1 + fi + printf '%s' "$name" | "${python_cmd[@]}" -c ' +import sys +value = sys.stdin.buffer.read().decode("utf-8") +lower = str.maketrans("ABCDEFGHIJKLMNOPQRSTUVWXYZ", "abcdefghijklmnopqrstuvwxyz") +result = "".join( + char if char.isalpha() or char.isdecimal() else sys.argv[1] + for char in value.translate(lower) +) +sys.stdout.buffer.write(result.encode("utf-8")) +' "$separator" + else + printf '%s' "$name" | LC_ALL=C tr '[:upper:]' '[:lower:]' | LC_ALL=C sed "s/[^a-z0-9]/$separator/g" + fi +} + +clean_branch_name() { + local name="$1" + local cleaned + cleaned=$(unicode_words "$name" '-') || return 1 + printf '%s\n' "$cleaned" | sed 's/--*/-/g' | sed 's/^-//' | sed 's/-$//' +} + +branch_byte_count() { + printf '%s' "$1" | wc -c | tr -d '[:space:]' +} + +# Fit a feature prefix and suffix within GitHub's branch-name limit. +fit_branch_name() { + local feature_num="$1" + local branch_suffix="$2" + local branch_name="${feature_num}-${branch_suffix}" + + if [ "$(branch_byte_count "$branch_name")" -gt "$MAX_BRANCH_LENGTH" ]; then + local prefix_length=$(( ${#feature_num} + 1 )) + local max_suffix_length=$((MAX_BRANCH_LENGTH - prefix_length)) + local truncated_suffix + local -x LC_ALL="$UNICODE_LOCALE" + local low=0 high=${#branch_suffix} mid + if (( high > max_suffix_length )); then + high=$max_suffix_length + fi + while (( low < high )); do + mid=$(((low + high + 1) / 2)) + if [ "$(branch_byte_count "${branch_suffix:0:$mid}")" -le "$max_suffix_length" ]; then + low=$mid + else + high=$((mid - 1)) + fi + done + truncated_suffix="${branch_suffix:0:$low}" + truncated_suffix="${truncated_suffix%-}" + branch_name="${feature_num}-${truncated_suffix}" + fi + + printf '%s' "$branch_name" +} + +# Quote a value for POSIX shell reuse, byte-identical to Python's shlex.quote +# so the persistence hints match the Python variant exactly (printf %q output +# differs between bash versions and from shlex.quote for spaces/metachars). +shell_quote() { + local value="$1" LC_ALL=C + if [[ "$value" =~ ^[A-Za-z0-9_@%+=:,./-]+$ ]]; then + printf '%s' "$value" + else + local q="'\"'\"'" + printf "'%s'" "${value//\'/$q}" + fi +} + +# Resolve repository root using common.sh functions which prioritize .specify +SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$SCRIPT_DIR/common.sh" + +REPO_ROOT=$(get_repo_root) || exit 1 + +cd "$REPO_ROOT" + +SPECS_DIR="$REPO_ROOT/specs" +if [ "$DRY_RUN" != true ]; then + mkdir -p "$SPECS_DIR" +fi + +# Function to generate branch name with stop word filtering and length filtering +generate_branch_name() { + local description="$1" + + # Common stop words to filter out + local stop_words="^(i|a|an|the|to|for|of|in|on|at|by|with|from|is|are|was|were|be|been|being|have|has|had|do|does|did|will|would|should|could|can|may|might|must|shall|this|that|these|those|my|your|our|their|want|need|add|get|set)$" + + # Use a UTF-8 locale for character-safe length checks and split words. + local -x LC_ALL="$UNICODE_LOCALE" + local clean_name + clean_name=$(unicode_words "$description" ' ') || return 1 + + # Filter words: remove stop words and words shorter than 3 chars (unless they're uppercase acronyms in original) + local meaningful_words=() + for word in $clean_name; do + # Skip empty words + [ -z "$word" ] && continue + + # Retain non-ASCII words even when shorter than three characters. + if ! printf '%s\n' "$word" | LC_ALL=C grep -qE "$stop_words"; then + if [ ${#word} -ge 3 ] || printf '%s' "$word" | contains_non_ascii; then + meaningful_words+=("$word") + # Keep short words that appear as an uppercase acronym in the original. + # Uppercase via tr and match with grep -w (both portable) rather than + # bash's 4+ "^^" case expansion (breaks on macOS bash 3.2) and \b (non-POSIX). + elif printf '%s' "$description" | LC_ALL=C grep -qw -- "$(printf '%s' "$word" | LC_ALL=C tr '[:lower:]' '[:upper:]')"; then + meaningful_words+=("$word") + fi + fi + done + + # If we have meaningful words, use first 3-4 of them + if [ ${#meaningful_words[@]} -gt 0 ]; then + local max_words=3 + if [ ${#meaningful_words[@]} -eq 4 ]; then max_words=4; fi + + local result="" + local count=0 + for word in "${meaningful_words[@]}"; do + if [ $count -ge $max_words ]; then break; fi + if [ -n "$result" ]; then result="$result-"; fi + result="$result$word" + count=$((count + 1)) + done + echo "$result" + else + # Fallback to original logic if no meaningful words found + local cleaned=$(clean_branch_name "$description") + echo "$cleaned" | tr '-' '\n' | grep -v '^$' | head -3 | tr '\n' '-' | sed 's/-$//' + fi +} + +# Generate branch name +if [ -n "$SHORT_NAME" ]; then + # Use provided short name, just clean it up + BRANCH_SUFFIX=$(clean_branch_name "$SHORT_NAME") +else + # Generate from description with smart filtering + BRANCH_SUFFIX=$(generate_branch_name "$FEATURE_DESCRIPTION") +fi + +if [ -z "$BRANCH_SUFFIX" ]; then + echo "[specify] Warning: Feature name is empty after removing unsupported characters. Use --short-name with letters or digits (for example, user-auth)." >&2 +fi + +# Warn if --number and --timestamp are both specified +if [ "$USE_TIMESTAMP" = true ] && [ -n "$BRANCH_NUMBER" ]; then + >&2 echo "[specify] Warning: --number is ignored when --timestamp is used" + BRANCH_NUMBER="" +fi + +# Determine branch prefix +if [ "$USE_TIMESTAMP" = true ]; then + FEATURE_NUM=$(date +%Y%m%d-%H%M%S) + BRANCH_NAME="${FEATURE_NUM}-${BRANCH_SUFFIX}" +else + if [ -n "$BRANCH_NUMBER" ] && [[ ! "$BRANCH_NUMBER" =~ ^[0-9]+$ ]]; then + echo "Error: --number must be an unsigned integer, got '$BRANCH_NUMBER'" >&2 + exit 1 + fi + + # Bash arithmetic is signed 64-bit; reject digit strings that would wrap. + if [ -n "$BRANCH_NUMBER" ] && ! is_feature_number_in_range "$BRANCH_NUMBER"; then + echo "Error: --number must be between 0 and $MAX_FEATURE_NUMBER, got '$BRANCH_NUMBER'" >&2 + exit 1 + fi + + # Determine branch number from existing feature directories + if [ -z "$BRANCH_NUMBER" ]; then + HIGHEST=$(get_highest_from_specs "$SPECS_DIR") + if [ "$HIGHEST" -eq "$MAX_FEATURE_NUMBER" ]; then + echo "Error: feature number must be between 0 and $MAX_FEATURE_NUMBER, got '9223372036854775808'" >&2 + exit 1 + fi + BRANCH_NUMBER=$((HIGHEST + 1)) + fi + + # Force base-10 interpretation to prevent octal conversion (e.g., 010 → 8 in octal, but should be 10 in decimal) + FEATURE_NUM=$(printf "%03d" "$((10#$BRANCH_NUMBER))") + + # Treat an explicit number as a preference when its prefix is already used + # by a feature directory. Auto-detected numbers are already conflict-free. + if [ "$NUMBER_EXPLICIT" = true ]; then + SPEC_CONFLICT=false + REQUESTED_BRANCH_NAME=$(fit_branch_name "$FEATURE_NUM" "$BRANCH_SUFFIX") + REQUESTED_DIR="$SPECS_DIR/$REQUESTED_BRANCH_NAME" + if [ "$ALLOW_EXISTING" != true ] || [ ! -d "$REQUESTED_DIR" ]; then + spec_prefix_exists "$SPECS_DIR" "$FEATURE_NUM" && SPEC_CONFLICT=true + fi + + if [ "$SPEC_CONFLICT" = true ]; then + REQUESTED_NUM="$FEATURE_NUM" + HIGHEST=$(get_highest_from_specs "$SPECS_DIR") + BRANCH_NUMBER=$HIGHEST + while true; do + if [ "$BRANCH_NUMBER" -eq "$MAX_FEATURE_NUMBER" ]; then + echo "Error: feature number must be between 0 and $MAX_FEATURE_NUMBER, got '9223372036854775808'" >&2 + exit 1 + fi + BRANCH_NUMBER=$((BRANCH_NUMBER + 1)) + FEATURE_NUM=$(printf "%03d" "$((10#$BRANCH_NUMBER))") + spec_prefix_exists "$SPECS_DIR" "$FEATURE_NUM" || break + done + >&2 echo "[specify] Warning: --number $REQUESTED_NUM conflicts with an existing spec directory; using $FEATURE_NUM instead" + fi + fi + +fi + +# GitHub enforces a 244-byte limit on branch names +# Validate and truncate if necessary +ORIGINAL_BRANCH_NAME="${FEATURE_NUM}-${BRANCH_SUFFIX}" +BRANCH_NAME=$(fit_branch_name "$FEATURE_NUM" "$BRANCH_SUFFIX") +if [ "$BRANCH_NAME" != "$ORIGINAL_BRANCH_NAME" ]; then + >&2 echo "[specify] Warning: Branch name exceeded GitHub's 244-byte limit" + >&2 echo "[specify] Original: $ORIGINAL_BRANCH_NAME ($(branch_byte_count "$ORIGINAL_BRANCH_NAME") bytes)" + >&2 echo "[specify] Truncated to: $BRANCH_NAME ($(branch_byte_count "$BRANCH_NAME") bytes)" +fi + +FEATURE_DIR="$SPECS_DIR/$BRANCH_NAME" +SPEC_FILE="$FEATURE_DIR/spec.md" + +if [ "$DRY_RUN" != true ]; then + if [ -d "$FEATURE_DIR" ] && [ "$ALLOW_EXISTING" != true ]; then + if [ "$USE_TIMESTAMP" = true ]; then + >&2 echo "Error: Feature directory '$FEATURE_DIR' already exists. Rerun to get a new timestamp or use a different --short-name." + else + >&2 echo "Error: Feature directory '$FEATURE_DIR' already exists. Please use a different feature name or specify a different number with --number." + fi + exit 1 + fi + + NEEDS_SPEC=false + SPEC_TEMPLATE_FOUND=false + SPEC_TEMPLATE_CONTENT="" + if [ ! -f "$SPEC_FILE" ]; then + NEEDS_SPEC=true + if SPEC_TEMPLATE_CONTENT=$(resolve_template_content "spec-template" "$REPO_ROOT"; status=$?; printf x; exit "$status"); then + SPEC_TEMPLATE_CONTENT="${SPEC_TEMPLATE_CONTENT%x}" + SPEC_TEMPLATE_FOUND=true + else + resolve_status=$? + if [ "$resolve_status" -ne 1 ]; then + exit "$resolve_status" + fi + fi + fi + + mkdir -p "$FEATURE_DIR" + + if [ "$NEEDS_SPEC" = true ]; then + if [ "$SPEC_TEMPLATE_FOUND" = true ]; then + printf '%s' "$SPEC_TEMPLATE_CONTENT" > "$SPEC_FILE" + else + echo "Warning: Spec template not found; created empty spec file" >&2 + touch "$SPEC_FILE" + fi + fi + + # Persist to .specify/feature.json so downstream commands can find the + # feature, unless the orchestrator opted out via SPECIFY_FEATURE_NO_PERSIST (#4129). + if [[ "${SPECIFY_FEATURE_NO_PERSIST:-}" != "1" && "${SPECIFY_FEATURE_NO_PERSIST:-}" != "true" ]]; then + _persist_feature_json "$REPO_ROOT" "$FEATURE_DIR" + fi + + # Inform the user how to set feature state in their own shell + printf '# To persist: export SPECIFY_FEATURE=%s\n' "$(shell_quote "$BRANCH_NAME")" >&2 + printf '# export SPECIFY_FEATURE_DIRECTORY=%s\n' "$(shell_quote "$FEATURE_DIR")" >&2 +fi + +if $JSON_MODE; then + if command -v jq >/dev/null 2>&1; then + if [ "$DRY_RUN" = true ]; then + jq -cn \ + --arg branch_name "$BRANCH_NAME" \ + --arg spec_file "$SPEC_FILE" \ + --arg feature_num "$FEATURE_NUM" \ + '{BRANCH_NAME:$branch_name,SPEC_FILE:$spec_file,FEATURE_NUM:$feature_num,DRY_RUN:true}' + else + jq -cn \ + --arg branch_name "$BRANCH_NAME" \ + --arg spec_file "$SPEC_FILE" \ + --arg feature_num "$FEATURE_NUM" \ + '{BRANCH_NAME:$branch_name,SPEC_FILE:$spec_file,FEATURE_NUM:$feature_num}' + fi + else + if [ "$DRY_RUN" = true ]; then + printf '{"BRANCH_NAME":"%s","SPEC_FILE":"%s","FEATURE_NUM":"%s","DRY_RUN":true}\n' "$(json_escape "$BRANCH_NAME")" "$(json_escape "$SPEC_FILE")" "$(json_escape "$FEATURE_NUM")" + else + printf '{"BRANCH_NAME":"%s","SPEC_FILE":"%s","FEATURE_NUM":"%s"}\n' "$(json_escape "$BRANCH_NAME")" "$(json_escape "$SPEC_FILE")" "$(json_escape "$FEATURE_NUM")" + fi + fi +else + echo "BRANCH_NAME: $BRANCH_NAME" + echo "SPEC_FILE: $SPEC_FILE" + echo "FEATURE_NUM: $FEATURE_NUM" + if [ "$DRY_RUN" != true ]; then + printf '# To persist in your shell: export SPECIFY_FEATURE=%s\n' "$(shell_quote "$BRANCH_NAME")" + printf '# export SPECIFY_FEATURE_DIRECTORY=%s\n' "$(shell_quote "$FEATURE_DIR")" + fi +fi diff --git a/.specify/scripts/bash/resolve-template.sh b/.specify/scripts/bash/resolve-template.sh new file mode 100755 index 0000000..da05d2d --- /dev/null +++ b/.specify/scripts/bash/resolve-template.sh @@ -0,0 +1,57 @@ +#!/usr/bin/env bash + +set -e + +SCRIPT_DIR="$(CDPATH="" cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)" +source "$SCRIPT_DIR/common.sh" + +JSON_MODE=false +TEMPLATE_NAME="" + +for arg in "$@"; do + case "$arg" in + --json) JSON_MODE=true ;; + --help|-h) + echo "Usage: $0 [--json]" + exit 0 + ;; + -*) + echo "ERROR: Unknown option '$arg'" >&2 + exit 1 + ;; + *) + if [[ -n "$TEMPLATE_NAME" ]]; then + echo "ERROR: Unexpected argument '$arg'" >&2 + exit 1 + fi + TEMPLATE_NAME="$arg" + ;; + esac +done + +if [[ -z "$TEMPLATE_NAME" ]]; then + echo "ERROR: Template name is required" >&2 + exit 1 +fi + +REPO_ROOT=$(get_repo_root) +if TEMPLATE_CONTENT=$(resolve_template_content "$TEMPLATE_NAME" "$REPO_ROOT"; status=$?; printf x; exit "$status"); then + TEMPLATE_CONTENT="${TEMPLATE_CONTENT%x}" +else + echo "ERROR: Could not resolve required $TEMPLATE_NAME from the template override stack for $REPO_ROOT" >&2 + exit 1 +fi + +if $JSON_MODE; then + if has_jq; then + jq -cn \ + --arg template_name "$TEMPLATE_NAME" \ + --arg template_content "$TEMPLATE_CONTENT" \ + '{TEMPLATE_NAME:$template_name,TEMPLATE_CONTENT:$template_content}' + else + printf '{"TEMPLATE_NAME":"%s","TEMPLATE_CONTENT":"%s"}\n' \ + "$(json_escape "$TEMPLATE_NAME")" "$(json_escape "$TEMPLATE_CONTENT")" + fi +else + printf '%s' "$TEMPLATE_CONTENT" +fi diff --git a/.specify/scripts/bash/setup-plan.sh b/.specify/scripts/bash/setup-plan.sh new file mode 100755 index 0000000..aa39418 --- /dev/null +++ b/.specify/scripts/bash/setup-plan.sh @@ -0,0 +1,85 @@ +#!/usr/bin/env bash + +set -e + +# Parse command line arguments +JSON_MODE=false + +for arg in "$@"; do + case "$arg" in + --json) + JSON_MODE=true + ;; + --help|-h) + echo "Usage: $0 [--json]" + echo " --json Output results in JSON format" + echo " --help Show this help message" + exit 0 + ;; + *) + echo "ERROR: Unknown option '$arg'" >&2 + exit 1 + ;; + esac +done + +# Get script directory and load common functions +SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$SCRIPT_DIR/common.sh" + +# Get all paths and variables from common functions +_paths_output=$(get_feature_paths) || { echo "ERROR: Failed to resolve feature paths" >&2; exit 1; } +eval "$_paths_output" +unset _paths_output + +# Ensure the feature directory exists +mkdir -p "$FEATURE_DIR" + +# Copy plan template if plan doesn't already exist +if [[ -f "$IMPL_PLAN" ]]; then + if $JSON_MODE; then + echo "Plan already exists at $IMPL_PLAN, skipping template copy" >&2 + else + echo "Plan already exists at $IMPL_PLAN, skipping template copy" + fi +else + if resolve_template_content "plan-template" "$REPO_ROOT" > "$IMPL_PLAN"; then + if $JSON_MODE; then + echo "Copied plan template to $IMPL_PLAN" >&2 + else + echo "Copied plan template to $IMPL_PLAN" + fi + else + resolve_status=$? + rm -f "$IMPL_PLAN" + if [ "$resolve_status" -ne 1 ]; then + exit "$resolve_status" + fi + if $JSON_MODE; then + echo "Warning: Plan template not found" >&2 + else + echo "Warning: Plan template not found" + fi + touch "$IMPL_PLAN" + fi +fi + +# Output results +if $JSON_MODE; then + if has_jq; then + jq -cn \ + --arg feature_spec "$FEATURE_SPEC" \ + --arg impl_plan "$IMPL_PLAN" \ + --arg feature_dir "$FEATURE_DIR" \ + --arg branch "$CURRENT_BRANCH" \ + '{FEATURE_SPEC:$feature_spec,IMPL_PLAN:$impl_plan,FEATURE_DIR:$feature_dir,BRANCH:$branch}' + else + printf '{"FEATURE_SPEC":"%s","IMPL_PLAN":"%s","FEATURE_DIR":"%s","BRANCH":"%s"}\n' \ + "$(json_escape "$FEATURE_SPEC")" "$(json_escape "$IMPL_PLAN")" "$(json_escape "$FEATURE_DIR")" "$(json_escape "$CURRENT_BRANCH")" + fi +else + echo "FEATURE_SPEC: $FEATURE_SPEC" + echo "IMPL_PLAN: $IMPL_PLAN" + echo "FEATURE_DIR: $FEATURE_DIR" + echo "BRANCH: $CURRENT_BRANCH" +fi diff --git a/.specify/scripts/bash/setup-tasks.sh b/.specify/scripts/bash/setup-tasks.sh new file mode 100755 index 0000000..0383f9f --- /dev/null +++ b/.specify/scripts/bash/setup-tasks.sh @@ -0,0 +1,94 @@ +#!/usr/bin/env bash + +set -e + +# Parse command line arguments +JSON_MODE=false + +for arg in "$@"; do + case "$arg" in + --json) JSON_MODE=true ;; + --help|-h) + echo "Usage: $0 [--json]" + echo " --json Output results in JSON format" + echo " --help Show this help message" + exit 0 + ;; + *) echo "ERROR: Unknown option '$arg'" >&2; exit 1 ;; + esac +done + +# Source common functions +SCRIPT_DIR="$(CDPATH="" cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source "$SCRIPT_DIR/common.sh" + +# Get feature paths +_paths_output=$(get_feature_paths) || { echo "ERROR: Failed to resolve feature paths" >&2; exit 1; } +eval "$_paths_output" +unset _paths_output + +# Validate required files +if [[ ! -f "$IMPL_PLAN" ]]; then + echo "ERROR: plan.md not found in $FEATURE_DIR" >&2 + echo "Run /speckit-plan first to create the implementation plan." >&2 + exit 1 +fi + +if [[ ! -f "$FEATURE_SPEC" ]]; then + echo "ERROR: spec.md not found in $FEATURE_DIR" >&2 + echo "Run /speckit-specify first to create the feature structure." >&2 + exit 1 +fi + +# Build available docs list +docs=() +[[ -f "$RESEARCH" ]] && docs+=("research.md") +[[ -f "$DATA_MODEL" ]] && docs+=("data-model.md") +if [[ -d "$CONTRACTS_DIR" ]] && [[ -n "$(ls -A "$CONTRACTS_DIR" 2>/dev/null)" ]]; then + docs+=("contracts/") +fi +[[ -f "$QUICKSTART" ]] && docs+=("quickstart.md") + +# Resolve tasks template through override stack +TASKS_TEMPLATE=$(resolve_template "tasks-template" "$REPO_ROOT") || true +if TASKS_TEMPLATE_CONTENT=$(resolve_template_content "tasks-template" "$REPO_ROOT"; status=$?; printf x; exit "$status"); then + TASKS_TEMPLATE_CONTENT="${TASKS_TEMPLATE_CONTENT%x}" +else + echo "ERROR: Could not resolve required tasks-template from the template override stack for $REPO_ROOT" >&2 + echo "Template 'tasks-template' was not found in any supported location (overrides, presets, extensions, or shared core). Add an override at .specify/templates/overrides/tasks-template.md, or run 'specify init' / reinstall shared infra to restore the core .specify/templates/tasks-template.md template." >&2 + exit 1 +fi + +# Output results +if $JSON_MODE; then + if has_jq; then + if [[ ${#docs[@]} -eq 0 ]]; then + json_docs="[]" + else + json_docs=$(printf '%s\n' "${docs[@]}" | jq -R . | jq -s .) + fi + jq -cn \ + --arg feature_dir "$FEATURE_DIR" \ + --argjson docs "$json_docs" \ + --arg tasks_template "${TASKS_TEMPLATE:-}" \ + --arg tasks_template_content "$TASKS_TEMPLATE_CONTENT" \ + '{FEATURE_DIR:$feature_dir,AVAILABLE_DOCS:$docs,TASKS_TEMPLATE:$tasks_template,TASKS_TEMPLATE_CONTENT:$tasks_template_content}' + else + if [[ ${#docs[@]} -eq 0 ]]; then + json_docs="[]" + else + json_docs=$(for d in "${docs[@]}"; do printf '"%s",' "$(json_escape "$d")"; done) + json_docs="[${json_docs%,}]" + fi + printf '{"FEATURE_DIR":"%s","AVAILABLE_DOCS":%s,"TASKS_TEMPLATE":"%s","TASKS_TEMPLATE_CONTENT":"%s"}\n' \ + "$(json_escape "$FEATURE_DIR")" "$json_docs" "$(json_escape "${TASKS_TEMPLATE:-}")" "$(json_escape "$TASKS_TEMPLATE_CONTENT")" + fi +else + echo "FEATURE_DIR: $FEATURE_DIR" + echo "TASKS_TEMPLATE: ${TASKS_TEMPLATE:-not found}" + echo "AVAILABLE_DOCS:" + check_file "$RESEARCH" "research.md" + check_file "$DATA_MODEL" "data-model.md" + check_dir "$CONTRACTS_DIR" "contracts/" + check_file "$QUICKSTART" "quickstart.md" +fi diff --git a/.specify/templates/checklist-template.md b/.specify/templates/checklist-template.md new file mode 100644 index 0000000..c4c4ffb --- /dev/null +++ b/.specify/templates/checklist-template.md @@ -0,0 +1,45 @@ +# [CHECKLIST TYPE] Checklist: [FEATURE NAME] + +**Purpose**: [Brief description of what this checklist covers] +**Created**: [DATE] +**Feature**: [Link to spec.md or relevant documentation] + +**Note**: This custom checklist is generated by the `/speckit-checklist` command based on feature context and requirements. +**Review Ownership**: This checklist is a reviewer-owned requirements-quality review artifact. Mark an item `[x]` only when the reviewer determines the requirements-quality criterion is satisfied. +**Marker Semantics**: `[x]` means the criterion has been reviewed and satisfied for requirements quality. It does not mean implementation work is complete. + + + +## [Category 1] + +- [ ] CHK001 First checklist item with clear action +- [ ] CHK002 Second checklist item +- [ ] CHK003 Third checklist item + +## [Category 2] + +- [ ] CHK004 Another category item +- [ ] CHK005 Item with specific criteria +- [ ] CHK006 Final item in this category + +## Notes + +- Mark items `[x]` only after review confirms the requirement-quality criterion is satisfied +- Leave items unchecked when they still require clarification, correction, or reviewer evaluation +- `/speckit-implement` reads checklist checkbox state as a gate and must not modify markers +- `checklists/requirements.md` has a separate built-in lifecycle maintained by `/speckit-specify` and `/speckit-clarify` +- Add comments or findings inline +- Link to relevant resources or documentation +- Items are numbered sequentially for easy reference diff --git a/.specify/templates/constitution-template.md b/.specify/templates/constitution-template.md new file mode 100644 index 0000000..a4670ff --- /dev/null +++ b/.specify/templates/constitution-template.md @@ -0,0 +1,50 @@ +# [PROJECT_NAME] Constitution + + +## Core Principles + +### [PRINCIPLE_1_NAME] + +[PRINCIPLE_1_DESCRIPTION] + + +### [PRINCIPLE_2_NAME] + +[PRINCIPLE_2_DESCRIPTION] + + +### [PRINCIPLE_3_NAME] + +[PRINCIPLE_3_DESCRIPTION] + + +### [PRINCIPLE_4_NAME] + +[PRINCIPLE_4_DESCRIPTION] + + +### [PRINCIPLE_5_NAME] + +[PRINCIPLE_5_DESCRIPTION] + + +## [SECTION_2_NAME] + + +[SECTION_2_CONTENT] + + +## [SECTION_3_NAME] + + +[SECTION_3_CONTENT] + + +## Governance + + +[GOVERNANCE_RULES] + + +**Version**: [CONSTITUTION_VERSION] | **Ratified**: [RATIFICATION_DATE] | **Last Amended**: [LAST_AMENDED_DATE] + diff --git a/.specify/templates/plan-template.md b/.specify/templates/plan-template.md new file mode 100644 index 0000000..be1aa88 --- /dev/null +++ b/.specify/templates/plan-template.md @@ -0,0 +1,113 @@ +# Implementation Plan: [FEATURE] + +**Branch**: `[###-feature-name]` | **Date**: [DATE] | **Spec**: [link] + +**Input**: Feature specification from `/specs/[###-feature-name]/spec.md` + +**Note**: This template is filled in by the `/speckit-plan` command; its definition describes the execution workflow. + +## Summary + +[Extract from feature spec: primary requirement + technical approach from research] + +## Technical Context + + + +**Language/Version**: [e.g., Python 3.11, Swift 5.9, Rust 1.75 or NEEDS CLARIFICATION] + +**Primary Dependencies**: [e.g., FastAPI, UIKit, LLVM or NEEDS CLARIFICATION] + +**Storage**: [if applicable, e.g., PostgreSQL, CoreData, files or N/A] + +**Testing**: [e.g., pytest, XCTest, cargo test or NEEDS CLARIFICATION] + +**Target Platform**: [e.g., Linux server, iOS 15+, WASM or NEEDS CLARIFICATION] + +**Project Type**: [e.g., library/cli/web-service/mobile-app/compiler/desktop-app or NEEDS CLARIFICATION] + +**Performance Goals**: [domain-specific, e.g., 1000 req/s, 10k lines/sec, 60 fps or NEEDS CLARIFICATION] + +**Constraints**: [domain-specific, e.g., <200ms p95, <100MB memory, offline-capable or NEEDS CLARIFICATION] + +**Scale/Scope**: [domain-specific, e.g., 10k users, 1M LOC, 50 screens or NEEDS CLARIFICATION] + +## Constitution Check + +*GATE: Must pass before Phase 0 research. Re-check after Phase 1 design.* + +[Gates determined based on constitution file] + +## Project Structure + +### Documentation (this feature) + +```text +specs/[###-feature]/ +├── plan.md # This file (/speckit-plan command output) +├── research.md # Phase 0 output (/speckit-plan command) +├── data-model.md # Phase 1 output (/speckit-plan command) +├── quickstart.md # Phase 1 output (/speckit-plan command) +├── contracts/ # Phase 1 output (/speckit-plan command) +└── tasks.md # Phase 2 output (/speckit-tasks command - NOT created by /speckit-plan) +``` + +### Source Code (repository root) + + +```text +# [REMOVE IF UNUSED] Option 1: Single project (DEFAULT) +src/ +├── models/ +├── services/ +├── cli/ +└── lib/ + +tests/ +├── contract/ +├── integration/ +└── unit/ + +# [REMOVE IF UNUSED] Option 2: Web application (when "frontend" + "backend" detected) +backend/ +├── src/ +│ ├── models/ +│ ├── services/ +│ └── api/ +└── tests/ + +frontend/ +├── src/ +│ ├── components/ +│ ├── pages/ +│ └── services/ +└── tests/ + +# [REMOVE IF UNUSED] Option 3: Mobile + API (when "iOS/Android" detected) +api/ +└── [same as backend above] + +ios/ or android/ +└── [platform-specific structure: feature modules, UI flows, platform tests] +``` + +**Structure Decision**: [Document the selected structure and reference the real +directories captured above] + +## Complexity Tracking + +> **Fill ONLY if Constitution Check has violations that must be justified** + +| Violation | Why Needed | Simpler Alternative Rejected Because | +|-----------|------------|-------------------------------------| +| [e.g., 4th project] | [current need] | [why 3 projects insufficient] | +| [e.g., Repository pattern] | [specific problem] | [why direct DB access insufficient] | diff --git a/.specify/templates/spec-template.md b/.specify/templates/spec-template.md new file mode 100644 index 0000000..ceb2877 --- /dev/null +++ b/.specify/templates/spec-template.md @@ -0,0 +1,131 @@ +# Feature Specification: [FEATURE NAME] + +**Feature Branch**: `[###-feature-name]` + +**Created**: [DATE] + +**Status**: Draft + +**Input**: User description: "$ARGUMENTS" + +## User Scenarios & Testing *(mandatory)* + + + +### User Story 1 - [Brief Title] (Priority: P1) + +[Describe this user journey in plain language] + +**Why this priority**: [Explain the value and why it has this priority level] + +**Independent Test**: [Describe how this can be tested independently - e.g., "Can be fully tested by [specific action] and delivers [specific value]"] + +**Acceptance Scenarios**: + +1. **Given** [initial state], **When** [action], **Then** [expected outcome] +2. **Given** [initial state], **When** [action], **Then** [expected outcome] + +--- + +### User Story 2 - [Brief Title] (Priority: P2) + +[Describe this user journey in plain language] + +**Why this priority**: [Explain the value and why it has this priority level] + +**Independent Test**: [Describe how this can be tested independently] + +**Acceptance Scenarios**: + +1. **Given** [initial state], **When** [action], **Then** [expected outcome] + +--- + +### User Story 3 - [Brief Title] (Priority: P3) + +[Describe this user journey in plain language] + +**Why this priority**: [Explain the value and why it has this priority level] + +**Independent Test**: [Describe how this can be tested independently] + +**Acceptance Scenarios**: + +1. **Given** [initial state], **When** [action], **Then** [expected outcome] + +--- + +[Add more user stories as needed, each with an assigned priority] + +### Edge Cases + + + +- What happens when [boundary condition]? +- How does system handle [error scenario]? + +## Requirements *(mandatory)* + + + +### Functional Requirements + +- **FR-001**: System MUST [specific capability, e.g., "allow users to create accounts"] +- **FR-002**: System MUST [specific capability, e.g., "validate email addresses"] +- **FR-003**: Users MUST be able to [key interaction, e.g., "reset their password"] +- **FR-004**: System MUST [data requirement, e.g., "persist user preferences"] +- **FR-005**: System MUST [behavior, e.g., "log all security events"] + +*Example of marking unclear requirements:* + +- **FR-006**: System MUST authenticate users via [NEEDS CLARIFICATION: auth method not specified - email/password, SSO, OAuth?] +- **FR-007**: System MUST retain user data for [NEEDS CLARIFICATION: retention period not specified] + +### Key Entities *(include if feature involves data)* + +- **[Entity 1]**: [What it represents, key attributes without implementation] +- **[Entity 2]**: [What it represents, relationships to other entities] + +## Success Criteria *(mandatory)* + + + +### Measurable Outcomes + +- **SC-001**: [Measurable metric, e.g., "Users can complete account creation in under 2 minutes"] +- **SC-002**: [Measurable metric, e.g., "System handles 1000 concurrent users without degradation"] +- **SC-003**: [User satisfaction metric, e.g., "90% of users successfully complete primary task on first attempt"] +- **SC-004**: [Business metric, e.g., "Reduce support tickets related to [X] by 50%"] + +## Assumptions + + + +- [Assumption about target users, e.g., "Users have stable internet connectivity"] +- [Assumption about scope boundaries, e.g., "Mobile support is out of scope for v1"] +- [Assumption about data/environment, e.g., "Existing authentication system will be reused"] +- [Dependency on existing system/service, e.g., "Requires access to the existing user profile API"] diff --git a/.specify/templates/tasks-template.md b/.specify/templates/tasks-template.md new file mode 100644 index 0000000..d46a1f1 --- /dev/null +++ b/.specify/templates/tasks-template.md @@ -0,0 +1,252 @@ +--- + +description: "Task list template for feature implementation" +--- + +# Tasks: [FEATURE NAME] + +**Input**: Design documents from `/specs/[###-feature-name]/` + +**Prerequisites**: plan.md (required), spec.md (required for user stories), research.md, data-model.md, contracts/ + +**Tests**: The examples below include test tasks. Tests are OPTIONAL - only include them if explicitly requested in the feature specification. + +**Organization**: Tasks are grouped by user story to enable independent implementation and testing of each story. + +## Format: `[ID] [P?] [Story] Description` + +- **[P]**: Can run in parallel (different files, no dependencies) +- **[Story]**: Which user story this task belongs to (e.g., US1, US2, US3) +- Include exact file paths in descriptions + +## Path Conventions + +- **Single project**: `src/`, `tests/` at repository root +- **Web app**: `backend/src/`, `frontend/src/` +- **Mobile**: `api/src/`, `ios/src/` or `android/src/` +- Paths shown below assume single project - adjust based on plan.md structure + + + +## Phase 1: Setup (Shared Infrastructure) + +**Purpose**: Project initialization and basic structure + +- [ ] T001 Create project structure per implementation plan +- [ ] T002 Initialize [language] project with [framework] dependencies +- [ ] T003 [P] Configure linting and formatting tools + +--- + +## Phase 2: Foundational (Blocking Prerequisites) + +**Purpose**: Core infrastructure that MUST be complete before ANY user story can be implemented + +**⚠️ CRITICAL**: No user story work can begin until this phase is complete + +Examples of foundational tasks (adjust based on your project): + +- [ ] T004 Setup database schema and migrations framework +- [ ] T005 [P] Implement authentication/authorization framework +- [ ] T006 [P] Setup API routing and middleware structure +- [ ] T007 Create base models/entities that all stories depend on +- [ ] T008 Configure error handling and logging infrastructure +- [ ] T009 Setup environment configuration management + +**Checkpoint**: Foundation ready - user story implementation can now begin in parallel + +--- + +## Phase 3: User Story 1 - [Title] (Priority: P1) 🎯 MVP + +**Goal**: [Brief description of what this story delivers] + +**Independent Test**: [How to verify this story works on its own] + +### Tests for User Story 1 (OPTIONAL - only if tests requested) ⚠️ + +> **NOTE: Write these tests FIRST, ensure they FAIL before implementation** + +- [ ] T010 [P] [US1] Contract test for [endpoint] in tests/contract/test_[name].py +- [ ] T011 [P] [US1] Integration test for [user journey] in tests/integration/test_[name].py + +### Implementation for User Story 1 + +- [ ] T012 [P] [US1] Create [Entity1] model in src/models/[entity1].py +- [ ] T013 [P] [US1] Create [Entity2] model in src/models/[entity2].py +- [ ] T014 [US1] Implement [Service] in src/services/[service].py (depends on T012, T013) +- [ ] T015 [US1] Implement [endpoint/feature] in src/[location]/[file].py +- [ ] T016 [US1] Add validation and error handling +- [ ] T017 [US1] Add logging for user story 1 operations + +**Checkpoint**: At this point, User Story 1 should be fully functional and testable independently + +--- + +## Phase 4: User Story 2 - [Title] (Priority: P2) + +**Goal**: [Brief description of what this story delivers] + +**Independent Test**: [How to verify this story works on its own] + +### Tests for User Story 2 (OPTIONAL - only if tests requested) ⚠️ + +- [ ] T018 [P] [US2] Contract test for [endpoint] in tests/contract/test_[name].py +- [ ] T019 [P] [US2] Integration test for [user journey] in tests/integration/test_[name].py + +### Implementation for User Story 2 + +- [ ] T020 [P] [US2] Create [Entity] model in src/models/[entity].py +- [ ] T021 [US2] Implement [Service] in src/services/[service].py +- [ ] T022 [US2] Implement [endpoint/feature] in src/[location]/[file].py +- [ ] T023 [US2] Integrate with User Story 1 components (if needed) + +**Checkpoint**: At this point, User Stories 1 AND 2 should both work independently + +--- + +## Phase 5: User Story 3 - [Title] (Priority: P3) + +**Goal**: [Brief description of what this story delivers] + +**Independent Test**: [How to verify this story works on its own] + +### Tests for User Story 3 (OPTIONAL - only if tests requested) ⚠️ + +- [ ] T024 [P] [US3] Contract test for [endpoint] in tests/contract/test_[name].py +- [ ] T025 [P] [US3] Integration test for [user journey] in tests/integration/test_[name].py + +### Implementation for User Story 3 + +- [ ] T026 [P] [US3] Create [Entity] model in src/models/[entity].py +- [ ] T027 [US3] Implement [Service] in src/services/[service].py +- [ ] T028 [US3] Implement [endpoint/feature] in src/[location]/[file].py + +**Checkpoint**: All user stories should now be independently functional + +--- + +[Add more user story phases as needed, following the same pattern] + +--- + +## Phase N: Polish & Cross-Cutting Concerns + +**Purpose**: Improvements that affect multiple user stories + +- [ ] TXXX [P] Documentation updates in docs/ +- [ ] TXXX Code cleanup and refactoring +- [ ] TXXX Performance optimization across all stories +- [ ] TXXX [P] Additional unit tests (if requested) in tests/unit/ +- [ ] TXXX Security hardening +- [ ] TXXX Run quickstart.md validation + +--- + +## Dependencies & Execution Order + +### Phase Dependencies + +- **Setup (Phase 1)**: No dependencies - can start immediately +- **Foundational (Phase 2)**: Depends on Setup completion - BLOCKS all user stories +- **User Stories (Phase 3+)**: All depend on Foundational phase completion + - User stories can then proceed in parallel (if staffed) + - Or sequentially in priority order (P1 → P2 → P3) +- **Polish (Final Phase)**: Depends on all desired user stories being complete + +### User Story Dependencies + +- **User Story 1 (P1)**: Can start after Foundational (Phase 2) - No dependencies on other stories +- **User Story 2 (P2)**: Can start after Foundational (Phase 2) - May integrate with US1 but should be independently testable +- **User Story 3 (P3)**: Can start after Foundational (Phase 2) - May integrate with US1/US2 but should be independently testable + +### Within Each User Story + +- Tests (if included) MUST be written and FAIL before implementation +- Models before services +- Services before endpoints +- Core implementation before integration +- Story complete before moving to next priority + +### Parallel Opportunities + +- All Setup tasks marked [P] can run in parallel +- All Foundational tasks marked [P] can run in parallel (within Phase 2) +- Once Foundational phase completes, all user stories can start in parallel (if team capacity allows) +- All tests for a user story marked [P] can run in parallel +- Models within a story marked [P] can run in parallel +- Different user stories can be worked on in parallel by different team members + +--- + +## Parallel Example: User Story 1 + +```bash +# Launch all tests for User Story 1 together (if tests requested): +Task: "Contract test for [endpoint] in tests/contract/test_[name].py" +Task: "Integration test for [user journey] in tests/integration/test_[name].py" + +# Launch all models for User Story 1 together: +Task: "Create [Entity1] model in src/models/[entity1].py" +Task: "Create [Entity2] model in src/models/[entity2].py" +``` + +--- + +## Implementation Strategy + +### MVP First (User Story 1 Only) + +1. Complete Phase 1: Setup +2. Complete Phase 2: Foundational (CRITICAL - blocks all stories) +3. Complete Phase 3: User Story 1 +4. **STOP and VALIDATE**: Test User Story 1 independently +5. Deploy/demo if ready + +### Incremental Delivery + +1. Complete Setup + Foundational → Foundation ready +2. Add User Story 1 → Test independently → Deploy/Demo (MVP!) +3. Add User Story 2 → Test independently → Deploy/Demo +4. Add User Story 3 → Test independently → Deploy/Demo +5. Each story adds value without breaking previous stories + +### Parallel Team Strategy + +With multiple developers: + +1. Team completes Setup + Foundational together +2. Once Foundational is done: + - Developer A: User Story 1 + - Developer B: User Story 2 + - Developer C: User Story 3 +3. Stories complete and integrate independently + +--- + +## Notes + +- [P] tasks = different files, no dependencies +- [Story] label maps task to specific user story for traceability +- Each user story should be independently completable and testable +- Verify tests fail before implementing +- Commit after each task or logical group +- Stop at any checkpoint to validate story independently +- Avoid: vague tasks, same file conflicts, cross-story dependencies that break independence diff --git a/.specify/workflows/speckit/workflow.yml b/.specify/workflows/speckit/workflow.yml new file mode 100644 index 0000000..571318a --- /dev/null +++ b/.specify/workflows/speckit/workflow.yml @@ -0,0 +1,74 @@ +schema_version: "1.0" +workflow: + id: "speckit" + name: "Full SDD Cycle" + version: "1.0.1" + author: "GitHub" + description: "Runs specify → plan → tasks → implement with review gates" + +requires: + # 0.8.5 is the first release with engine-side resolution of the + # ``integration: "auto"`` default. Older versions would treat "auto" + # as a literal integration key and fail at dispatch. + speckit_version: ">=0.8.5" + integrations: + # The four commands below (specify, plan, tasks, implement) are core + # spec-kit commands provided by every integration. The list here is an + # advisory, non-exhaustive compatibility hint following the documented + # ``any: [...]`` schema -- it is NOT a closed set. The workflow runs + # against any integration the project was initialized with, including + # ones not listed below, as long as that integration provides the four + # core commands referenced in ``steps``. + any: + - "alquimia" + - "claude" + - "copilot" + - "gemini" + - "opencode" + +inputs: + spec: + type: string + required: true + prompt: "Describe what you want to build" + integration: + type: string + default: "auto" + prompt: "Integration to use (e.g. claude, copilot, gemini; 'auto' uses the project's initialized integration)" + +steps: + - id: specify + command: speckit.specify + integration: "{{ inputs.integration }}" + input: + args: "{{ inputs.spec }}" + + - id: review-spec + type: gate + message: "Review the generated spec before planning." + options: [approve, reject] + on_reject: abort + + - id: plan + command: speckit.plan + integration: "{{ inputs.integration }}" + input: + args: "{{ inputs.spec }}" + + - id: review-plan + type: gate + message: "Review the plan before generating tasks." + options: [approve, reject] + on_reject: abort + + - id: tasks + command: speckit.tasks + integration: "{{ inputs.integration }}" + input: + args: "{{ inputs.spec }}" + + - id: implement + command: speckit.implement + integration: "{{ inputs.integration }}" + input: + args: "{{ inputs.spec }}" diff --git a/.specify/workflows/workflow-registry.json b/.specify/workflows/workflow-registry.json new file mode 100644 index 0000000..7af7964 --- /dev/null +++ b/.specify/workflows/workflow-registry.json @@ -0,0 +1,13 @@ +{ + "schema_version": "1.0", + "workflows": { + "speckit": { + "name": "Full SDD Cycle", + "version": "1.0.1", + "description": "Runs specify \u2192 plan \u2192 tasks \u2192 implement with review gates", + "source": "bundled", + "installed_at": "2026-10-03T14:19:51.676125+00:00", + "updated_at": "2026-10-03T14:19:51.676131+00:00" + } + } +} \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 3b2b9fa..f9a624d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,35 +1,37 @@ # Changelog -All notable changes to this project will be documented in this file. - -The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), -and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +All notable changes to this project are recorded here. The format follows +[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and the project uses +[Semantic Versioning](https://semver.org/). Content updates name the FitSM edition and the +document versions they bring in. ## [Unreleased] ### Added -- Interactive FitSM v3 process map (`index.html`) showing the 14 processes and their key interfaces. -- FitSM content in `fitsm-data.js`: requirements (FitSM-1), activities and procedures, inputs / outputs and interfaces (FitSM-2), roles and tasks (FitSM-3), and databases and records (FitSM-0). -- `scripts/check.js` consistency checks, run in CI. -- GitHub Pages deployment from `main` after the tests pass. -- GitHub releases with the site attached as a zip, for `v*` tags. - -### Changed - -- Contact method for conduct and security reports: GitHub issues. -- CI actions pinned to commit SHAs; tests also run on pull requests. - -### Removed - -- Docker image build and publication (`Dockerfile`); the site is served by GitHub Pages. -- Template placeholder page and template screenshot. -- ORT licence scan: the project has no package-managed dependencies. -- SonarCloud badge: SonarCloud is not used. -- Trivy scan: no Docker images are built. +- Initial process map of FitSM 3.0: FitSM-0 Overview and vocabulary v3.0.1, FitSM-1 + Requirements v3.0.1, FitSM-2 Process activities and implementation v3.0.2, FitSM-3 Role + model v3.0.1 (all ITEMO e.V., CC BY 4.0). 14 processes, 17 general and 65 process + requirements, 58 roles, 53 activities, 9 records, 31 interfaces with 64 flows. +- Subway-style map with five study-aid lines, a detail frame for every item, direct links + (`#ISRM`, `#ISRM-PM`, `#GR`), keyboard and screen-reader access. +- `scripts/check.js` consistency and contrast checks, unit tests, REUSE compliance, GitHub + Pages deployment and release workflows. +- Map layout on a finer grid: no two connections share a segment, a connection yields at a + crossing (a short gap with ticks parallel to the crossing line, which stays unbroken), + transfers are thin solid grey, stations show only their code (full name as tooltip and in + the frame), and line names appear in the legend only. +- Selection by fading: the selected station or connection and what it connects to keep full + strength with a soft halo while everything else fades; clicking the selection again + deselects it; a selected connection shows moving markers in the direction of each flow + FitSM-2 lists (hidden under `prefers-reduced-motion`). +- After a selection, focus moves to the frame's heading and only that heading is announced + to screen readers; the legend's transfer sample takes its colour from the content. +- Checks for alias format, `map.grid` fields and role `tasks`; `scripts/check.js` works + from any working directory; unit tests for the map geometry and selection rules. diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md index 2d4c80e..4c26de9 100644 --- a/CODE_OF_CONDUCT.md +++ b/CODE_OF_CONDUCT.md @@ -1,141 +1,91 @@ + # Contributor Covenant Code of Conduct ## Our Pledge -We as members, contributors, and leaders pledge to make participation in our -community a harassment-free experience for everyone, regardless of age, body -size, visible or invisible disability, ethnicity, sex characteristics, gender -identity and expression, level of experience, education, socio-economic status, -nationality, personal appearance, race, caste, color, religion, or sexual -identity and orientation. +We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation. -We pledge to act and interact in ways that contribute to an open, welcoming, -diverse, inclusive, and healthy community. +We pledge to act and interact in ways that contribute to an open, welcoming, diverse, inclusive, and healthy community. ## Our Standards -Examples of behavior that contributes to a positive environment for our -community include: +Examples of behavior that contributes to a positive environment for our community include: -- Demonstrating empathy and kindness toward other people -- Being respectful of differing opinions, viewpoints, and experiences -- Giving and gracefully accepting constructive feedback -- Accepting responsibility and apologizing to those affected by our mistakes, - and learning from the experience -- Focusing on what is best not just for us as individuals, but for the overall - community +* Demonstrating empathy and kindness toward other people +* Being respectful of differing opinions, viewpoints, and experiences +* Giving and gracefully accepting constructive feedback +* Accepting responsibility and apologizing to those affected by our mistakes, and learning from the experience +* Focusing on what is best not just for us as individuals, but for the overall community Examples of unacceptable behavior include: -- The use of sexualized language or imagery, and sexual attention or advances of - any kind -- Trolling, insulting or derogatory comments, and personal or political attacks -- Public or private harassment -- Publishing others' private information, such as a physical or email address, - without their explicit permission -- Other conduct which could reasonably be considered inappropriate in a - professional setting +* The use of sexualized language or imagery, and sexual attention or advances of any kind +* Trolling, insulting or derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or email address, without their explicit permission +* Other conduct which could reasonably be considered inappropriate in a professional setting ## Enforcement Responsibilities -Community leaders are responsible for clarifying and enforcing our standards of -acceptable behavior and will take appropriate and fair corrective action in -response to any behavior that they deem inappropriate, threatening, offensive, -or harmful. +Community leaders are responsible for clarifying and enforcing our standards of acceptable behavior and will take appropriate and fair corrective action in response to any behavior that they deem inappropriate, threatening, offensive, or harmful. -Community leaders have the right and responsibility to remove, edit, or reject -comments, commits, code, wiki edits, issues, and other contributions that are -not aligned to this Code of Conduct, and will communicate reasons for moderation -decisions when appropriate. +Community leaders have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, and will communicate reasons for moderation decisions when appropriate. ## Scope -This Code of Conduct applies within all community spaces, and also applies when -an individual is officially representing the community in public spaces. -Examples of representing our community include using an official email address, -posting via an official social media account, or acting as an appointed -representative at an online or offline event. +This Code of Conduct applies within all community spaces, and also applies when an individual is officially representing the community in public spaces. Examples of representing our community include using an official e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. ## Enforcement -Instances of abusive, harassing, or otherwise unacceptable behavior may be -reported to the community leaders responsible for enforcement at -opening a [GitHub issue](https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues). -If the matter is sensitive, open an issue asking for a private contact and -leave out the details; a maintainer will reach out. -All complaints will be reviewed and investigated promptly and fairly. +Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues (the repository's issue tracker, read by the maintainers). All complaints will be reviewed and investigated promptly and fairly. -All community leaders are obligated to respect the privacy and security of the -reporter of any incident. +All community leaders are obligated to respect the privacy and security of the reporter of any incident. ## Enforcement Guidelines -Community leaders will follow these Community Impact Guidelines in determining -the consequences for any action they deem in violation of this Code of Conduct: +Community leaders will follow these Community Impact Guidelines in determining the consequences for any action they deem in violation of this Code of Conduct: ### 1. Correction -**Community Impact**: Use of inappropriate language or other behavior deemed -unprofessional or unwelcome in the community. +**Community Impact**: Use of inappropriate language or other behavior deemed unprofessional or unwelcome in the community. -**Consequence**: A private, written warning from community leaders, providing -clarity around the nature of the violation and an explanation of why the -behavior was inappropriate. A public apology may be requested. +**Consequence**: A private, written warning from community leaders, providing clarity around the nature of the violation and an explanation of why the behavior was inappropriate. A public apology may be requested. ### 2. Warning -**Community Impact**: A violation through a single incident or series of -actions. +**Community Impact**: A violation through a single incident or series of actions. -**Consequence**: A warning with consequences for continued behavior. No -interaction with the people involved, including unsolicited interaction with -those enforcing the Code of Conduct, for a specified period of time. This -includes avoiding interactions in community spaces as well as external channels -like social media. Violating these terms may lead to a temporary or permanent -ban. +**Consequence**: A warning with consequences for continued behavior. No interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, for a specified period of time. This includes avoiding interactions in community spaces as well as external channels like social media. Violating these terms may lead to a temporary or permanent ban. ### 3. Temporary Ban -**Community Impact**: A serious violation of community standards, including -sustained inappropriate behavior. +**Community Impact**: A serious violation of community standards, including sustained inappropriate behavior. -**Consequence**: A temporary ban from any sort of interaction or public -communication with the community for a specified period of time. No public or -private interaction with the people involved, including unsolicited interaction -with those enforcing the Code of Conduct, is allowed during this period. -Violating these terms may lead to a permanent ban. +**Consequence**: A temporary ban from any sort of interaction or public communication with the community for a specified period of time. No public or private interaction with the people involved, including unsolicited interaction with those enforcing the Code of Conduct, is allowed during this period. Violating these terms may lead to a permanent ban. ### 4. Permanent Ban -**Community Impact**: Demonstrating a pattern of violation of community -standards, including sustained inappropriate behavior, harassment of an -individual, or aggression toward or disparagement of classes of individuals. +**Community Impact**: Demonstrating a pattern of violation of community standards, including sustained inappropriate behavior, harassment of an individual, or aggression toward or disparagement of classes of individuals. -**Consequence**: A permanent ban from any sort of public interaction within the -community. +**Consequence**: A permanent ban from any sort of public interaction within the community. ## Attribution -This Code of Conduct is adapted from the [Contributor Covenant][homepage], -version 2.1, available at -[https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 2.1, available at [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1]. -Community Impact Guidelines were inspired by -[Mozilla's code of conduct enforcement ladder][Mozilla CoC]. +Community Impact Guidelines were inspired by [Mozilla's code of conduct enforcement ladder][Mozilla CoC]. -For answers to common questions about this code of conduct, see the FAQ at -[https://www.contributor-covenant.org/faq][FAQ]. Translations are available at -[https://www.contributor-covenant.org/translations][translations]. +For answers to common questions about this code of conduct, see the FAQ at [https://www.contributor-covenant.org/faq][FAQ]. Translations are available at [https://www.contributor-covenant.org/translations][translations]. [homepage]: https://www.contributor-covenant.org [v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html [Mozilla CoC]: https://github.com/mozilla/diversity [FAQ]: https://www.contributor-covenant.org/faq [translations]: https://www.contributor-covenant.org/translations + diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 3629001..6987427 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,187 +1,56 @@ - - # Contributing to FitSM Process Map -First off, thanks for taking the time to contribute! ❤️ - -All types of contributions are encouraged and valued. See the [Table of Contents](#table-of-contents) for different ways to help and details about how this project handles them. Please make sure to read the relevant section before making your contribution. It will make it a lot easier for us maintainers and smooth out the experience for all involved. The community looks forward to your contributions. 🎉 - -> And if you like the project, but just don't have time to contribute, that's fine. There are other easy ways to support the project and show your appreciation, which we would also be very happy about: -> -> - Star the project -> - Tweet about it -> - Refer this project in your project's readme -> - Mention the project at local meetups and tell your friends/colleagues - - - -## Table of Contents - -- [Code of Conduct](#code-of-conduct) -- [I Have a Question](#i-have-a-question) -- [I Want To Contribute](#i-want-to-contribute) - - [Reporting Bugs](#reporting-bugs) - - [Suggesting Enhancements](#suggesting-enhancements) - - [Your First Code Contribution](#your-first-code-contribution) - - [Improving The Documentation](#improving-the-documentation) -- [Styleguides](#styleguides) - - [Commit Messages](#commit-messages) +Thank you for taking the time to contribute. This project is a learning aid for FitSM, so the +most valuable contributions are corrections that bring the map closer to what FitSM says. ## Code of Conduct This project and everyone participating in it is governed by the -[FitSM Process Map Code of Conduct](CODE_OF_CONDUCT.md). -By participating, you are expected to uphold this code. Please report unacceptable behavior -by opening a [GitHub issue](https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues/new). If the matter is sensitive, open an issue asking for a private contact and leave out the details. - -## I Have a Question - -> If you want to ask a question, we assume that you have read the available [Documentation](README.md). - -Before you ask a question, it is best to search for existing [Issues](https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues) that might help you. In case you have found a suitable issue and still need clarification, you can write your question in this issue. It is also advisable to search the internet for answers first. - -If you then still feel the need to ask a question and need clarification, we recommend the following: - -- Open an [Issue](https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues/new). -- Provide as much context as you can about what you're running into. -- Provide project and platform versions (nodejs, npm, etc), depending on what seems relevant. - -We will then take care of the issue as soon as possible. - - - -## I Want To Contribute - -> ### Legal Notice -> -> When contributing to this project, you must agree that you have authored 100% of the content, that you have the necessary rights to the content and that the content you contribute may be provided under the project license. - -### Reporting Bugs - - - -#### Before Submitting a Bug Report - -A good bug report shouldn't leave others needing to chase you up for more information. Therefore, we ask you to investigate carefully, collect information and describe the issue in detail in your report. Please complete the following steps in advance to help us fix any potential bug as fast as possible. - -- Make sure that you are using the latest version. -- Determine if your bug is really a bug and not an error on your side e.g. using incompatible environment components/versions (Make sure that you have read the [documentation](README.md). If you are looking for support, you might want to check [this section](#i-have-a-question)). -- To see if other users have experienced (and potentially already solved) the same issue you are having, check if there is not already a bug report existing for your bug or error in the [bug tracker](https://github.com/GenomicDataInfrastructure/fitsm-process-map/labels/bug) -- Also make sure to search the internet (including Stack Overflow) to see if users outside of the GitHub community have discussed the issue. -- Collect information about the bug: - - Stack trace (Traceback) - - OS, Platform and Version (Windows, Linux, macOS, x86, ARM) - - Version of the interpreter, compiler, SDK, runtime environment, package manager, depending on what seems relevant. - - Possibly your input and the output - - Can you reliably reproduce the issue? And can you also reproduce it with older versions? - - +[Code of Conduct](CODE_OF_CONDUCT.md). By participating, you are expected to uphold it. -#### How Do I Submit a Good Bug Report? +## Reporting an error in the content -> You must never report security related issues, vulnerabilities or bugs including sensitive information to the issue tracker, or elsewhere in public. Instead, open a [GitHub issue](https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues/new) that only asks the maintainers for a private contact, without describing the vulnerability; a maintainer will follow up privately. +Open an issue and cite the FitSM document, version and section that shows the error, for +example "FitSM-2 v3.0.2, §4.9.3, second bullet". Every item on the page shows its source, so +you can copy it from there. Say what the page shows and what FitSM says. - +## Suggesting a change -We use GitHub issues to track bugs and errors. If you run into an issue with the project: +Open an issue first for anything beyond a small correction. The project deliberately shows +only what FitSM defines, plus a few labelled study aids; a new feature needs to help people +learn FitSM to be accepted (see the project constitution in `.specify/memory/constitution.md`). -- Open an [Issue](https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues/new). (Since we can't be sure at this point whether it is a bug or not, we ask you not to talk about a bug yet and not to label the issue.) -- Explain the behavior you would expect and the actual behavior. -- Please provide as much context as possible and describe the _reproduction steps_ that someone else can follow to recreate the issue on their own. This usually includes your code. For good bug reports you should isolate the problem and create a reduced test case. -- Provide the information you collected in the previous section. +## Making a change -Once it's filed: - -- The project team will label the issue accordingly. -- A team member will try to reproduce the issue with your provided steps. If there are no reproduction steps or no obvious way to reproduce the issue, the team will ask you for those steps and mark the issue as `needs-repro`. Bugs with the `needs-repro` tag will not be addressed until they are reproduced. -- If the team is able to reproduce the issue, it will be marked `needs-fix`, as well as possibly other tags (such as `critical`), and the issue will be left to be [implemented by someone](#your-first-code-contribution). - - - -### Suggesting Enhancements - -This section guides you through submitting an enhancement suggestion for FitSM Process Map, **including completely new features and minor improvements to existing functionality**. Following these guidelines will help maintainers and the community to understand your suggestion and find related suggestions. - - - -#### Before Submitting an Enhancement - -- Make sure that you are using the latest version. -- Read the [documentation](README.md) carefully and find out if the functionality is already covered, maybe by an individual configuration. -- Perform a [search](https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues) to see if the enhancement has already been suggested. If it has, add a comment to the existing issue instead of opening a new one. -- Find out whether your idea fits with the scope and aims of the project. It's up to you to make a strong case to convince the project's developers of the merits of this feature. Keep in mind that we want features that will be useful to the majority of our users and not just a small subset. If you're just targeting a minority of users, consider writing an add-on/plugin library. - - - -#### How Do I Submit a Good Enhancement Suggestion? - -Enhancement suggestions are tracked as [GitHub issues](https://github.com/GenomicDataInfrastructure/fitsm-process-map/issues). - -- Use a **clear and descriptive title** for the issue to identify the suggestion. -- Provide a **step-by-step description of the suggested enhancement** in as many details as possible. -- **Describe the current behavior** and **explain which behavior you expected to see instead** and why. At this point you can also tell which alternatives do not work for you. -- You may want to **include screenshots and animated GIFs** which help you demonstrate the steps or point out the part which the suggestion is related to. You can use [this tool](https://www.cockos.com/licecap/) to record GIFs on macOS and Windows, and [this tool](https://github.com/colinkeenan/silentcast) or [this tool](https://github.com/GNOME/byzanz) on Linux. -- **Explain why this enhancement would be useful** to most FitSM Process Map users. You may also want to point out the other projects that solved it better and which could serve as inspiration. - - - -### Your First Code Contribution - -The project is a static page with no build step or dependencies. You need Git, a browser, Python 3 (to serve the folder) and Node.js (to run the checks). - -1. Fork and clone the repository, then create a branch for your change. -2. Serve the folder and open http://localhost:8000: - - ```bash - python3 -m http.server 8000 - ``` - -3. Make your change: - - **FitSM content** (requirements, roles, databases, activities, interfaces) lives in `fitsm-data.js`. Quote the FitSM documents as published at [fitsm.eu](https://www.fitsm.eu/downloads/) and name the source; mark anything that is interpretation rather than quotation. - - **Layout, styles and behaviour** live in `index.html`. Diagram positions and arrow routes are the `pos` and `route` fields in `fitsm-data.js`. -4. Run the same checks as CI before opening a pull request: +1. Fork and branch from `main`. +2. For content, edit only the files under `content//`. Quote FitSM text unchanged. + The README's "Updating the content" section explains the files. +3. Run the checks before you push: ```bash node scripts/check.js - reuse lint + node --test ``` - `reuse lint` needs the [REUSE tool](https://reuse.software/) (`pipx install reuse`). Every new file needs an SPDX header: Apache-2.0 for code, CC-BY-4.0 for documentation and FitSM content. -5. Add a line to the `[Unreleased]` section of `CHANGELOG.md` and open a pull request using the template. - -### Improving The Documentation - -Documentation lives in `README.md`, this file and `CHANGELOG.md`. Corrections to FitSM content are welcome too: if the map disagrees with the FitSM documents, open an issue or a pull request that cites the document, version and section. - -## Styleguides - -### Commit Messages + Both must pass. If you add a new kind of content, add a check for it too. +4. Every new file needs an SPDX header naming the copyright holder and the licence + (CC-BY-4.0), like the one at the top of this file; JSON files are covered by `REUSE.toml`. + Check with `reuse lint` if you have it installed; CI runs it anyway. +5. Open a pull request. For content changes, cite the FitSM document and section for each + change in the description. The `Run Tests` workflow must be green before a merge. -- Write a short summary in the imperative mood (e.g. "Add CAB notes to CHM roles"), at most about 72 characters. -- Add a body when the reason for the change is not obvious, and reference related issues (e.g. `Fixes #12`). -- Keep each commit to one logical change. +## Commit messages - +- Subject line in the imperative, at most 72 characters: "Add CAPM interfaces", not "Added". +- Body (optional) explains why, and for content names the FitSM source. -## Attribution +## Licence -This guide is based on the **contributing-gen**. [Make your own](https://github.com/bttger/contributing-gen)! +By contributing you agree that your contribution is licensed under +[CC BY 4.0](LICENSES/CC-BY-4.0.txt), like the rest of the project. diff --git a/LICENSES/Apache-2.0.txt b/LICENSES/Apache-2.0.txt deleted file mode 100644 index 137069b..0000000 --- a/LICENSES/Apache-2.0.txt +++ /dev/null @@ -1,73 +0,0 @@ -Apache License -Version 2.0, January 2004 -http://www.apache.org/licenses/ - -TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION - -1. Definitions. - -"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. - -"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. - -"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. - -"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. - -"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. - -"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. - -"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). - -"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. - -"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." - -"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. - -2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. - -3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. - -4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: - - (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and - - (b) You must cause any modified files to carry prominent notices stating that You changed the files; and - - (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and - - (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. - - You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. - -5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. - -6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. - -7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. - -8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. - -9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. - -END OF TERMS AND CONDITIONS - -APPENDIX: How to apply the Apache License to your work. - -To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. - -Copyright [yyyy] [name of copyright owner] - -Licensed under the Apache License, Version 2.0 (the "License"); -you may not use this file except in compliance with the License. -You may obtain a copy of the License at - -http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. diff --git a/LICENSES/CC-BY-4.0.txt b/LICENSES/CC-BY-4.0.txt index 13ca539..da6ab6c 100644 --- a/LICENSES/CC-BY-4.0.txt +++ b/LICENSES/CC-BY-4.0.txt @@ -1,156 +1,396 @@ -Creative Commons Attribution 4.0 International +Attribution 4.0 International - Creative Commons Corporation (“Creative Commons”) is not a law firm and does not provide legal services or legal advice. Distribution of Creative Commons public licenses does not create a lawyer-client or other relationship. Creative Commons makes its licenses and related information available on an “as-is” basis. Creative Commons gives no warranties regarding its licenses, any material licensed under their terms and conditions, or any related information. Creative Commons disclaims all liability for damages resulting from their use to the fullest extent possible. +======================================================================= -Using Creative Commons Public Licenses - -Creative Commons public licenses provide a standard set of terms and conditions that creators and other rights holders may use to share original works of authorship and other material subject to copyright and certain other rights specified in the public license below. The following considerations are for informational purposes only, are not exhaustive, and do not form part of our licenses. +Creative Commons Corporation ("Creative Commons") is not a law firm and +does not provide legal services or legal advice. Distribution of +Creative Commons public licenses does not create a lawyer-client or +other relationship. Creative Commons makes its licenses and related +information available on an "as-is" basis. Creative Commons gives no +warranties regarding its licenses, any material licensed under their +terms and conditions, or any related information. Creative Commons +disclaims all liability for damages resulting from their use to the +fullest extent possible. -Considerations for licensors: Our public licenses are intended for use by those authorized to give the public permission to use material in ways otherwise restricted by copyright and certain other rights. Our licenses are irrevocable. Licensors should read and understand the terms and conditions of the license they choose before applying it. Licensors should also secure all rights necessary before applying our licenses so that the public can reuse the material as expected. Licensors should clearly mark any material not subject to the license. This includes other CC-licensed material, or material used under an exception or limitation to copyright. More considerations for licensors. +Using Creative Commons Public Licenses -Considerations for the public: By using one of our public licenses, a licensor grants the public permission to use the licensed material under specified terms and conditions. If the licensor’s permission is not necessary for any reason–for example, because of any applicable exception or limitation to copyright–then that use is not regulated by the license. Our licenses grant only permissions under copyright and certain other rights that a licensor has authority to grant. Use of the licensed material may still be restricted for other reasons, including because others have copyright or other rights in the material. A licensor may make special requests, such as asking that all changes be marked or described. Although not required by our licenses, you are encouraged to respect those requests where reasonable. More considerations for the public. +Creative Commons public licenses provide a standard set of terms and +conditions that creators and other rights holders may use to share +original works of authorship and other material subject to copyright +and certain other rights specified in the public license below. The +following considerations are for informational purposes only, are not +exhaustive, and do not form part of our licenses. + + Considerations for licensors: Our public licenses are + intended for use by those authorized to give the public + permission to use material in ways otherwise restricted by + copyright and certain other rights. Our licenses are + irrevocable. Licensors should read and understand the terms + and conditions of the license they choose before applying it. + Licensors should also secure all rights necessary before + applying our licenses so that the public can reuse the + material as expected. Licensors should clearly mark any + material not subject to the license. This includes other CC- + licensed material, or material used under an exception or + limitation to copyright. More considerations for licensors: + wiki.creativecommons.org/Considerations_for_licensors + + Considerations for the public: By using one of our public + licenses, a licensor grants the public permission to use the + licensed material under specified terms and conditions. If + the licensor's permission is not necessary for any reason--for + example, because of any applicable exception or limitation to + copyright--then that use is not regulated by the license. Our + licenses grant only permissions under copyright and certain + other rights that a licensor has authority to grant. Use of + the licensed material may still be restricted for other + reasons, including because others have copyright or other + rights in the material. A licensor may make special requests, + such as asking that all changes be marked or described. + Although not required by our licenses, you are encouraged to + respect those requests where reasonable. More considerations + for the public: + wiki.creativecommons.org/Considerations_for_licensees + +======================================================================= Creative Commons Attribution 4.0 International Public License -By exercising the Licensed Rights (defined below), You accept and agree to be bound by the terms and conditions of this Creative Commons Attribution 4.0 International Public License ("Public License"). To the extent this Public License may be interpreted as a contract, You are granted the Licensed Rights in consideration of Your acceptance of these terms and conditions, and the Licensor grants You such rights in consideration of benefits the Licensor receives from making the Licensed Material available under these terms and conditions. - -Section 1 – Definitions. - - a. Adapted Material means material subject to Copyright and Similar Rights that is derived from or based upon the Licensed Material and in which the Licensed Material is translated, altered, arranged, transformed, or otherwise modified in a manner requiring permission under the Copyright and Similar Rights held by the Licensor. For purposes of this Public License, where the Licensed Material is a musical work, performance, or sound recording, Adapted Material is always produced where the Licensed Material is synched in timed relation with a moving image. - - b. Adapter's License means the license You apply to Your Copyright and Similar Rights in Your contributions to Adapted Material in accordance with the terms and conditions of this Public License. - - c. Copyright and Similar Rights means copyright and/or similar rights closely related to copyright including, without limitation, performance, broadcast, sound recording, and Sui Generis Database Rights, without regard to how the rights are labeled or categorized. For purposes of this Public License, the rights specified in Section 2(b)(1)-(2) are not Copyright and Similar Rights. - - d. Effective Technological Measures means those measures that, in the absence of proper authority, may not be circumvented under laws fulfilling obligations under Article 11 of the WIPO Copyright Treaty adopted on December 20, 1996, and/or similar international agreements. - - e. Exceptions and Limitations means fair use, fair dealing, and/or any other exception or limitation to Copyright and Similar Rights that applies to Your use of the Licensed Material. - - f. Licensed Material means the artistic or literary work, database, or other material to which the Licensor applied this Public License. +By exercising the Licensed Rights (defined below), You accept and agree +to be bound by the terms and conditions of this Creative Commons +Attribution 4.0 International Public License ("Public License"). To the +extent this Public License may be interpreted as a contract, You are +granted the Licensed Rights in consideration of Your acceptance of +these terms and conditions, and the Licensor grants You such rights in +consideration of benefits the Licensor receives from making the +Licensed Material available under these terms and conditions. + + +Section 1 -- Definitions. + + a. Adapted Material means material subject to Copyright and Similar + Rights that is derived from or based upon the Licensed Material + and in which the Licensed Material is translated, altered, + arranged, transformed, or otherwise modified in a manner requiring + permission under the Copyright and Similar Rights held by the + Licensor. For purposes of this Public License, where the Licensed + Material is a musical work, performance, or sound recording, + Adapted Material is always produced where the Licensed Material is + synched in timed relation with a moving image. + + b. Adapter's License means the license You apply to Your Copyright + and Similar Rights in Your contributions to Adapted Material in + accordance with the terms and conditions of this Public License. + + c. Copyright and Similar Rights means copyright and/or similar rights + closely related to copyright including, without limitation, + performance, broadcast, sound recording, and Sui Generis Database + Rights, without regard to how the rights are labeled or + categorized. For purposes of this Public License, the rights + specified in Section 2(b)(1)-(2) are not Copyright and Similar + Rights. + + d. Effective Technological Measures means those measures that, in the + absence of proper authority, may not be circumvented under laws + fulfilling obligations under Article 11 of the WIPO Copyright + Treaty adopted on December 20, 1996, and/or similar international + agreements. + + e. Exceptions and Limitations means fair use, fair dealing, and/or + any other exception or limitation to Copyright and Similar Rights + that applies to Your use of the Licensed Material. + + f. Licensed Material means the artistic or literary work, database, + or other material to which the Licensor applied this Public + License. + + g. Licensed Rights means the rights granted to You subject to the + terms and conditions of this Public License, which are limited to + all Copyright and Similar Rights that apply to Your use of the + Licensed Material and that the Licensor has authority to license. + + h. Licensor means the individual(s) or entity(ies) granting rights + under this Public License. + + i. Share means to provide material to the public by any means or + process that requires permission under the Licensed Rights, such + as reproduction, public display, public performance, distribution, + dissemination, communication, or importation, and to make material + available to the public including in ways that members of the + public may access the material from a place and at a time + individually chosen by them. + + j. Sui Generis Database Rights means rights other than copyright + resulting from Directive 96/9/EC of the European Parliament and of + the Council of 11 March 1996 on the legal protection of databases, + as amended and/or succeeded, as well as other essentially + equivalent rights anywhere in the world. + + k. You means the individual or entity exercising the Licensed Rights + under this Public License. Your has a corresponding meaning. + + +Section 2 -- Scope. + + a. License grant. + + 1. Subject to the terms and conditions of this Public License, + the Licensor hereby grants You a worldwide, royalty-free, + non-sublicensable, non-exclusive, irrevocable license to + exercise the Licensed Rights in the Licensed Material to: + + a. reproduce and Share the Licensed Material, in whole or + in part; and + + b. produce, reproduce, and Share Adapted Material. + + 2. Exceptions and Limitations. For the avoidance of doubt, where + Exceptions and Limitations apply to Your use, this Public + License does not apply, and You do not need to comply with + its terms and conditions. + + 3. Term. The term of this Public License is specified in Section + 6(a). + + 4. Media and formats; technical modifications allowed. The + Licensor authorizes You to exercise the Licensed Rights in + all media and formats whether now known or hereafter created, + and to make technical modifications necessary to do so. The + Licensor waives and/or agrees not to assert any right or + authority to forbid You from making technical modifications + necessary to exercise the Licensed Rights, including + technical modifications necessary to circumvent Effective + Technological Measures. For purposes of this Public License, + simply making modifications authorized by this Section 2(a) + (4) never produces Adapted Material. - g. Licensed Rights means the rights granted to You subject to the terms and conditions of this Public License, which are limited to all Copyright and Similar Rights that apply to Your use of the Licensed Material and that the Licensor has authority to license. + 5. Downstream recipients. + + a. Offer from the Licensor -- Licensed Material. Every + recipient of the Licensed Material automatically + receives an offer from the Licensor to exercise the + Licensed Rights under the terms and conditions of this + Public License. + + b. No downstream restrictions. You may not offer or impose + any additional or different terms or conditions on, or + apply any Effective Technological Measures to, the + Licensed Material if doing so restricts exercise of the + Licensed Rights by any recipient of the Licensed + Material. + + 6. No endorsement. Nothing in this Public License constitutes or + may be construed as permission to assert or imply that You + are, or that Your use of the Licensed Material is, connected + with, or sponsored, endorsed, or granted official status by, + the Licensor or others designated to receive attribution as + provided in Section 3(a)(1)(A)(i). - h. Licensor means the individual(s) or entity(ies) granting rights under this Public License. + b. Other rights. - i. Share means to provide material to the public by any means or process that requires permission under the Licensed Rights, such as reproduction, public display, public performance, distribution, dissemination, communication, or importation, and to make material available to the public including in ways that members of the public may access the material from a place and at a time individually chosen by them. + 1. Moral rights, such as the right of integrity, are not + licensed under this Public License, nor are publicity, + privacy, and/or other similar personality rights; however, to + the extent possible, the Licensor waives and/or agrees not to + assert any such rights held by the Licensor to the limited + extent necessary to allow You to exercise the Licensed + Rights, but not otherwise. - j. Sui Generis Database Rights means rights other than copyright resulting from Directive 96/9/EC of the European Parliament and of the Council of 11 March 1996 on the legal protection of databases, as amended and/or succeeded, as well as other essentially equivalent rights anywhere in the world. + 2. Patent and trademark rights are not licensed under this + Public License. - k. You means the individual or entity exercising the Licensed Rights under this Public License. Your has a corresponding meaning. + 3. To the extent possible, the Licensor waives any right to + collect royalties from You for the exercise of the Licensed + Rights, whether directly or through a collecting society + under any voluntary or waivable statutory or compulsory + licensing scheme. In all other cases the Licensor expressly + reserves any right to collect such royalties. + + +Section 3 -- License Conditions. -Section 2 – Scope. +Your exercise of the Licensed Rights is expressly made subject to the +following conditions. - a. License grant. + a. Attribution. - 1. Subject to the terms and conditions of this Public License, the Licensor hereby grants You a worldwide, royalty-free, non-sublicensable, non-exclusive, irrevocable license to exercise the Licensed Rights in the Licensed Material to: + 1. If You Share the Licensed Material (including in modified + form), You must: - A. reproduce and Share the Licensed Material, in whole or in part; and + a. retain the following if it is supplied by the Licensor + with the Licensed Material: - B. produce, reproduce, and Share Adapted Material. + i. identification of the creator(s) of the Licensed + Material and any others designated to receive + attribution, in any reasonable manner requested by + the Licensor (including by pseudonym if + designated); - 2. Exceptions and Limitations. For the avoidance of doubt, where Exceptions and Limitations apply to Your use, this Public License does not apply, and You do not need to comply with its terms and conditions. + ii. a copyright notice; - 3. Term. The term of this Public License is specified in Section 6(a). + iii. a notice that refers to this Public License; - 4. Media and formats; technical modifications allowed. The Licensor authorizes You to exercise the Licensed Rights in all media and formats whether now known or hereafter created, and to make technical modifications necessary to do so. The Licensor waives and/or agrees not to assert any right or authority to forbid You from making technical modifications necessary to exercise the Licensed Rights, including technical modifications necessary to circumvent Effective Technological Measures. For purposes of this Public License, simply making modifications authorized by this Section 2(a)(4) never produces Adapted Material. + iv. a notice that refers to the disclaimer of + warranties; - 5. Downstream recipients. + v. a URI or hyperlink to the Licensed Material to the + extent reasonably practicable; - A. Offer from the Licensor – Licensed Material. Every recipient of the Licensed Material automatically receives an offer from the Licensor to exercise the Licensed Rights under the terms and conditions of this Public License. + b. indicate if You modified the Licensed Material and + retain an indication of any previous modifications; and - B. No downstream restrictions. You may not offer or impose any additional or different terms or conditions on, or apply any Effective Technological Measures to, the Licensed Material if doing so restricts exercise of the Licensed Rights by any recipient of the Licensed Material. + c. indicate the Licensed Material is licensed under this + Public License, and include the text of, or the URI or + hyperlink to, this Public License. - 6. No endorsement. Nothing in this Public License constitutes or may be construed as permission to assert or imply that You are, or that Your use of the Licensed Material is, connected with, or sponsored, endorsed, or granted official status by, the Licensor or others designated to receive attribution as provided in Section 3(a)(1)(A)(i). + 2. You may satisfy the conditions in Section 3(a)(1) in any + reasonable manner based on the medium, means, and context in + which You Share the Licensed Material. For example, it may be + reasonable to satisfy the conditions by providing a URI or + hyperlink to a resource that includes the required + information. -b. Other rights. + 3. If requested by the Licensor, You must remove any of the + information required by Section 3(a)(1)(A) to the extent + reasonably practicable. - 1. Moral rights, such as the right of integrity, are not licensed under this Public License, nor are publicity, privacy, and/or other similar personality rights; however, to the extent possible, the Licensor waives and/or agrees not to assert any such rights held by the Licensor to the limited extent necessary to allow You to exercise the Licensed Rights, but not otherwise. + 4. If You Share Adapted Material You produce, the Adapter's + License You apply must not prevent recipients of the Adapted + Material from complying with this Public License. - 2. Patent and trademark rights are not licensed under this Public License. - 3. To the extent possible, the Licensor waives any right to collect royalties from You for the exercise of the Licensed Rights, whether directly or through a collecting society under any voluntary or waivable statutory or compulsory licensing scheme. In all other cases the Licensor expressly reserves any right to collect such royalties. +Section 4 -- Sui Generis Database Rights. -Section 3 – License Conditions. +Where the Licensed Rights include Sui Generis Database Rights that +apply to Your use of the Licensed Material: -Your exercise of the Licensed Rights is expressly made subject to the following conditions. + a. for the avoidance of doubt, Section 2(a)(1) grants You the right + to extract, reuse, reproduce, and Share all or a substantial + portion of the contents of the database; - a. Attribution. + b. if You include all or a substantial portion of the database + contents in a database in which You have Sui Generis Database + Rights, then the database in which You have Sui Generis Database + Rights (but not its individual contents) is Adapted Material; and - 1. If You Share the Licensed Material (including in modified form), You must: + c. You must comply with the conditions in Section 3(a) if You Share + all or a substantial portion of the contents of the database. - A. retain the following if it is supplied by the Licensor with the Licensed Material: +For the avoidance of doubt, this Section 4 supplements and does not +replace Your obligations under this Public License where the Licensed +Rights include other Copyright and Similar Rights. - i. identification of the creator(s) of the Licensed Material and any others designated to receive attribution, in any reasonable manner requested by the Licensor (including by pseudonym if designated); - ii. a copyright notice; +Section 5 -- Disclaimer of Warranties and Limitation of Liability. - iii. a notice that refers to this Public License; + a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE + EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS + AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF + ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS, + IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION, + WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR + PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS, + ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT + KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT + ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU. - iv. a notice that refers to the disclaimer of warranties; + b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE + TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION, + NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT, + INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES, + COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR + USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN + ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR + DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR + IN PART, THIS LIMITATION MAY NOT APPLY TO YOU. - v. a URI or hyperlink to the Licensed Material to the extent reasonably practicable; + c. The disclaimer of warranties and limitation of liability provided + above shall be interpreted in a manner that, to the extent + possible, most closely approximates an absolute disclaimer and + waiver of all liability. - B. indicate if You modified the Licensed Material and retain an indication of any previous modifications; and - C. indicate the Licensed Material is licensed under this Public License, and include the text of, or the URI or hyperlink to, this Public License. +Section 6 -- Term and Termination. - 2. You may satisfy the conditions in Section 3(a)(1) in any reasonable manner based on the medium, means, and context in which You Share the Licensed Material. For example, it may be reasonable to satisfy the conditions by providing a URI or hyperlink to a resource that includes the required information. + a. This Public License applies for the term of the Copyright and + Similar Rights licensed here. However, if You fail to comply with + this Public License, then Your rights under this Public License + terminate automatically. - 3. If requested by the Licensor, You must remove any of the information required by Section 3(a)(1)(A) to the extent reasonably practicable. + b. Where Your right to use the Licensed Material has terminated under + Section 6(a), it reinstates: - 4. If You Share Adapted Material You produce, the Adapter's License You apply must not prevent recipients of the Adapted Material from complying with this Public License. + 1. automatically as of the date the violation is cured, provided + it is cured within 30 days of Your discovery of the + violation; or -Section 4 – Sui Generis Database Rights. + 2. upon express reinstatement by the Licensor. -Where the Licensed Rights include Sui Generis Database Rights that apply to Your use of the Licensed Material: + For the avoidance of doubt, this Section 6(b) does not affect any + right the Licensor may have to seek remedies for Your violations + of this Public License. - a. for the avoidance of doubt, Section 2(a)(1) grants You the right to extract, reuse, reproduce, and Share all or a substantial portion of the contents of the database; + c. For the avoidance of doubt, the Licensor may also offer the + Licensed Material under separate terms or conditions or stop + distributing the Licensed Material at any time; however, doing so + will not terminate this Public License. - b. if You include all or a substantial portion of the database contents in a database in which You have Sui Generis Database Rights, then the database in which You have Sui Generis Database Rights (but not its individual contents) is Adapted Material; and + d. Sections 1, 5, 6, 7, and 8 survive termination of this Public + License. - c. You must comply with the conditions in Section 3(a) if You Share all or a substantial portion of the contents of the database. -For the avoidance of doubt, this Section 4 supplements and does not replace Your obligations under this Public License where the Licensed Rights include other Copyright and Similar Rights. -Section 5 – Disclaimer of Warranties and Limitation of Liability. +Section 7 -- Other Terms and Conditions. - a. Unless otherwise separately undertaken by the Licensor, to the extent possible, the Licensor offers the Licensed Material as-is and as-available, and makes no representations or warranties of any kind concerning the Licensed Material, whether express, implied, statutory, or other. This includes, without limitation, warranties of title, merchantability, fitness for a particular purpose, non-infringement, absence of latent or other defects, accuracy, or the presence or absence of errors, whether or not known or discoverable. Where disclaimers of warranties are not allowed in full or in part, this disclaimer may not apply to You. + a. The Licensor shall not be bound by any additional or different + terms or conditions communicated by You unless expressly agreed. - b. To the extent possible, in no event will the Licensor be liable to You on any legal theory (including, without limitation, negligence) or otherwise for any direct, special, indirect, incidental, consequential, punitive, exemplary, or other losses, costs, expenses, or damages arising out of this Public License or use of the Licensed Material, even if the Licensor has been advised of the possibility of such losses, costs, expenses, or damages. Where a limitation of liability is not allowed in full or in part, this limitation may not apply to You. + b. Any arrangements, understandings, or agreements regarding the + Licensed Material not stated herein are separate from and + independent of the terms and conditions of this Public License. - c. The disclaimer of warranties and limitation of liability provided above shall be interpreted in a manner that, to the extent possible, most closely approximates an absolute disclaimer and waiver of all liability. -Section 6 – Term and Termination. +Section 8 -- Interpretation. - a. This Public License applies for the term of the Copyright and Similar Rights licensed here. However, if You fail to comply with this Public License, then Your rights under this Public License terminate automatically. + a. For the avoidance of doubt, this Public License does not, and + shall not be interpreted to, reduce, limit, restrict, or impose + conditions on any use of the Licensed Material that could lawfully + be made without permission under this Public License. - b. Where Your right to use the Licensed Material has terminated under Section 6(a), it reinstates: + b. To the extent possible, if any provision of this Public License is + deemed unenforceable, it shall be automatically reformed to the + minimum extent necessary to make it enforceable. If the provision + cannot be reformed, it shall be severed from this Public License + without affecting the enforceability of the remaining terms and + conditions. - 1. automatically as of the date the violation is cured, provided it is cured within 30 days of Your discovery of the violation; or + c. No term or condition of this Public License will be waived and no + failure to comply consented to unless expressly agreed to by the + Licensor. - 2. upon express reinstatement by the Licensor. + d. Nothing in this Public License constitutes or may be interpreted + as a limitation upon, or waiver of, any privileges and immunities + that apply to the Licensor or You, including from the legal + processes of any jurisdiction or authority. - c. For the avoidance of doubt, this Section 6(b) does not affect any right the Licensor may have to seek remedies for Your violations of this Public License. - d. For the avoidance of doubt, the Licensor may also offer the Licensed Material under separate terms or conditions or stop distributing the Licensed Material at any time; however, doing so will not terminate this Public License. +======================================================================= - e. Sections 1, 5, 6, 7, and 8 survive termination of this Public License. - -Section 7 – Other Terms and Conditions. - - a. The Licensor shall not be bound by any additional or different terms or conditions communicated by You unless expressly agreed. - - b. Any arrangements, understandings, or agreements regarding the Licensed Material not stated herein are separate from and independent of the terms and conditions of this Public License. - -Section 8 – Interpretation. - - a. For the avoidance of doubt, this Public License does not, and shall not be interpreted to, reduce, limit, restrict, or impose conditions on any use of the Licensed Material that could lawfully be made without permission under this Public License. - - b. To the extent possible, if any provision of this Public License is deemed unenforceable, it shall be automatically reformed to the minimum extent necessary to make it enforceable. If the provision cannot be reformed, it shall be severed from this Public License without affecting the enforceability of the remaining terms and conditions. - - c. No term or condition of this Public License will be waived and no failure to comply consented to unless expressly agreed to by the Licensor. - - d. Nothing in this Public License constitutes or may be interpreted as a limitation upon, or waiver of, any privileges and immunities that apply to the Licensor or You, including from the legal processes of any jurisdiction or authority. - -Creative Commons is not a party to its public licenses. Notwithstanding, Creative Commons may elect to apply one of its public licenses to material it publishes and in those instances will be considered the “Licensor.” Except for the limited purpose of indicating that material is shared under a Creative Commons public license or as otherwise permitted by the Creative Commons policies published at creativecommons.org/policies, Creative Commons does not authorize the use of the trademark “Creative Commons” or any other trademark or logo of Creative Commons without its prior written consent including, without limitation, in connection with any unauthorized modifications to any of its public licenses or any other arrangements, understandings, or agreements concerning use of licensed material. For the avoidance of doubt, this paragraph does not form part of the public licenses. +Creative Commons is not a party to its public +licenses. Notwithstanding, Creative Commons may elect to apply one of +its public licenses to material it publishes and in those instances +will be considered the “Licensor.” The text of the Creative Commons +public licenses is dedicated to the public domain under the CC0 Public +Domain Dedication. Except for the limited purpose of indicating that +material is shared under a Creative Commons public license or as +otherwise permitted by the Creative Commons policies published at +creativecommons.org/policies, Creative Commons does not authorize the +use of the trademark "Creative Commons" or any other trademark or logo +of Creative Commons without its prior written consent including, +without limitation, in connection with any unauthorized modifications +to any of its public licenses or any other arrangements, +understandings, or agreements concerning use of licensed material. For +the avoidance of doubt, this paragraph does not form part of the +public licenses. Creative Commons may be contacted at creativecommons.org. + diff --git a/LICENSES/MIT.txt b/LICENSES/MIT.txt new file mode 100644 index 0000000..d817195 --- /dev/null +++ b/LICENSES/MIT.txt @@ -0,0 +1,18 @@ +MIT License + +Copyright (c) + +Permission is hereby granted, free of charge, to any person obtaining a copy of this software and +associated documentation files (the "Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the +following conditions: + +The above copyright notice and this permission notice shall be included in all copies or substantial +portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER +IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE +USE OR OTHER DEALINGS IN THE SOFTWARE. diff --git a/README.md b/README.md index 63fe3f9..8de5e74 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ @@ -8,12 +8,14 @@ SPDX-License-Identifier: CC-BY-4.0 [![Run Tests](https://github.com/GenomicDataInfrastructure/fitsm-process-map/actions/workflows/test.yml/badge.svg)](https://github.com/GenomicDataInfrastructure/fitsm-process-map/actions/workflows/test.yml) [![Publish main](https://github.com/GenomicDataInfrastructure/fitsm-process-map/actions/workflows/main.yml/badge.svg)](https://github.com/GenomicDataInfrastructure/fitsm-process-map/actions/workflows/main.yml) [![Publish release](https://github.com/GenomicDataInfrastructure/fitsm-process-map/actions/workflows/release.yml/badge.svg)](https://github.com/GenomicDataInfrastructure/fitsm-process-map/actions/workflows/release.yml) -[![GitHub contributors](https://img.shields.io/github/contributors/GenomicDataInfrastructure/fitsm-process-map)](https://github.com/GenomicDataInfrastructure/fitsm-process-map/graphs/contributors) [![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-2.1-4baaaa.svg)](CODE_OF_CONDUCT.md) # FitSM Process Map -An interactive diagram for learning [FitSM](https://www.fitsm.eu/), the lightweight IT service management standard. It shows the 14 FitSM processes and the interfaces between them, and lets you drill into each part of the standard. +A subway-style map of [FitSM](https://www.fitsm.eu/), the lightweight IT service management +standard. The 14 FitSM processes are stations; the interfaces between them are the +connections. Click a station or a connection and the frame beside the map shows what FitSM +says about it, with a reference to the FitSM document and section for every item. **Live site:** https://genomicdatainfrastructure.github.io/fitsm-process-map/ @@ -21,75 +23,148 @@ An interactive diagram for learning [FitSM](https://www.fitsm.eu/), the lightwei | Click on | You see | | --- | --- | -| A process | Its objective, requirements (FitSM-1), roles, databases and records, activities and interfaces | -| A role | Its tasks (FitSM-3), split into process-specific and generic tasks, and how many are assigned | -| A database or record | Its description, source, and which processes use it | -| An activity | Its procedures, as the ordered steps from FitSM-2 | -| An arrow (interface) | The relationship description and the inputs / outputs exchanged between the two processes | +| A process (station) | Its objective, requirements (FitSM-1), roles, databases and records, activities, interfaces, and inputs/outputs exchanged with parties outside the processes | +| A connection | FitSM's description of the interface and the inputs and outputs exchanged in each direction | +| A role | Its tasks (FitSM-3), split into tasks specific to the process and tasks common to every role of that kind | +| An activity | Its procedure, as the ordered steps from FitSM-2 | +| A database or record | Its FitSM-0 definition and the processes that use it | +| **General requirements** (header) | FitSM-1's general requirements GR1–GR7 | -A process can also be opened directly by link, e.g. `…/fitsm-process-map/#ISRM`. +Any view can be opened directly by link, for example `…/fitsm-process-map/#ISRM` for a +process, `#ISRM-PM` for an interface or `#GR` for the general requirements. + +The coloured lines group related processes as a study aid. They are not part of FitSM, and +the page says so wherever they appear. Everything else on the page is FitSM's own text, with +the few interpretations (such as which records a process uses) labelled "Not part of FitSM". ## Sources -The content comes from the FitSM v3 standard, published by ITEMO e.V. under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) at [fitsm.eu/downloads](https://www.fitsm.eu/downloads/): +The content comes from FitSM edition 3.0, published by ITEMO e.V. under +[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/) at +[fitsm.eu/downloads](https://www.fitsm.eu/downloads/): -- FitSM-0 Overview and vocabulary v3.0: definitions used for databases and records -- FitSM-1 Requirements v3.0.1: requirements PR1–PR14 -- FitSM-2 Process activities and implementation v3.0.2: objectives, activities, inputs / outputs and key interfaces -- FitSM-3 Role model v3.0.1: roles and tasks +- FitSM-0 Overview and vocabulary: definitions of records and information stores +- FitSM-1 Requirements: general requirements GR1–GR7 and process requirements PR1–PR14 +- FitSM-2 Process activities and implementation: objectives, activities and procedures, + inputs/outputs and key interfaces +- FitSM-3 Role model: roles and tasks -A few things are interpretation rather than quotation, and each is labelled on the page: +The exact document versions the site reflects are listed in the page footer and in +`content/fitsm-3.0/edition.json`. -- FitSM does not list databases per process; they are derived from each process's outputs, and each one names its source. -- Where FitSM-2's two interface tables disagree, both descriptions are shown with a note. -- The colour groups are a study aid, not part of the standard. +## Running locally -## Project structure +The page fetches its content over HTTP, so opening `index.html` from the file system does not +work. Serve the folder with any static server, for example: -| File | Purpose | -| --- | --- | -| `index.html` | The page: layout, styles and the diagram / panel logic | -| `fitsm-data.js` | All FitSM content: processes, requirements, roles, databases, activities, interfaces and diagram positions | -| `scripts/check.js` | Consistency checks run in CI (references resolve, nothing missing, page script parses) | +```bash +python3 -m http.server 8765 +``` -To correct or extend the content, edit `fitsm-data.js`. No build step is needed. +Then open http://localhost:8765. No build step and no dependencies are needed. -## Running locally +## Project structure -The page loads `fitsm-data.js` next to it, so serve the folder over HTTP: +| Path | Purpose | +| --- | --- | +| `index.html`, `styles.css` | The page: header, map container, legend, detail frame, footer | +| `src/app.js` | Loads the content, builds the model, renders, and routes on the address hash | +| `src/content.js` | Turns the JSON files into an indexed model (pure, tested in Node) | +| `src/graph.js` | Line colours, interchanges, labels (pure, tested in Node) | +| `src/router.js` | Parses and formats the address hash (pure, tested in Node) | +| `src/map.js` | Draws the SVG map | +| `src/panel.js` | Renders the detail frame views | +| `content/editions.json` | Which FitSM editions are present and which one the page shows | +| `content/fitsm-3.0/` | The FitSM 3.0 content: eight JSON files (see below) | +| `scripts/check.js` | Consistency and contrast checks, run in CI | +| `tests/` | Unit tests (`node --test`) and fixtures for the check script | + +Each edition directory holds `edition.json` (documents, versions, licence), `processes.json`, +`requirements.json`, `roles.json`, `activities.json`, `records.json`, `interfaces.json` and +`map.json` (lines, station positions, routes). Every content item carries a `source` naming +the FitSM document and section it comes from. + +## Checks and tests ```bash -python3 -m http.server 8000 +node scripts/check.js ``` -Then open http://localhost:8000. To run the same checks as CI: +Checks every edition listed in `content/editions.json`: all references resolve, every process +has its objective, requirements, roles and activities and sits on a line, every interface has +a route, line colours pass WCAG contrast, and more. Exit code 0 means no errors; 1 means at +least one error (each printed as `error /: : `); 2 means a +file could not be read. A line whose processes are not all connected through that line is a +warning and does not fail the run. Options: `--content ` checks one edition directory; +`--editions ` names a different editions file; `--quiet` prints findings only. ```bash -node scripts/check.js +node --test ``` +Runs the unit tests for the pure modules and the check script's fixtures. + +## Updating the content + +Only `content/` changes for a content update; the page code does not. + +### Updating to a new FitSM edition + +1. Download the new PDFs from the URL in the current `edition.json` (`downloads`). +2. Copy the current edition directory to a new one, for example `content/fitsm-3.1/`, and add + it to `content/editions.json` under `editions`. Leave `current` pointing at the old one + until the new content is complete. +3. In the new directory, update `edition.json`: each document's `version`, `url` and the page + of its licence statement. +4. Work through the files in this order, because later files reference earlier ones: + `processes.json` → `requirements.json` → `roles.json` → `activities.json` → + `records.json` → `interfaces.json` → `map.json`. Quote FitSM text unchanged; put wording + of your own only into `note` fields. +5. Run `node scripts/check.js` and fix every error; read the warnings. +6. Set `current` in `content/editions.json` to the new id and add a line to `CHANGELOG.md` + naming the edition and the documents' versions. +7. Open a pull request citing the FitSM document and section for each content change. + +### Adding a connection + +1. Add an entry to `interfaces.json` with the two process codes in alphabetical order and at + least one description or one flow. +2. Add a route for the same id to `map.json` under `routes` (an empty array draws a straight + segment). +3. Run the checks: a missing route fails with the interface id. + +### Changing the lines + +Edit `lines` in `map.json` only. Membership, names, colours and label sides are free to +change; the checks verify that every process is on a line, that colours pass contrast, and +warn when a line's stations are not connected through interfaces. + ## CI/CD | Workflow | Trigger | What it does | | --- | --- | --- | -| `test.yml` — Run Tests | Every push and pull request | [REUSE](https://reuse.software/) compliance and `scripts/check.js` | -| `main.yml` — Publish main | After Run Tests succeeds on `main` (or manually) | Re-runs `scripts/check.js`, then deploys the site to GitHub Pages | +| `test.yml` — Run Tests | Every push and pull request | [REUSE](https://reuse.software/) compliance, `node scripts/check.js`, `node --test` | +| `main.yml` — Publish main | After Run Tests succeeds on `main` (or manually) | Re-runs the checks, copies the site files to `_site/` and deploys them to GitHub Pages | | `release.yml` — Publish release | Tags matching `v*` | Creates a GitHub release with the site attached as a zip | -All actions are pinned to commit SHAs. - -The project has no package-managed dependencies (no npm, pip or similar), and no Docker image is built, so neither a dependency licence scan (ORT) nor an image scan (Trivy) runs. The only external resource is the [IBM Plex](https://github.com/IBM/plex) font family, loaded at runtime from Google Fonts under the SIL Open Font License 1.1. If a package-managed dependency or a container image is added, reintroduce those scans. +All actions are pinned to commit SHAs. The project has no package-managed dependencies and +loads nothing from third-party servers at runtime. **One-time setup:** in the repository's *Settings → Pages*, set **Source** to **GitHub Actions**. ## Contributing -See [CONTRIBUTING.md](CONTRIBUTING.md) and the [Code of Conduct](CODE_OF_CONDUCT.md). Every file must carry SPDX copyright and licence information ([REUSE](https://reuse.software/)); check with `reuse lint`. +See [CONTRIBUTING.md](CONTRIBUTING.md) and the [Code of Conduct](CODE_OF_CONDUCT.md). Every +file carries SPDX copyright and licence information ([REUSE](https://reuse.software/)); check +with `reuse lint`. -## Licenses +## Licence -This work is licensed under multiple licences: +The whole project, code, documentation and content, is licensed under +[Creative Commons Attribution 4.0 International (CC BY 4.0)](LICENSES/CC-BY-4.0.txt), the same +licence as FitSM. FitSM content © ITEMO e.V., reproduced unchanged; the site's own additions +are labelled on the page. See the SPDX headers and `REUSE.toml` for per-file information. -- Source code (`index.html`, `scripts/`, workflows) is licensed under [Apache-2.0](./LICENSES/Apache-2.0.txt). -- Documentation and the FitSM content in `fitsm-data.js` are licensed under [CC-BY-4.0](./LICENSES/CC-BY-4.0.txt). FitSM content © ITEMO e.V. -- For more accurate information, check the individual files. +The only third-party files in the repository are the [Spec Kit](https://github.com/github/spec-kit) +templates and scripts under `.specify/`, used to write the specification; they stay under +their own [MIT licence](LICENSES/MIT.txt) and are not part of the published site. diff --git a/REUSE.toml b/REUSE.toml new file mode 100644 index 0000000..9d42505 --- /dev/null +++ b/REUSE.toml @@ -0,0 +1,32 @@ +version = 1 + +# FitSM content transcribed from the FitSM 3.0 documents (ITEMO e.V., CC BY 4.0) plus the +# project's own structure and map layout. JSON cannot carry comment headers, so the files +# are annotated here. +[[annotations]] +path = ["content/**"] +precedence = "aggregate" +SPDX-FileCopyrightText = ["ITEMO e.V. (FitSM content)", "2026 PNED G.I.E."] +SPDX-License-Identifier = "CC-BY-4.0" + +# Project files without a comment syntax, and the feature specifications. +[[annotations]] +path = ["package.json", "tests/fixtures/**", "specs/**"] +precedence = "aggregate" +SPDX-FileCopyrightText = "2026 PNED G.I.E." +SPDX-License-Identifier = "CC-BY-4.0" + +# Spec Kit tooling (templates, scripts, workflow definitions) installed by +# `specify init`; third-party, kept under its own licence. +[[annotations]] +path = [".specify/**"] +precedence = "aggregate" +SPDX-FileCopyrightText = "GitHub, Inc. (Spec Kit)" +SPDX-License-Identifier = "MIT" + +# The project's own Spec Kit files: the constitution and the feature pointer. +[[annotations]] +path = [".specify/memory/**", ".specify/feature.json"] +precedence = "override" +SPDX-FileCopyrightText = "2026 PNED G.I.E." +SPDX-License-Identifier = "CC-BY-4.0" diff --git a/content/editions.json b/content/editions.json new file mode 100644 index 0000000..a9c7aa7 --- /dev/null +++ b/content/editions.json @@ -0,0 +1,6 @@ +{ + "current": "fitsm-3.0", + "editions": [ + { "id": "fitsm-3.0", "label": "FitSM 3.0 (English)", "path": "fitsm-3.0" } + ] +} diff --git a/content/fitsm-3.0/activities.json b/content/fitsm-3.0/activities.json new file mode 100644 index 0000000..d38540c --- /dev/null +++ b/content/fitsm-3.0/activities.json @@ -0,0 +1,311 @@ +[ + { "id": "SPM.S", "process": "SPM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR1", "page": 11 }, "procedure": [ + "Define a way to document the service portfolio.", + "Define a way to describe / specify a specific service (e.g. service specification template) including the different lifecycle phases that the service may move through (e.g. proposed, planned, production, retired).", + "Set up an initial service portfolio (including service specifications) covering at least all live services provided to customers, as far as they are in the scope of the service management system.", + "Create a map of the bodies / parties (organisations, federation members) involved in delivering services.", + "Identify and describe the role of each party in service provisioning.", + "Identify a single contact point for each body / party.", + "Define a way to deal with changed demand for services and new service proposals.", + "Create a service proposal template (e.g. smaller subset of the service specification template).", + "Write down the assessment criteria used to make decisions on proposals for new or changed services." + ] }, + { "id": "SPM.A1", "process": "SPM", "phase": "execution", "name": "Manage demand and service proposals", "source": { "doc": "FitSM-2", "section": "PR1", "page": 11 }, "procedure": [ + "Identify demand for new or changed services", + "Create service proposal", + "Evaluate service proposal" + ] }, + { "id": "SPM.A2", "process": "SPM", "phase": "execution", "name": "Maintain the service portfolio", "source": { "doc": "FitSM-2", "section": "PR1", "page": 11 }, "procedure": [ + "Add a new service to the service portfolio", + "Update service in the service portfolio", + "Retire service from the service portfolio" + ] }, + { "id": "SPM.A3", "process": "SPM", "phase": "execution", "name": "Manage services through their lifecycle", "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 }, "procedure": [ + "Design and plan a new or changed service", + "Oversee the implementation (of the plan for a new or changed service)" + ] }, + + { "id": "SLM.S", "process": "SLM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 }, "procedure": [ + "Define the minimum structure, format and content for service catalogues.", + "Create an initial service catalogue based on the information in the service portfolio.", + "Define a basic / default SLA valid for all services provided to customers, where no specific / individual SLAs are in place.", + "Define templates for individual SLAs, OLAs and UAs.", + "Identify the most critical supporting service components and agree OLAs and UAs with internal and external suppliers contributing to delivering services to customers.", + "Agree individual SLAs with customers for the most important / critical services.", + "Define a standard way to notify customers of SLA violations." + ] }, + { "id": "SLM.A1", "process": "SLM", "phase": "execution", "name": "Maintain service catalogues", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 }, "procedure": [ + "Create a new service catalogue", + "Add, update or remove services from a catalogue", + "Retire a service catalogue" + ] }, + { "id": "SLM.A2", "process": "SLM", "phase": "execution", "name": "Maintain SLAs", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 }, "procedure": [ + "Defined and negotiate / agree a new SLA", + "Evaluate SLA fulfilment", + "Notify customer of an SLA violation", + "Review, update or terminate an SLA" + ] }, + { "id": "SLM.A3", "process": "SLM", "phase": "execution", "name": "Maintain supporting agreements (OLAs and UAs)", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 }, "procedure": [ + "Define and negotiate / agree a new OLA / UA", + "Evaluate OLA / UA fulfilment", + "Escalate an OLA / UA violation to the supplier", + "Review, update or terminate an OLA / UA" + ] }, + + { "id": "SRM.S", "process": "SRM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 }, "procedure": [ + "Create a list of all reports that are currently produced or will be produced on a regular basis.", + "Specify every identified report by giving the report a unique name (ID), describing the purpose of the report, identifying its audience / addressee, defining its frequency, outlining the intended contents of the report and defining its format and method of delivery.", + "Define templates for reports to standardise / harmonise the report structure and support effective and repeatable reporting." + ] }, + { "id": "SRM.A1", "process": "SRM", "phase": "execution", "name": "Identify reporting requirements", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 }, "procedure": [ + "Derive targets, events and nonconformities to be reported to customers based on SLAs", + "Identify targets, events and nonconformities to be reported to internal stakeholders to support management of the SMS" + ] }, + { "id": "SRM.A2", "process": "SRM", "phase": "execution", "name": "Maintain report specifications", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 }, "procedure": [ + "Define/specify a new report", + "Update a report specification", + "Terminate a report" + ] }, + { "id": "SRM.A3", "process": "SRM", "phase": "execution", "name": "Monitor the production and distribution of reports", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 }, "procedure": [ + "Verify the production and distribution of reports according to specifications", + "Initiate follow-up actions in case of inaccurate reporting" + ] }, + + { "id": "SACM.S", "process": "SACM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 }, "procedure": [ + "Identify the most critical service availability and continuity requirements based on SLAs and other sources of information.", + "Define the structure and format of a (generic) service availability and continuity plan.", + "Define an approach to monitor service availability (and continuity) and to record the results on an ongoing basis." + ] }, + { "id": "SACM.A1", "process": "SACM", "phase": "execution", "name": "Identify service availability and continuity requirements", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 }, "procedure": [ + "Derive availability targets from SLAs", + "Identify continuity requirements based on SLAs and business impact analysis" + ] }, + { "id": "SACM.A2", "process": "SACM", "phase": "execution", "name": "Maintain and implement service availability and continuity plans", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 }, "procedure": [ + "Assess risks related to service availability and continuity", + "Create service continuity and availability plans", + "Implement preventive measures from plans", + "Review, update or terminate service continuity and availability plans" + ] }, + { "id": "SACM.A3", "process": "SACM", "phase": "execution", "name": "Evaluate service availability and continuity", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 }, "procedure": [ + "Monitor service availability", + "Perform service continuity tests for reactive measures from plans" + ] }, + + { "id": "CAPM.S", "process": "CAPM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 }, "procedure": [ + "Define the structure and format of a (generic) capacity plan.", + "Define an approach to monitor service performance and capacity (including utilisation of resources) and to record the results on an ongoing basis." + ] }, + { "id": "CAPM.A1", "process": "CAPM", "phase": "execution", "name": "Identify service capacity and performance requirements", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 }, "procedure": [ + "Derive performance targets from SLAs", + "Translate performance targets into capacity requirements" + ] }, + { "id": "CAPM.A2", "process": "CAPM", "phase": "execution", "name": "Maintain and implement capacity plans", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 }, "procedure": [ + "Create capacity plans", + "Ensure capacity according to plans", + "Review, update or terminate capacity plans" + ] }, + { "id": "CAPM.A3", "process": "CAPM", "phase": "execution", "name": "Evaluate service performance", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 }, "procedure": [ + "Monitor performance of services and service components", + "Monitor capacity including assessment against thresholds", + "Respond when capacity thresholds are exceeded" + ] }, + + { "id": "ISM.S", "process": "ISM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR6", "page": 23 }, "procedure": [ + "Define a scheme to classify information assets according to their sensitivity / criticality.", + "Define a way to document an inventory of (information) assets.", + "Identify, describe and classify the most important information assets.", + "Identify the most important links between service components such as information-processing systems / facilities and the information assets identified before.", + "Define a method / scheme to identify and assess information security risks.", + "Perform an initial risk assessment, based on the identified assets, and focused on the most significant information security risks.", + "Define clear information security policies as a basis for effective information security governance.", + "Define a way to document information security controls and to monitor their status and progress of implementation.", + "Identify and document the most important technical, physical and organisational information security controls in place." + ] }, + { "id": "ISM.A1", "process": "ISM", "phase": "execution", "name": "Identify information security requirements", "source": { "doc": "FitSM-2", "section": "PR6", "page": 23 }, "procedure": [ + "Derive information security requirements from SLAs", + "Identify information (assets) to be protected and their needs in terms of confidentiality, integrity and availability" + ] }, + { "id": "ISM.A2", "process": "ISM", "phase": "execution", "name": "Maintain and implement information security controls and policies", "source": { "doc": "FitSM-2", "section": "PR6", "page": 23 }, "procedure": [ + "Assess risks related information security", + "Create information security policies and define other controls", + "Implement information security controls", + "Review, update or terminate information security policies and other controls" + ] }, + { "id": "ISM.A3", "process": "ISM", "phase": "execution", "name": "Evaluate information security", "source": { "doc": "FitSM-2", "section": "PR6", "page": 23 }, "procedure": [ + "Monitor, record and classify information security events", + "Identify and handle information security incidents" + ] }, + { "id": "ISM.A4", "process": "ISM", "phase": "execution", "name": "Perform access control", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 }, "procedure": [ + "Process requests for access rights", + "Provide access rights", + "Modify or revoke access rights", + "Review access rights (at regular intervals)" + ] }, + + { "id": "CRM.S", "process": "CRM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 }, "procedure": [ + "Set up an initial customer database, and for each service customer document the most important information including contact information.", + "Decide on general communication channels to be used for customer engagement (e.g. ordering, escalation and complaints).", + "Define a way to perform and document the results of a service review.", + "Define a way to record, respond to and follow-up a customer complaint.", + "Define a way to evaluate customer satisfaction on a regular basis, e.g. (online) surveys." + ] }, + { "id": "CRM.A1", "process": "CRM", "phase": "execution", "name": "Maintain the customer database", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 }, "procedure": [ + "Add a new customer to the customer database (including contact information)", + "Update the information on a customer in the customer database", + "Remove a customer from the customer database" + ] }, + { "id": "CRM.A2", "process": "CRM", "phase": "execution", "name": "Perform customer service reviews", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 }, "procedure": [ + "Plan and prepare service reviews with customers", + "Perform and record a service review with a customer" + ] }, + { "id": "CRM.A3", "process": "CRM", "phase": "execution", "name": "Handle customer complaints", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 }, "procedure": [ + "Register, address and close a customer complaint", + "Track the implementation status of actions following a customer complaint", + "Review all customer complaints and follow-up actions periodically" + ] }, + { "id": "CRM.A4", "process": "CRM", "phase": "execution", "name": "Manage customer satisfaction", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 }, "procedure": [ + "Plan and implement measures to assess customer satisfaction", + "Initiate follow-up actions in response to insufficient customer satisfaction" + ] }, + + { "id": "SUPPM.S", "process": "SUPPM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 }, "procedure": [ + "Set up an initial supplier database (covering all internal and external suppliers).", + "For each supplier, document the most important information including contact details both on the supplier side as well as on the service provider side (supplier relationship manager).", + "Understand which supplier services or service components need to be monitored, and how the monitoring will take place." + ] }, + { "id": "SUPPM.A1", "process": "SUPPM", "phase": "execution", "name": "Maintain the supplier database", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 }, "procedure": [ + "Add a new supplier to the supplier database (including contact information)", + "Update the information on a supplier in the supplier database", + "Remove a supplier from the supplier database" + ] }, + { "id": "SUPPM.A2", "process": "SUPPM", "phase": "execution", "name": "Monitor supplier performance", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 }, "procedure": [ + "Evaluate supplier performance", + "Together with the supplier, agree on follow-up actions in response to insufficient supplier performance", + "Track the implementation status of agreed follow-up actions with suppliers" + ] }, + + { "id": "ISRM.S", "process": "ISRM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR9", "page": 29 }, "procedure": [ + "Set up a tool (e.g. ticket / workflow tool) supporting the recording and handling (including classification, prioritisation, escalation, closure) of reported incidents and service requests.", + "Define a standardised and repeatable way (procedure) of recording incidents and service requests that specifies the sources and channels through which incidents and service requests may be raised, the required format of an incident report or service request, and the way in which the incident or service request is recorded in the recording system.", + "Define a standardised and repeatable way (procedure) of classifying incidents and service requests that specifies a suitable classification scheme and describes how it should be applied.", + "Define a standardised and repeatable way (procedure) of prioritising incidents and service requests that specifies a suitable prioritisation scheme and describes how the priority of an incident or service request should be calculated.", + "Define a standardised and repeatable way (procedure) of escalating incidents and service requests that specifies functional and hierarchical escalation paths.", + "Define a standardised and repeatable way (procedure) of closing incidents and service requests that specifies how incidents and service requests are closed, including required user communication and confirmation.", + "Define the criteria for identifying a major incident, as well as a standardised and repeatable way (procedure) of dealing with major incidents from recording to closure, including a major incident review.", + "Identify well-known and recurring incidents, and for each of them describe, where required, the concrete steps to be carried out in response to the respective incident in order to manage it effectively from recording to closure.", + "Identify standardised service requests based on service descriptions and SLAs, and for each of them describe, where required, the concrete steps to be carried out in response to the respective service request in order to manage it effectively from recording to closure." + ] }, + { "id": "ISRM.A1", "process": "ISRM", "phase": "execution", "name": "Manage incidents and service requests", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 }, "procedure": [ + "Register incident or service request", + "Classify and prioritise incident or service request including checking against major incident criteria", + "Escalate incident or service request as required", + "Resolve incident or fulfil service request", + "Close incident or service request" + ] }, + { "id": "ISRM.A2", "process": "ISRM", "phase": "execution", "name": "Manage major incidents", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 }, "procedure": [ + "Identify incident as major incident based on agreed criteria", + "Assign a major incident coordinator for the major incident", + "Handle major incident with highest priority", + "Inform stakeholders and escalate major incident as required", + "Resolve major incident", + "Perform major incident review and close the major incident" + ] }, + { "id": "ISRM.A3", "process": "ISRM", "phase": "execution", "name": "Manage workflows needed to resolve incidents and fulfil service requests", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 }, "procedure": [ + "Maintain the step-by-step workflows for well-known and recurring incidents taking into account the KEDB", + "Maintain workflows for standardised service requests" + ] }, + + { "id": "PM.S", "process": "PM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 }, "procedure": [ + "Define a standardised and repeatable way to register problems, known errors and related workarounds, and set up an initial known error database (KEDB) using a suitable tool or other form of documentation.", + "Set up a tool (e.g. ticket / workflow tool) supporting the recording and handling (including classification, prioritisation, escalation, closure) of identified problems.", + "Make sure relevant information on incidents, including incident records and reports, and the CMDB are accessible to process staff performing problem identification and investigation.", + "Ensure process staff involved in both ISRM and PM are aware of the different goals and perspectives of these processes, even when in practice some activities may overlap or happen almost in parallel." + ] }, + { "id": "PM.A1", "process": "PM", "phase": "execution", "name": "Identify problems", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 }, "procedure": [ + "Perform regular incident pattern and trend analysis to identify (potential) problems", + "Register a problem" + ] }, + { "id": "PM.A2", "process": "PM", "phase": "execution", "name": "Handle problems", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 }, "procedure": [ + "Classify and prioritise a problem", + "Identify the root cause and categorise the problem as a known error", + "Identify one or more workarounds where possible", + "Assess options for resolution of a problem, and resolve a problem where appropriate", + "Close a problem (following resolution or when no longer relevant)" + ] }, + { "id": "PM.A3", "process": "PM", "phase": "execution", "name": "Maintain the KEDB", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 }, "procedure": [ + "Add a known error (including one or more workarounds) to the KEDB", + "Update or deactivate a known error record in the KEDB" + ] }, + + { "id": "CONFM.S", "process": "CONFM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 }, "procedure": [ + "Define the scope of the configuration management process and the integrated configuration management database (CMDB).", + "Agree the level of detail of configuration information to be collected.", + "Identify and define CI types (including their attributes) and relationship types.", + "Based on the defined scope, identify all existing sources of configuration information in the environment of the service provider.", + "Define the concept for integrating available sources of configuration information and add missing configuration information to the integrated CMDB, including the selection of appropriate supporting technology / tools." + ] }, + { "id": "CONFM.A1", "process": "CONFM", "phase": "execution", "name": "Maintain configuration information", "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 }, "procedure": [ + "Record new CI in the CMDB (create a configuration record)", + "Update information on a CI" + ] }, + { "id": "CONFM.A2", "process": "CONFM", "phase": "execution", "name": "Verify configuration information", "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 }, "procedure": [ + "Plan configuration verification", + "Perform configuration verification (to identify errors or inconsistencies in configuration information and trigger corrective actions)" + ] }, + + { "id": "CHM.S", "process": "CHM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR12", "page": 36 }, "procedure": [ + "Set up a tool (e.g. ticket / workflow tool) supporting the recording and handling (including classification, evaluation, approval, implementation, post implementation review) of requested and approved changes.", + "Define a standardised and repeatable way of recording requests for changes (RFCs) and resulting approved changes that specifies the sources and channels through which RFCs may be raised, the required format of an RFC, and the way in which the RFC is recorded in the recording system.", + "Define the criteria for identifying emergency changes, as well as a standardised and repeatable way of dealing with emergency changes from recording to closure, including an emergency change review.", + "Identify well-known and recurring changes , and for each of them create a standardised change and describe, where required, the concrete steps to be carried out in order to manage the respective change effectively from recording to closure (including the steps for implementing the change and ensuring adequate traceability and documentation).", + "Create a schedule of changes (including those in releases to provide an overview of change implementation)." + ] }, + { "id": "CHM.A1", "process": "CHM", "phase": "execution", "name": "Manage change evaluation and approval", "source": { "doc": "FitSM-2", "section": "PR12", "page": 36 }, "procedure": [ + "Register a change based on a request for change (RFC)", + "Classify a change, including checking against major change and emergency change criteria", + "Assess a change", + "Approve or reject a change (considering special conditions for major or emergency changes)" + ] }, + { "id": "CHM.A2", "process": "CHM", "phase": "execution", "name": "Manage change implementation and review (in connection with RDM where applicable)", "source": { "doc": "FitSM-2", "section": "PR12", "page": 36 }, "procedure": [ + "Plan and schedule a change (including technical and non-technical actions)", + "Implement a change", + "Perform a post implementation review (considering special conditions for major or emergency changes)", + "Close a change" + ] }, + + { "id": "RDM.S", "process": "RDM", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 }, "procedure": [ + "Define a standardised and repeatable way of defining and planning releases, based on approved changes and the schedule of changes.", + "Define criteria for identifying different types of releases, such as major releases, minor releases or emergency releases.", + "Define release and deployment strategies for all CIs under control of the change management process, ensuring the approach for deploying changes to a CI or a set of CIs is understood.", + "Define the service components and CIs which the strategy applies to, and under what conditions", + "Define the frequency of releases and manner of release for the strategy", + "Define the testing to be performed under this strategy", + "Define a way to record the results of release and deployment testing and evaluation of acceptance criteria." + ] }, + { "id": "RDM.A1", "process": "RDM", "phase": "execution", "name": "Release planning", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 }, "procedure": [ + "Build a release, based on the applicable release and deployment strategy", + "Test a release" + ] }, + { "id": "RDM.A2", "process": "RDM", "phase": "execution", "name": "Release deployment", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 }, "procedure": [ + "Plan and perform communication and training for users and support staff", + "Prepare deployment of a release", + "Deploy a release", + "Review a release for success", + "Inform stakeholders of the results of the release", + "Close a release" + ] }, + + { "id": "CSI.S", "process": "CSI", "phase": "setup", "name": "Initial process setup", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 }, "procedure": [ + "Identify all relevant sources of potential suggestions for improvement.", + "Define a standardised way to record suggestions for improvements from the identified sources.", + "Set up a tool (e.g. ticket / workflow tool) supporting the recording and handling (including prioritisation, evaluation approval) of suggestions for improvement." + ] }, + { "id": "CSI.A1", "process": "CSI", "phase": "execution", "name": "Manage evaluation of improvements", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 }, "procedure": [ + "Identify and register an opportunity / suggestion for improvement", + "Evaluate an opportunity / suggestion for improvement" + ] }, + { "id": "CSI.A2", "process": "CSI", "phase": "execution", "name": "Manage implementation of improvements", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 }, "procedure": [ + "Initiate an action to address an improvement", + "Track the status and progress of improvement actions" + ] } +] diff --git a/content/fitsm-3.0/edition.json b/content/fitsm-3.0/edition.json new file mode 100644 index 0000000..8f81833 --- /dev/null +++ b/content/fitsm-3.0/edition.json @@ -0,0 +1,43 @@ +{ + "standard": "FitSM", + "edition": "3.0", + "documents": { + "FitSM-0": { + "title": "FitSM-0: Overview and vocabulary", + "version": "3.0.1", + "releaseDate": "2025-06-09", + "url": "https://www.fitsm.eu/download/1660/", + "licenceStatement": { "page": 1 } + }, + "FitSM-1": { + "title": "FitSM-1: Requirements", + "version": "3.0.1", + "releaseDate": "2024-05-21", + "url": "https://www.fitsm.eu/download/1263/", + "licenceStatement": { "page": 1 } + }, + "FitSM-2": { + "title": "FitSM-2: Process activities and implementation", + "version": "3.0.2", + "releaseDate": "2025-12-18", + "url": "https://www.fitsm.eu/download/1716/", + "licenceStatement": { "page": 1 } + }, + "FitSM-3": { + "title": "FitSM-3: Role model", + "version": "3.0.1", + "releaseDate": "2024-05-22", + "url": "https://www.fitsm.eu/download/1268/", + "licenceStatement": { "page": 1 } + } + }, + "downloads": "https://www.fitsm.eu/downloads/", + "licence": { + "name": "CC BY 4.0", + "url": "https://creativecommons.org/licenses/by/4.0/" + }, + "attribution": "ITEMO e.V.", + "externalParties": { + "Any": "any process (FitSM-2: “Any”)" + } +} diff --git a/content/fitsm-3.0/interfaces.json b/content/fitsm-3.0/interfaces.json new file mode 100644 index 0000000..f12652f --- /dev/null +++ b/content/fitsm-3.0/interfaces.json @@ -0,0 +1,284 @@ +[ + { + "id": "CRM-SPM", + "processes": ["CRM", "SPM"], + "descriptions": [], + "flows": [ + { "from": "CRM", "to": "SPM", "item": "Identified customer requirements as a factor to be considered to identify demand for new or changed services", "listedBy": "SPM", "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 } }, + { "from": "CRM", "to": "SPM", "item": "Identified customer requirements as a factor to be considered to identify demand for new or changed services", "listedBy": "CRM", "source": { "doc": "FitSM-2", "section": "PR7", "page": 26 } } + ] + }, + { + "id": "SPM-SUPPM", + "processes": ["SPM", "SUPPM"], + "descriptions": [], + "flows": [ + { "from": "SUPPM", "to": "SPM", "item": "Information on suppliers as a basis for identifying suppliers involved in the delivery of a given service", "listedBy": "SPM", "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 } }, + { "from": "SPM", "to": "SUPPM", "item": "Information on internal and external suppliers involved in delivering a given service (part of plans for new or changed services) as a basis for the identification of new suppliers", "listedBy": "SPM", "source": { "doc": "FitSM-2", "section": "PR1", "page": 13 } }, + { "from": "SPM", "to": "SUPPM", "item": "Information on internal and external suppliers involved in delivering a given service (part of plans for new or changed services) as a basis for the identification of new suppliers", "listedBy": "SUPPM", "source": { "doc": "FitSM-2", "section": "PR8", "page": 28 } }, + { "from": "SUPPM", "to": "SPM", "item": "Information on suppliers as a basis for identifying suppliers involved in the delivery of a given service", "listedBy": "SUPPM", "source": { "doc": "FitSM-2", "section": "PR8", "page": 28 } } + ] + }, + { + "id": "SLM-SPM", + "processes": ["SLM", "SPM"], + "descriptions": [], + "flows": [ + { "from": "SPM", "to": "SLM", "item": "Service portfolio together with service specifications as a basis for creating the service catalogue", "listedBy": "SPM", "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 } }, + { "from": "SPM", "to": "SLM", "item": "Service portfolio together with service specifications as a basis for creating the service catalogue", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 15 } } + ] + }, + { + "id": "CHM-SPM", + "processes": ["CHM", "SPM"], + "descriptions": [], + "flows": [ + { "from": "SPM", "to": "CHM", "item": "Requests for changes to trigger changes to configuration items (CIs) as required to implement plans for new or changed services", "listedBy": "SPM", "source": { "doc": "FitSM-2", "section": "PR1", "page": 13 } } + ] + }, + { + "id": "ISRM-SPM", + "processes": ["ISRM", "SPM"], + "descriptions": [], + "flows": [ + { "from": "SPM", "to": "ISRM", "item": "Service level agreements (SLAs) containing information on agreed service targets to enable prioritisation of incidents and service requests", "listedBy": "SPM", "source": { "doc": "FitSM-2", "section": "PR1", "page": 13 } } + ], + "note": "FitSM-2 lists this row under Service Portfolio Management's outputs; the same wording appears under Service Level Management's interface with ISRM." + }, + { + "id": "CRM-SLM", + "processes": ["CRM", "SLM"], + "descriptions": [], + "flows": [ + { "from": "CRM", "to": "SLM", "item": "Information on customers and identified customer-specific service level requirements (e.g. based on customer feedback or resulting from service reviews with customers) as a basis for defining SLAs", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 15 } }, + { "from": "SLM", "to": "CRM", "item": "Service catalogue for available services that are offered to customers", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 16 } }, + { "from": "SLM", "to": "CRM", "item": "SLAs reflecting what has been agreed with customers together with service reports to support service reviews with customers", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 16 } }, + { "from": "SLM", "to": "CRM", "item": "Service catalogue for available services that are offered to customers", "listedBy": "CRM", "source": { "doc": "FitSM-2", "section": "PR7", "page": 26 } }, + { "from": "SLM", "to": "CRM", "item": "SLAs reflecting what has been agreed with customers together with service reports to support service reviews with customers", "listedBy": "CRM", "source": { "doc": "FitSM-2", "section": "PR7", "page": 26 } }, + { "from": "CRM", "to": "SLM", "item": "Information on customers and identified customer-specific service level requirements (e.g. based on customer feedback or resulting from service reviews with customers) as a basis for defining SLAs", "listedBy": "CRM", "source": { "doc": "FitSM-2", "section": "PR7", "page": 26 } } + ] + }, + { + "id": "SLM-SUPPM", + "processes": ["SLM", "SUPPM"], + "descriptions": [], + "flows": [ + { "from": "SUPPM", "to": "SLM", "item": "Information on suppliers as a basis for defining OLAs and UAs", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 15 } }, + { "from": "SLM", "to": "SUPPM", "item": "OLAs and UAs together with reports on operational targets to support supplier performance evaluation", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 16 } }, + { "from": "SLM", "to": "SUPPM", "item": "OLAs and UAs together with reports on operational targets to support supplier performance evaluation", "listedBy": "SUPPM", "source": { "doc": "FitSM-2", "section": "PR8", "page": 28 } }, + { "from": "SUPPM", "to": "SLM", "item": "Information on suppliers as a basis for new or updated OLAs and UAs", "listedBy": "SUPPM", "source": { "doc": "FitSM-2", "section": "PR8", "page": 28 } } + ] + }, + { + "id": "SLM-SRM", + "processes": ["SLM", "SRM"], + "descriptions": [], + "flows": [ + { "from": "SLM", "to": "SRM", "item": "SLAs with agreed service targets as a basis for identifying service reporting requirements, i.e. understanding the reporting requirements agreed in SLAs", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 15 } }, + { "from": "SLM", "to": "SRM", "item": "Data from evaluation of SLAs, OLAs and UAs as a basis for reports", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 15 } }, + { "from": "SLM", "to": "SRM", "item": "SLAs with agreed service targets as a basis for identifying service reporting requirements, i.e. understanding the reporting requirements agreed in SLAs", "listedBy": "SRM", "source": { "doc": "FitSM-2", "section": "PR3", "page": 18 } }, + { "from": "SLM", "to": "SRM", "item": "Data from evaluation of SLAs, OLAs and UAs as a basis for reports", "listedBy": "SRM", "source": { "doc": "FitSM-2", "section": "PR3", "page": 18 } } + ] + }, + { + "id": "SACM-SLM", + "processes": ["SACM", "SLM"], + "descriptions": [], + "flows": [ + { "from": "SLM", "to": "SACM", "item": "SLAs with agreed service availability and continuity targets as a basis for identifying overall availability and continuity requirements", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 15 } }, + { "from": "SLM", "to": "SACM", "item": "SLAs with agreed service availability and continuity targets as a basis for identifying overall availability and continuity requirements", "listedBy": "SACM", "source": { "doc": "FitSM-2", "section": "PR4", "page": 20 } } + ] + }, + { + "id": "CAPM-SLM", + "processes": ["CAPM", "SLM"], + "descriptions": [], + "flows": [ + { "from": "SLM", "to": "CAPM", "item": "SLAs with agreed capacity and performance targets as a basis for identifying overall capacity and performance requirements", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 15 } }, + { "from": "SLM", "to": "CAPM", "item": "SLAs with agreed capacity and performance targets as a basis for identifying overall capacity and performance requirements", "listedBy": "CAPM", "source": { "doc": "FitSM-2", "section": "PR5", "page": 22 } } + ] + }, + { + "id": "ISM-SLM", + "processes": ["ISM", "SLM"], + "descriptions": [], + "flows": [ + { "from": "SLM", "to": "ISM", "item": "SLAs with agreed information security targets as a basis for identifying overall security requirements", "listedBy": "SLM", "source": { "doc": "FitSM-2", "section": "PR2", "page": 16 } }, + { "from": "SLM", "to": "ISM", "item": "SLAs with agreed information security targets as a basis for identifying overall security requirements", "listedBy": "ISM", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } } + ] + }, + { + "id": "ISRM-SLM", + "processes": ["ISRM", "SLM"], + "descriptions": [], + "flows": [ + { "from": "SLM", "to": "ISRM", "item": "SLAs containing information on agreed service targets to enable prioritisation of incidents and service requests", "listedBy": "ISRM", "source": { "doc": "FitSM-2", "section": "PR9", "page": 31 } } + ] + }, + { + "id": "SACM-SRM", + "processes": ["SACM", "SRM"], + "descriptions": [], + "flows": [ + { "from": "SACM", "to": "SRM", "item": "Service availability data as a basis for reports", "listedBy": "SRM", "source": { "doc": "FitSM-2", "section": "PR3", "page": 18 } }, + { "from": "SACM", "to": "SRM", "item": "Service availability data as a basis for reports", "listedBy": "SACM", "source": { "doc": "FitSM-2", "section": "PR4", "page": 20 } } + ] + }, + { + "id": "CAPM-SRM", + "processes": ["CAPM", "SRM"], + "descriptions": [], + "flows": [ + { "from": "CAPM", "to": "SRM", "item": "Performance and utilisation data as a basis for reports", "listedBy": "SRM", "source": { "doc": "FitSM-2", "section": "PR3", "page": 18 } }, + { "from": "CAPM", "to": "SRM", "item": "Performance and utilisation data as a basis for reports", "listedBy": "CAPM", "source": { "doc": "FitSM-2", "section": "PR5", "page": 22 } } + ] + }, + { + "id": "CRM-SRM", + "processes": ["CRM", "SRM"], + "descriptions": [], + "flows": [ + { "from": "SRM", "to": "CRM", "item": "Relevant reports as a basis for managing customer relationships and customer satisfaction", "listedBy": "SRM", "source": { "doc": "FitSM-2", "section": "PR3", "page": 18 } }, + { "from": "SRM", "to": "CRM", "item": "Relevant reports as a basis for managing customer relationships and customer satisfaction", "listedBy": "CRM", "source": { "doc": "FitSM-2", "section": "PR7", "page": 26 } } + ] + }, + { + "id": "CSI-SRM", + "processes": ["CSI", "SRM"], + "descriptions": [], + "flows": [ + { "from": "SRM", "to": "CSI", "item": "Service reports as an information basis related to opportunities for improving services and the SMS", "listedBy": "SRM", "source": { "doc": "FitSM-2", "section": "PR3", "page": 18 } }, + { "from": "SRM", "to": "CSI", "item": "Service reports as an information basis related to opportunities for improving services and the SMS", "listedBy": "CSI", "source": { "doc": "FitSM-2", "section": "PR14", "page": 42 } } + ] + }, + { + "id": "CHM-SACM", + "processes": ["CHM", "SACM"], + "descriptions": [], + "flows": [ + { "from": "SACM", "to": "CHM", "item": "Requests for change addressing required updates or modifications to CIs as a basis for implementing the measures necessary to enable the IT service environment to meet identified availability and continuity requirements", "listedBy": "SACM", "source": { "doc": "FitSM-2", "section": "PR4", "page": 20 } } + ] + }, + { + "id": "CAPM-CHM", + "processes": ["CAPM", "CHM"], + "descriptions": [], + "flows": [ + { "from": "CAPM", "to": "CHM", "item": "Request for changes addressing required updates or modifications to CIs as a basis for implementing the capacity planning to enable the IT service environment to meet identified capacity and performance requirements", "listedBy": "CAPM", "source": { "doc": "FitSM-2", "section": "PR5", "page": 22 } } + ] + }, + { + "id": "CHM-ISM", + "processes": ["CHM", "ISM"], + "descriptions": [], + "flows": [ + { "from": "ISM", "to": "CHM", "item": "Requests for changes addressing required updates or modifications to CIs as a basis for implementing the information security controls as far as they relate to CIs supporting the services", "listedBy": "ISM", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } } + ] + }, + { + "id": "CHM-CRM", + "processes": ["CHM", "CRM"], + "descriptions": [], + "flows": [ + { "from": "CRM", "to": "CHM", "item": "Requests for changes (e.g. to address insufficient customer satisfaction, feedback from service reviews or customer complaints)", "listedBy": "CRM", "source": { "doc": "FitSM-2", "section": "PR7", "page": 26 } } + ] + }, + { + "id": "CRM-CSI", + "processes": ["CRM", "CSI"], + "descriptions": [], + "flows": [ + { "from": "CRM", "to": "CSI", "item": "Suggestions for improvement (e.g. to address insufficient customer satisfaction, feedback from service reviews or customer complaints)", "listedBy": "CRM", "source": { "doc": "FitSM-2", "section": "PR7", "page": 26 } } + ] + }, + { + "id": "ISRM-PM", + "processes": ["ISRM", "PM"], + "descriptions": [], + "flows": [ + { "from": "PM", "to": "ISRM", "item": "Known error database (KEDB) containing information on known errors and related workarounds to support the resolution of incidents caused by known errors", "listedBy": "ISRM", "source": { "doc": "FitSM-2", "section": "PR9", "page": 31 } }, + { "from": "ISRM", "to": "PM", "item": "Trend information on incidents, including information from incident tickets and reports, to enable pattern and trend analysis", "listedBy": "ISRM", "source": { "doc": "FitSM-2", "section": "PR9", "page": 31 } }, + { "from": "ISRM", "to": "PM", "item": "Trend information on incidents, including information from incident tickets and reports, to enable pattern and trend analysis", "listedBy": "PM", "source": { "doc": "FitSM-2", "section": "PR10", "page": 33 } }, + { "from": "PM", "to": "ISRM", "item": "Known error database (KEDB) containing information on known errors and related workarounds to support the resolution of incidents caused by known errors", "listedBy": "PM", "source": { "doc": "FitSM-2", "section": "PR10", "page": 33 } } + ] + }, + { + "id": "CONFM-ISRM", + "processes": ["CONFM", "ISRM"], + "descriptions": [], + "flows": [ + { "from": "CONFM", "to": "ISRM", "item": "CMDB containing information on configuration items and their relationships to support the classification, prioritisation, escalation and resolution of incidents and the fulfilment of service requests", "listedBy": "ISRM", "source": { "doc": "FitSM-2", "section": "PR9", "page": 31 } } + ] + }, + { + "id": "ISRM-RDM", + "processes": ["ISRM", "RDM"], + "descriptions": [], + "flows": [ + { "from": "RDM", "to": "ISRM", "item": "Information on planned or recently deployed releases to support incident resolution (e.g. to understand if incidents are potentially related to releases)", "listedBy": "ISRM", "source": { "doc": "FitSM-2", "section": "PR9", "page": 31 } }, + { "from": "RDM", "to": "ISRM", "item": "Information on planned or recently deployed releases to support incident resolution (e.g. to understand if incidents are potentially related to releases)", "listedBy": "RDM", "source": { "doc": "FitSM-2", "section": "PR13", "page": 39 } } + ] + }, + { + "id": "CHM-ISRM", + "processes": ["CHM", "ISRM"], + "descriptions": [], + "flows": [ + { "from": "ISRM", "to": "CHM", "item": "Requests for changes required to resolve incidents or to fulfil service requests", "listedBy": "ISRM", "source": { "doc": "FitSM-2", "section": "PR9", "page": 31 } } + ] + }, + { + "id": "CONFM-PM", + "processes": ["CONFM", "PM"], + "descriptions": [], + "flows": [ + { "from": "CONFM", "to": "PM", "item": "CMDB containing information on configuration items and their relationships to support the classification, prioritisation and investigation of problems", "listedBy": "PM", "source": { "doc": "FitSM-2", "section": "PR10", "page": 33 } } + ] + }, + { + "id": "CHM-PM", + "processes": ["CHM", "PM"], + "descriptions": [], + "flows": [ + { "from": "PM", "to": "CHM", "item": "Requests for changes to resolve / eliminate problems", "listedBy": "PM", "source": { "doc": "FitSM-2", "section": "PR10", "page": 33 } } + ] + }, + { + "id": "CHM-CONFM", + "processes": ["CHM", "CONFM"], + "descriptions": [], + "flows": [ + { "from": "CHM", "to": "CONFM", "item": "Information on the deployment of releases (and the changes to CIs included in the releases) required to update the CMDB and (if necessary) introduce new CI types", "listedBy": "CONFM", "source": { "doc": "FitSM-2", "section": "PR11", "page": 35 } }, + { "from": "CHM", "to": "CONFM", "item": "Information on planned, approved and / or implemented changes to CIs to be reflected in the CMDB", "listedBy": "CHM", "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } } + ] + }, + { + "id": "CHM-RDM", + "processes": ["CHM", "RDM"], + "descriptions": [], + "flows": [ + { "from": "CHM", "to": "RDM", "item": "Approved and planned changes that are ready for deployment to be considered for future / upcoming releases (depending on defined criteria and applicable release and deployment strategies)", "listedBy": "CHM", "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } }, + { "from": "CHM", "to": "RDM", "item": "Change schedule with proposed deployment dates for planned and approved changes / Basis for planning and scheduling releases", "listedBy": "CHM", "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } }, + { "from": "CHM", "to": "RDM", "item": "Approved and planned changes that are ready for deployment to be considered for future / upcoming releases (depending on defined criteria and applicable release and deployment strategies)", "listedBy": "RDM", "source": { "doc": "FitSM-2", "section": "PR13", "page": 39 } }, + { "from": "CHM", "to": "RDM", "item": "Change schedule with proposed deployment dates for planned and approved changes / Basis for planning and scheduling releases", "listedBy": "RDM", "source": { "doc": "FitSM-2", "section": "PR13", "page": 39 } }, + { "from": "RDM", "to": "CHM", "item": "Information on deployed releases (release records) to allow for post implementation review of the bundled changes", "listedBy": "RDM", "source": { "doc": "FitSM-2", "section": "PR13", "page": 39 } } + ] + }, + { + "id": "CONFM-RDM", + "processes": ["CONFM", "RDM"], + "descriptions": [], + "flows": [ + { "from": "CONFM", "to": "RDM", "item": "Configuration information (CMDB) as a basis for informed decisions in deployment planning", "listedBy": "RDM", "source": { "doc": "FitSM-2", "section": "PR13", "page": 39 } }, + { "from": "RDM", "to": "CONFM", "item": "Information on the deployment of releases (and the changes to CIs included in the releases) required to update the CMDB and (if necessary) introduce new CI types", "listedBy": "RDM", "source": { "doc": "FitSM-2", "section": "PR13", "page": 39 } } + ] + }, + { + "id": "CHM-CSI", + "processes": ["CHM", "CSI"], + "descriptions": [], + "flows": [ + { "from": "CSI", "to": "CHM", "item": "Requests for changes to trigger the change management process, in order to implement improvements (where needed)", "listedBy": "CSI", "source": { "doc": "FitSM-2", "section": "PR14", "page": 42 } } + ] + } +] diff --git a/content/fitsm-3.0/map.json b/content/fitsm-3.0/map.json new file mode 100644 index 0000000..cdf4559 --- /dev/null +++ b/content/fitsm-3.0/map.json @@ -0,0 +1,255 @@ +{ + "note": "The lines group related processes as a study aid. They are not part of FitSM.", + "background": "#ffffff", + "transfer": { + "colour": "#8a8a8a", + "width": 4 + }, + "grid": { + "unit": 24, + "cols": 36, + "rows": 26, + "margin": { + "x": 5, + "y": 2 + } + }, + "lines": [ + { + "id": "agreements", + "name": "Agreements", + "colour": "#1565c0", + "stations": [ + "SPM", + "SLM", + "CRM", + "SUPPM" + ] + }, + { + "id": "assurance", + "name": "Assurance", + "colour": "#2e7d32", + "stations": [ + "CAPM", + "SACM", + "ISM", + "SLM" + ] + }, + { + "id": "operations", + "name": "Operations", + "colour": "#c62828", + "stations": [ + "PM", + "ISRM" + ] + }, + { + "id": "control", + "name": "Control", + "colour": "#6a1b9a", + "stations": [ + "RDM", + "CHM", + "CONFM" + ] + }, + { + "id": "reporting", + "name": "Reporting and improvement", + "colour": "#bf360c", + "stations": [ + "CSI", + "SRM" + ] + } + ], + "stations": { + "SPM": { + "x": 4, + "y": 4, + "label": "n" + }, + "SLM": { + "x": 12, + "y": 4, + "label": "n" + }, + "CRM": { + "x": 20, + "y": 4, + "label": "n" + }, + "SUPPM": { + "x": 28, + "y": 4, + "label": "n" + }, + "SRM": { + "x": 4, + "y": 10, + "label": "w" + }, + "SACM": { + "x": 12, + "y": 10, + "label": "e" + }, + "CAPM": { + "x": 20, + "y": 10, + "label": "e" + }, + "ISM": { + "x": 28, + "y": 10, + "label": "e" + }, + "ISRM": { + "x": 8, + "y": 16, + "label": "w" + }, + "PM": { + "x": 16, + "y": 16, + "label": "s" + }, + "CSI": { + "x": 34, + "y": 16, + "label": "s" + }, + "CONFM": { + "x": 12, + "y": 22, + "label": "s" + }, + "CHM": { + "x": 20, + "y": 22, + "label": "s" + }, + "RDM": { + "x": 28, + "y": 22, + "label": "s" + } + }, + "routes": { + "SACM-SLM": [], + "SLM-SPM": [], + "CRM-SLM": [], + "SACM-SRM": [], + "ISRM-PM": [], + "CHM-CONFM": [], + "CHM-RDM": [], + "CAPM-CHM": [ + [26, 16] + ], + "CRM-SPM": [ + [18, 6], + [6, 6] + ], + "SLM-SUPPM": [ + [15, 7], + [25, 7] + ], + "CAPM-SRM": [ + [18, 12], + [6, 12] + ], + "CONFM-RDM": [ + [14, 20], + [26, 20] + ], + "CHM-CRM": [ + [20, 16], + [26, 10] + ], + "SPM-SUPPM": [ + [2, 4], + [2, 1], + [24, 1], + [27, 4] + ], + "CSI-SRM": [ + [31, 16], + [23, 8], + [6, 8] + ], + "ISRM-RDM": [ + [11, 19], + [28, 19] + ], + "CHM-SPM": [ + [19, 21], + [0, 21], + [0, 8] + ], + "ISM-SLM": [ + [28, 9], + [24, 5], + [11, 5] + ], + "CRM-SRM": [ + [20, 6], + [15, 11], + [4, 11] + ], + "CRM-CSI": [ + [26, 4], + [32, 10], + [32, 14] + ], + "CHM-CSI": [ + [21, 22], + [28, 15], + [34, 15] + ], + "ISRM-SPM": [ + [8, 13], + [4, 9] + ], + "ISRM-SLM": [ + [4, 12] + ], + "CHM-SACM": [ + [19, 21], + [19, 15], + [12, 15] + ], + "CHM-ISM": [ + [21, 21], + [21, 17] + ], + "CHM-ISRM": [ + [19, 22], + [16, 25], + [8, 25] + ], + "SLM-SRM": [ + [11, 5], + [6, 5], + [3, 8], + [3, 9] + ], + "CAPM-SLM": [ + [17, 10], + [12, 5] + ], + "CONFM-ISRM": [ + [7, 17] + ], + "CONFM-PM": [ + [12, 20] + ], + "CHM-PM": [ + [21, 21], + [18, 18], + [18, 16] + ] + } +} diff --git a/content/fitsm-3.0/processes.json b/content/fitsm-3.0/processes.json new file mode 100644 index 0000000..7cdf8e6 --- /dev/null +++ b/content/fitsm-3.0/processes.json @@ -0,0 +1,248 @@ +[ + { + "code": "SPM", + "name": "Service Portfolio Management", + "requirements": "PR1", + "objective": { "text": "To maintain the service portfolio and to manage services through their lifecycle", "source": { "doc": "FitSM-2", "section": "PR1", "page": 11 } }, + "inputs": [ + { "text": "Any information indicating demand for services, including (potential) customer demand and requirements", "source": { "doc": "FitSM-2", "section": "PR1", "page": 11 } }, + { "text": "Understanding of the service provider’s resources, capabilities, limitations and constraints", "source": { "doc": "FitSM-2", "section": "PR1", "page": 11 } }, + { "text": "Information on any existing services (e.g. the current service portfolio)", "source": { "doc": "FitSM-2", "section": "PR1", "page": 11 } } + ], + "outputs": [ + { "text": "Complete and up-to-date service portfolio", "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 } }, + { "text": "Valid and consistent service specifications", "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 } }, + { "text": "Plans for new or changed services (and related requests for changes)", "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 } } + ], + "externalFlows": [] + }, + { + "code": "SLM", + "name": "Service Level Management", + "requirements": "PR2", + "objective": { "text": "To maintain service catalogues, and to define and evaluate agreements on service quality with customers and suppliers", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } }, + "inputs": [ + { "text": "Service portfolio together with service specifications", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } }, + { "text": "General and specific service level requirements", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } } + ], + "outputs": [ + { "text": "Up-to-date service catalogue covering all information that are relevant for customers", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } }, + { "text": "Default SLA and individual SLAs with customers", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } }, + { "text": "Supporting OLAs and UAs, aligned with SLAs", "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } } + ], + "externalFlows": [] + }, + { + "code": "SRM", + "name": "Service Reporting Management", + "requirements": "PR3", + "objective": { "text": "To specify reports on services and processes and ensure they are produced and delivered", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 } }, + "inputs": [ + { "text": "Reporting requirements (e.g. from SLAs)", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 } } + ], + "outputs": [ + { "text": "List of all (agreed) reports", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 } }, + { "text": "Specification of all reports", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 } }, + { "text": "Reports", "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 } } + ], + "externalFlows": [] + }, + { + "code": "SACM", + "name": "Service Availability & Continuity Management", + "requirements": "PR4", + "objective": { "text": "To ensure sufficient service availability and continuity to meet service targets", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 } }, + "inputs": [ + { "text": "Service availability and continuity requirements (e.g. from SLAs)", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 } }, + { "text": "Risk factors having impact on the capability of delivering services according to agreed availability and continuity targets", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 } } + ], + "outputs": [ + { "text": "Service availability and continuity plans", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 } }, + { "text": "Service availability data", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 } }, + { "text": "Requests for change", "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 } } + ], + "externalFlows": [] + }, + { + "code": "CAPM", + "name": "Capacity Management", + "requirements": "PR5", + "objective": { "text": "To ensure sufficient capacity and service performance to meet service targets", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } }, + "inputs": [ + { "text": "Service performance and capacity requirements (e.g. from SLAs)", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } }, + { "text": "Current level of capacities plus information on the past, current and future (predicted) utilisation of resources", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } }, + { "text": "Information on available resources and constraints", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } } + ], + "outputs": [ + { "text": "Capacity plans (reflecting demands, planned upgrades, downgrades and reallocations of resources)", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } }, + { "text": "Capacity and service performance monitoring plans / concept", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } }, + { "text": "Capacity and service performance monitoring records / reports", "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } } + ], + "externalFlows": [] + }, + { + "code": "ISM", + "name": "Information Security Management", + "requirements": "PR6", + "objective": { "text": "To preserve confidentiality, integrity and availability of information related to managing and delivering services", "source": { "doc": "FitSM-2", "section": "PR6", "page": 23 } }, + "inputs": [ + { "text": "Information security requirements (from SLAs, legislation, contracts)", "source": { "doc": "FitSM-2", "section": "PR6", "page": 23 } }, + { "text": "Assets to be protected", "source": { "doc": "FitSM-2", "section": "PR6", "page": 23 } }, + { "text": "Relevant risk factors (vulnerabilities, hazards)", "source": { "doc": "FitSM-2", "section": "PR6", "page": 23 } } + ], + "outputs": [ + { "text": "Up-to-date inventory of information assets", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } }, + { "text": "Approved information security policies", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } }, + { "text": "Up-to-date information security risk assessment", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } }, + { "text": "Documented information security controls", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } }, + { "text": "Reports on information security events, incidents and follow-up actions", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } }, + { "text": "Documented information on access rights and their reviews", "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } } + ], + "externalFlows": [] + }, + { + "code": "CRM", + "name": "Customer Relationship Management", + "requirements": "PR7", + "objective": { "text": "To establish and maintain good relationships with customers receiving services", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + "inputs": [ + { "text": "Information on service customers", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "text": "Current service catalogue", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "text": "Customer demands and requirements", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "text": "Existing SLAs with customers", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "text": "Customer complaints", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } } + ], + "outputs": [ + { "text": "Up-to-date database of service customers (customer database)", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "text": "Service review reports", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "text": "Customer complaints records", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "text": "Customer satisfaction reports", "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } } + ], + "externalFlows": [] + }, + { + "code": "SUPPM", + "name": "Supplier Relationship Management", + "requirements": "PR8", + "objective": { "text": "To establish and maintain healthy relationships with internal and external suppliers and to monitor their performance", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 } }, + "inputs": [ + { "text": "Information on suppliers", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 } }, + { "text": "Information on supplier offerings", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 } }, + { "text": "OLAs with internal suppliers", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 } }, + { "text": "UAs with external suppliers", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 } } + ], + "outputs": [ + { "text": "Up-to-date supplier database", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 } }, + { "text": "Supplier evaluation results", "source": { "doc": "FitSM-2", "section": "PR8", "page": 27 } } + ], + "externalFlows": [] + }, + { + "code": "ISRM", + "name": "Incident & Service Request Management", + "requirements": "PR9", + "objective": { "text": "To restore agreed service operation after the occurrence of an incident and to respond to user service requests", "source": { "doc": "FitSM-2", "section": "PR9", "page": 29 } }, + "inputs": [ + { "text": "Incidents reported by users or identified by the service provider", "source": { "doc": "FitSM-2", "section": "PR9", "page": 29 } }, + { "text": "Service requests raised by users", "source": { "doc": "FitSM-2", "section": "PR9", "page": 29 } }, + { "text": "Configuration information (CMDB)", "source": { "doc": "FitSM-2", "section": "PR9", "page": 29 } } + ], + "outputs": [ + { "text": "Incident records", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } }, + { "text": "Service request records", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } }, + { "text": "Major incident review reports", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } }, + { "text": "Requests for changes raised to trigger the change management process, in order to commence the fulfilment of service requests", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } }, + { "text": "Up-to-date descriptions of step-by-step workflows for standard incidents and service requests", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } }, + { "text": "Regular incident reports", "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } } + ], + "externalFlows": [] + }, + { + "code": "PM", + "name": "Problem Management", + "requirements": "PR10", + "objective": { "text": "To identify and investigate problems in order to reduce their impact or prevent them from causing further incidents", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 } }, + "inputs": [ + { "text": "Statistics on incidents and service requests (for trend analysis)", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 } }, + { "text": "Incident and service request records", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 } }, + { "text": "Other relevant sources of information to identify (new) problems, including change and release records", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 } }, + { "text": "Configuration information (CMDB)", "source": { "doc": "FitSM-2", "section": "PR10", "page": 32 } } + ], + "outputs": [ + { "text": "Up-to-date KEDB with information (records) on problems, known errors and related workarounds", "source": { "doc": "FitSM-2", "section": "PR10", "page": 33 } }, + { "text": "Requests for changes raised to trigger the change management process, in order to resolve the underlying root cause(s) of identified problems / known errors", "source": { "doc": "FitSM-2", "section": "PR10", "page": 33 } } + ], + "externalFlows": [] + }, + { + "code": "CONFM", + "name": "Configuration Management", + "requirements": "PR11", + "objective": { "text": "To provide and maintain a logical model of configuration items in support of other service management activities", "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 } }, + "inputs": [ + { "text": "Relevant information / data on configuration items (CIs) and their relationships", "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 } }, + { "text": "Information on changes to CIs", "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 } } + ], + "outputs": [ + { "text": "Up-to-date logical model of all relevant CIs and their attributes and relationships, reflected by the information / records stored in the configuration management database (CMDB)", "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 } }, + { "text": "Configuration verification reports", "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 } } + ], + "externalFlows": [ + { "direction": "out", "party": "Any", "item": "Configuration information from the CMDB to support process activities", "source": { "doc": "FitSM-2", "section": "PR11", "page": 35 } } + ] + }, + { + "code": "CHM", + "name": "Change Management", + "requirements": "PR12", + "objective": { "text": "To plan, approve and review changes in a controlled manner to avoid adverse impact on services", "source": { "doc": "FitSM-2", "section": "PR12", "page": 36 } }, + "inputs": [ + { "text": "Requests for changes (RFCs)", "source": { "doc": "FitSM-2", "section": "PR12", "page": 36 } }, + { "text": "Information on planned releases and deployments", "source": { "doc": "FitSM-2", "section": "PR12", "page": 36 } } + ], + "outputs": [ + { "text": "Change records", "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } }, + { "text": "Up-to-date schedule of changes", "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } }, + { "text": "Post implementation review reports", "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } }, + { "text": "Up-to-date list of (pre-defined) standard changes and step-by-step-workflows for handling them", "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } } + ], + "externalFlows": [ + { "direction": "in", "party": "Any", "item": "Request for change to trigger the CHM process", "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } } + ] + }, + { + "code": "RDM", + "name": "Release & Deployment Management", + "requirements": "PR13", + "objective": { "text": "To bundle changes into appropriate types of releases and to effectively deploy them", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 } }, + "inputs": [ + { "text": "Information on approved changes", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 } }, + { "text": "Change schedule", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 } }, + { "text": "Any release and deployment planning constraints or requirements", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 } } + ], + "outputs": [ + { "text": "Defined and successfully deployed releases", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 } }, + { "text": "Information / reports on the success and failure of releases", "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 } } + ], + "externalFlows": [] + }, + { + "code": "CSI", + "name": "Continual Service Improvement Management", + "requirements": "PR14", + "objective": { "text": "To plan, implement and review improvements to services and processes", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 } }, + "inputs": [ + { "text": "Suggestions for improvements", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 } }, + { "text": "Results from measurements, assessments and audits of the SMS, including: Identified nonconformities as well as deficiencies in effectiveness and efficiency of ITSM processes, and resulting opportunities for improvement; Identified deficiencies in the performance of services or supporting service components, and resulting opportunities for improvement", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 } }, + { "text": "Customer feedback from service reviews, complaints and satisfaction analysis / surveys", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 } }, + { "text": "Other sources of improvements", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 } } + ], + "outputs": [ + { "text": "Improvements to services or the SMS", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 } }, + { "text": "Requests for changes", "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 } } + ], + "externalFlows": [ + { "direction": "in", "party": "Any", "item": "Suggestions for improving services and the SMS that require control and coordination through the CSI process", "source": { "doc": "FitSM-2", "section": "PR14", "page": 42 } } + ] + } +] diff --git a/content/fitsm-3.0/records.json b/content/fitsm-3.0/records.json new file mode 100644 index 0000000..3a50365 --- /dev/null +++ b/content/fitsm-3.0/records.json @@ -0,0 +1,90 @@ +[ + { + "id": "service-portfolio", + "name": "Service portfolio", + "definition": { "text": "Internal list that details all the services offered by a service provider, including those in preparation, live and discontinued", "source": { "doc": "FitSM-0", "section": "6.69", "page": 18 } }, + "usedBy": [ + { "process": "SPM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 } } + ] + }, + { + "id": "service-catalogue", + "name": "Service catalogue", + "definition": { "text": "Customer-facing list of all live services offered along with relevant information about these services", "source": { "doc": "FitSM-0", "section": "6.62", "page": 17 } }, + "usedBy": [ + { "process": "SLM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } } + ] + }, + { + "id": "service-level-agreement", + "name": "Service level agreement (SLA)", + "definition": { "text": "Documented agreement between a customer and service provider that specifies the service to be provided and the service targets that define how it will be provided", "source": { "doc": "FitSM-0", "section": "6.64", "page": 17 } }, + "usedBy": [ + { "process": "SLM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } } + ] + }, + { + "id": "operational-level-agreement", + "name": "Operational level agreement (OLA)", + "definition": { "text": "Documented agreement between a service provider and an internal supplier that specifies the underpinning service(s) or service component(s) to be provided by the internal supplier or federation member, together with the related operational targets", "source": { "doc": "FitSM-0", "section": "6.45", "page": 14 } }, + "usedBy": [ + { "process": "SLM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } } + ] + }, + { + "id": "underpinning-agreement", + "name": "Underpinning agreement (UA)", + "definition": { "text": "Documented agreement between a service provider and an external supplier that specifies the underpinning service(s) or service component(s) to be provided by the supplier, together with the related operational targets", "source": { "doc": "FitSM-0", "section": "6.76", "page": 19 } }, + "usedBy": [ + { "process": "SLM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR2", "page": 14 } } + ] + }, + { + "id": "configuration-management-database", + "name": "Configuration management database (CMDB)", + "definition": { "text": "Store for data about configuration items (CIs)", "source": { "doc": "FitSM-0", "section": "6.16", "page": 11 } }, + "usedBy": [ + { "process": "CONFM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 } } + ] + }, + { + "id": "record", + "name": "Record", + "definition": { "text": "Documentation of an event or of the results of performing a process or activity", "source": { "doc": "FitSM-0", "section": "6.53", "page": 15 } }, + "usedBy": [ + { "process": "CAPM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } }, + { "process": "CRM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "process": "ISRM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } }, + { "process": "PM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR10", "page": 33 } }, + { "process": "CONFM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 } }, + { "process": "CHM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } } + ] + }, + { + "id": "report", + "name": "Report", + "definition": { "text": "A structured record communicating results gathered through measurement, monitoring, assessment, audit or observation", "source": { "doc": "FitSM-0", "section": "6.56", "page": 16 } }, + "usedBy": [ + { "process": "SRM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR3", "page": 17 } }, + { "process": "CAPM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR5", "page": 21 } }, + { "process": "ISM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR6", "page": 24 } }, + { "process": "CRM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR7", "page": 25 } }, + { "process": "ISRM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } }, + { "process": "CONFM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR11", "page": 34 } }, + { "process": "CHM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR12", "page": 37 } }, + { "process": "RDM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR13", "page": 38 } } + ] + }, + { + "id": "request-for-change", + "name": "Request for change (RFC)", + "definition": { "text": "Documented proposal for a change", "source": { "doc": "FitSM-0", "section": "6.57", "page": 16 } }, + "usedBy": [ + { "process": "SPM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR1", "page": 12 } }, + { "process": "SACM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR4", "page": 19 } }, + { "process": "ISRM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR9", "page": 30 } }, + { "process": "PM", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR10", "page": 33 } }, + { "process": "CSI", "basis": "output", "derived": true, "source": { "doc": "FitSM-2", "section": "PR14", "page": 41 } } + ] + } +] diff --git a/content/fitsm-3.0/requirements.json b/content/fitsm-3.0/requirements.json new file mode 100644 index 0000000..b272f5e --- /dev/null +++ b/content/fitsm-3.0/requirements.json @@ -0,0 +1,235 @@ +{ + "general": [ + { + "id": "GR1", + "name": "Top Management Commitment & Accountability (MCA)", + "source": { "doc": "FitSM-1", "section": "GR1", "page": 4 }, + "items": [ + { "id": "GR1.1", "text": "A member of top management of the service provider(s) involved in the delivery of services shall be assigned as the SMS owner to be accountable for the overall SMS.", "source": { "doc": "FitSM-1", "section": "GR1.1", "page": 4 } }, + { "id": "GR1.2", "text": "A general service management policy shall be defined that includes overall service management goals as well as a commitment to continual improvement and a service-oriented and process-oriented approach. The service management policy shall be approved and communicated to relevant parties by the SMS owner.", "source": { "doc": "FitSM-1", "section": "GR1.2", "page": 4 } }, + { "id": "GR1.3", "text": "The SMS owner shall conduct management reviews at planned intervals.", "source": { "doc": "FitSM-1", "section": "GR1.3", "page": 4 } } + ] + }, + { + "id": "GR2", + "name": "Documentation (DOC)", + "source": { "doc": "FitSM-1", "section": "GR2", "page": 4 }, + "items": [ + { "id": "GR2.1", "text": "The key elements of the SMS shall be documented to support effective planning. This documentation shall include the SMS scope statement (see GR3), the general service management policy (see GR1) as well as the service management plan and related plans (see GR4).", "source": { "doc": "FitSM-1", "section": "GR2.1", "page": 4 } }, + { "id": "GR2.2", "text": "Documented definitions of all service management processes (see PR1-PR14) shall be created and maintained. Each of these definitions shall include: Description of the goals of the process; Description of the inputs, activities and outputs of the process; Description of process-specific roles and responsibilities; Description of interfaces to other processes; Related process-specific policies as needed; Related process- and activity-specific procedures as needed.", "source": { "doc": "FitSM-1", "section": "GR2.2", "page": 4 } }, + { "id": "GR2.3", "text": "The key outputs of all service management processes (see PR1-PR14) shall be documented and the execution of key activities of these processes recorded.", "source": { "doc": "FitSM-1", "section": "GR2.3", "page": 4 } }, + { "id": "GR2.4", "text": "Documented information shall be controlled, addressing the following activities as applicable: Creation and approval; Communication and distribution; Review; Versioning and change tracking.", "source": { "doc": "FitSM-1", "section": "GR2.4", "page": 4 } } + ] + }, + { + "id": "GR3", + "name": "Scope & Stakeholders of IT Service Management (SCS)", + "source": { "doc": "FitSM-1", "section": "GR3", "page": 5 }, + "items": [ + { "id": "GR3.1", "text": "The stakeholders of the IT services and the SMS shall be identified and their needs and expectations analysed. Relevant legal, regulatory and contractual requirements shall be considered.", "source": { "doc": "FitSM-1", "section": "GR3.1", "page": 5 } }, + { "id": "GR3.2", "text": "The scope of the SMS shall be defined taking into consideration results from the stakeholder analysis.", "source": { "doc": "FitSM-1", "section": "GR3.2", "page": 5 } } + ] + }, + { + "id": "GR4", + "name": "Planning IT Service Management (PLAN)", + "source": { "doc": "FitSM-1", "section": "GR4", "page": 5 }, + "items": [ + { "id": "GR4.1", "text": "A service management plan shall be created and maintained. It shall include: Goals and timing of implementing or improving the SMS and the related processes; Roles and responsibilities; Training and awareness activities; Technology (tools) to support the SMS.", "source": { "doc": "FitSM-1", "section": "GR4.1", "page": 5 } }, + { "id": "GR4.2", "text": "Any process-specific plan shall be aligned to the overall service management plan.", "source": { "doc": "FitSM-1", "section": "GR4.2", "page": 5 } } + ] + }, + { + "id": "GR5", + "name": "Implementing IT Service Management (DO)", + "source": { "doc": "FitSM-1", "section": "GR5", "page": 5 }, + "items": [ + { "id": "GR5.1", "text": "The service management plan shall be implemented.", "source": { "doc": "FitSM-1", "section": "GR5.1", "page": 5 } }, + { "id": "GR5.2", "text": "Within the scope of the SMS, the defined service management processes shall be followed in practice, and their application, together with the adherence to related policies and procedures, shall be enforced.", "source": { "doc": "FitSM-1", "section": "GR5.2", "page": 5 } } + ] + }, + { + "id": "GR6", + "name": "Monitoring & Reviewing IT Service Management (CHECK)", + "source": { "doc": "FitSM-1", "section": "GR6", "page": 6 }, + "items": [ + { "id": "GR6.1", "text": "The effectiveness of the SMS and its service management processes shall be measured and evaluated based on suitable key performance indicators in support of defined or agreed goals.", "source": { "doc": "FitSM-1", "section": "GR6.1", "page": 6 } }, + { "id": "GR6.2", "text": "Assessments or audits of the SMS shall be conducted at planned intervals to evaluate the level of maturity and conformity.", "source": { "doc": "FitSM-1", "section": "GR6.2", "page": 6 } } + ] + }, + { + "id": "GR7", + "name": "Continually Improving Service Management (ACT)", + "source": { "doc": "FitSM-1", "section": "GR7", "page": 6 }, + "items": [ + { "id": "GR7.1", "text": "Nonconformities and deviations from goals shall be identified and actions shall be taken to prevent them from recurring.", "source": { "doc": "FitSM-1", "section": "GR7.1", "page": 6 } }, + { "id": "GR7.2", "text": "The service management policy, service management plan and all service management processes shall be subject to continual improvement. Respective improvements shall be identified, evaluated and implemented according to the Continual Service Improvement Management process (see PR14).", "source": { "doc": "FitSM-1", "section": "GR7.2", "page": 6 } } + ] + } + ], + "process": [ + { + "id": "PR1", + "process": "SPM", + "source": { "doc": "FitSM-1", "section": "PR1", "page": 7 }, + "items": [ + { "id": "PR1.1", "text": "A service portfolio shall be maintained. All services shall be specified as part of the service portfolio.", "source": { "doc": "FitSM-1", "section": "PR1.1", "page": 7 } }, + { "id": "PR1.2", "text": "Proposals for new or changed services shall be evaluated based on predicted demand, required resources and expected benefits.", "source": { "doc": "FitSM-1", "section": "PR1.2", "page": 7 } }, + { "id": "PR1.3", "text": "The evolution of services through their lifecycle shall be managed. This shall include the planning of new services and major alterations to existing services. Plans shall consider timescales, responsibilities, new or changed technology, communication and service acceptance criteria.", "source": { "doc": "FitSM-1", "section": "PR1.3", "page": 7 } }, + { "id": "PR1.4", "text": "For each service, the internal and external suppliers involved in delivering the service shall be identified, including, as relevant, federation members. Their contact points, roles and responsibilities shall be determined.", "source": { "doc": "FitSM-1", "section": "PR1.4", "page": 7 } } + ] + }, + { + "id": "PR2", + "process": "SLM", + "source": { "doc": "FitSM-1", "section": "PR2", "page": 7 }, + "items": [ + { "id": "PR2.1", "text": "A service catalogue shall be maintained.", "source": { "doc": "FitSM-1", "section": "PR2.1", "page": 7 } }, + { "id": "PR2.2", "text": "For all services delivered to customers, service level agreements (SLAs) shall be in place and reviewed at planned intervals.", "source": { "doc": "FitSM-1", "section": "PR2.2", "page": 7 } }, + { "id": "PR2.3", "text": "Service performance shall be evaluated against service targets defined in SLAs.", "source": { "doc": "FitSM-1", "section": "PR2.3", "page": 7 } }, + { "id": "PR2.4", "text": "For supporting services or service components, underpinning agreements (UAs) and operational level agreements (OLAs) shall be agreed as needed and reviewed at planned intervals.", "source": { "doc": "FitSM-1", "section": "PR2.4", "page": 7 } }, + { "id": "PR2.5", "text": "Performance of supporting services and service components shall be evaluated against targets defined in UAs and OLAs.", "source": { "doc": "FitSM-1", "section": "PR2.5", "page": 7 } } + ] + }, + { + "id": "PR3", + "process": "SRM", + "source": { "doc": "FitSM-1", "section": "PR3", "page": 8 }, + "items": [ + { "id": "PR3.1", "text": "Required reports shall be identified. Reporting shall cover performance of services and processes against defined targets, significant events and detected nonconformities.", "source": { "doc": "FitSM-1", "section": "PR3.1", "page": 8 } }, + { "id": "PR3.2", "text": "Reports shall be agreed with their recipients and specified. The specification of each report shall include its identity, purpose, audience, frequency, content, format and method of delivery.", "source": { "doc": "FitSM-1", "section": "PR3.2", "page": 8 } }, + { "id": "PR3.3", "text": "Reports shall be produced and delivered to their recipients according to specifications.", "source": { "doc": "FitSM-1", "section": "PR3.3", "page": 8 } } + ] + }, + { + "id": "PR4", + "process": "SACM", + "source": { "doc": "FitSM-1", "section": "PR4", "page": 8 }, + "items": [ + { "id": "PR4.1", "text": "Service availability and continuity requirements shall be identified and reviewed at planned intervals, taking into consideration SLAs.", "source": { "doc": "FitSM-1", "section": "PR4.1", "page": 8 } }, + { "id": "PR4.2", "text": "Service availability and continuity risks shall be assessed at planned intervals.", "source": { "doc": "FitSM-1", "section": "PR4.2", "page": 8 } }, + { "id": "PR4.3", "text": "Appropriate measures shall be taken to reduce the probability and impact of identified availability and continuity risks and meet identified requirements.", "source": { "doc": "FitSM-1", "section": "PR4.3", "page": 8 } }, + { "id": "PR4.4", "text": "Availability of services and service components shall be monitored.", "source": { "doc": "FitSM-1", "section": "PR4.4", "page": 8 } } + ] + }, + { + "id": "PR5", + "process": "CAPM", + "source": { "doc": "FitSM-1", "section": "PR5", "page": 8 }, + "items": [ + { "id": "PR5.1", "text": "Service capacity and performance requirements shall be identified and reviewed at planned intervals, taking into consideration SLAs and predicted demand.", "source": { "doc": "FitSM-1", "section": "PR5.1", "page": 8 } }, + { "id": "PR5.2", "text": "Current capacity and utilisation shall be identified.", "source": { "doc": "FitSM-1", "section": "PR5.2", "page": 8 } }, + { "id": "PR5.3", "text": "Future capacity shall be planned to meet identified requirements, considering human, technical and financial resources.", "source": { "doc": "FitSM-1", "section": "PR5.3", "page": 8 } }, + { "id": "PR5.4", "text": "Performance of services and service components shall be analysed based on monitoring the degree of capacity utilisation and identifying operational warnings and exceptions.", "source": { "doc": "FitSM-1", "section": "PR5.4", "page": 8 } } + ] + }, + { + "id": "PR6", + "process": "ISM", + "source": { "doc": "FitSM-1", "section": "PR6", "page": 9 }, + "items": [ + { "id": "PR6.1", "text": "Information security requirements shall be identified and information security policies defined and reviewed at planned intervals.", "source": { "doc": "FitSM-1", "section": "PR6.1", "page": 9 } }, + { "id": "PR6.2", "text": "Information security risks shall be assessed at planned intervals.", "source": { "doc": "FitSM-1", "section": "PR6.2", "page": 9 } }, + { "id": "PR6.3", "text": "Physical, technical and organisational information security controls shall be implemented to reduce the probability and impact of identified information security risks and meet identified requirements.", "source": { "doc": "FitSM-1", "section": "PR6.3", "page": 9 } }, + { "id": "PR6.4", "text": "Information security events and incidents shall be handled in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR6.4", "page": 9 } }, + { "id": "PR6.5", "text": "Access control, including provisioning of access rights, shall be carried out in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR6.5", "page": 9 } } + ] + }, + { + "id": "PR7", + "process": "CRM", + "source": { "doc": "FitSM-1", "section": "PR7", "page": 9 }, + "items": [ + { "id": "PR7.1", "text": "Service customers shall be identified.", "source": { "doc": "FitSM-1", "section": "PR7.1", "page": 9 } }, + { "id": "PR7.2", "text": "For each customer, there shall be a designated contact responsible for managing the relationship with them.", "source": { "doc": "FitSM-1", "section": "PR7.2", "page": 9 } }, + { "id": "PR7.3", "text": "Channels used to communicate with each customer, including mechanisms for service ordering, escalation and complaint shall be established.", "source": { "doc": "FitSM-1", "section": "PR7.3", "page": 9 } }, + { "id": "PR7.4", "text": "Service reviews with customers shall be conducted at planned intervals.", "source": { "doc": "FitSM-1", "section": "PR7.4", "page": 9 } }, + { "id": "PR7.5", "text": "Service complaints from customers shall be handled in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR7.5", "page": 9 } }, + { "id": "PR7.6", "text": "Customer satisfaction shall be managed.", "source": { "doc": "FitSM-1", "section": "PR7.6", "page": 9 } } + ] + }, + { + "id": "PR8", + "process": "SUPPM", + "source": { "doc": "FitSM-1", "section": "PR8", "page": 9 }, + "items": [ + { "id": "PR8.1", "text": "Internal and external suppliers shall be identified.", "source": { "doc": "FitSM-1", "section": "PR8.1", "page": 9 } }, + { "id": "PR8.2", "text": "For each supplier, there shall be a designated contact responsible for managing the relationship with them.", "source": { "doc": "FitSM-1", "section": "PR8.2", "page": 9 } }, + { "id": "PR8.3", "text": "Channels used to communicate with each supplier, including escalation mechanisms, shall be established.", "source": { "doc": "FitSM-1", "section": "PR8.3", "page": 9 } }, + { "id": "PR8.4", "text": "Suppliers shall be evaluated at planned intervals.", "source": { "doc": "FitSM-1", "section": "PR8.4", "page": 9 } } + ] + }, + { + "id": "PR9", + "process": "ISRM", + "source": { "doc": "FitSM-1", "section": "PR9", "page": 10 }, + "items": [ + { "id": "PR9.1", "text": "All incidents and service requests shall be registered, classified and prioritised in a consistent manner, taking into account service targets from SLAs.", "source": { "doc": "FitSM-1", "section": "PR9.1", "page": 10 } }, + { "id": "PR9.2", "text": "Incidents shall be resolved and service requests fulfilled, taking into consideration information from SLAs and on known errors, as relevant.", "source": { "doc": "FitSM-1", "section": "PR9.2", "page": 10 } }, + { "id": "PR9.3", "text": "Functional and hierarchical escalation of incidents and service requests shall be carried out in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR9.3", "page": 10 } }, + { "id": "PR9.4", "text": "Customers and users shall be kept informed of the progress of incidents and service requests, as appropriate.", "source": { "doc": "FitSM-1", "section": "PR9.4", "page": 10 } }, + { "id": "PR9.5", "text": "Closure of incidents and service requests shall be carried out in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR9.5", "page": 10 } }, + { "id": "PR9.6", "text": "Major incidents shall be identified based on defined criteria, and handled in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR9.6", "page": 10 } } + ] + }, + { + "id": "PR10", + "process": "PM", + "source": { "doc": "FitSM-1", "section": "PR10", "page": 10 }, + "items": [ + { "id": "PR10.1", "text": "Problems shall be identified and registered in a consistent manner, based on analysing patterns and trends in the occurrence of incidents.", "source": { "doc": "FitSM-1", "section": "PR10.1", "page": 10 } }, + { "id": "PR10.2", "text": "Problems shall be investigated to identify actions to resolve them or reduce their impact on services.", "source": { "doc": "FitSM-1", "section": "PR10.2", "page": 10 } }, + { "id": "PR10.3", "text": "If a problem is not permanently resolved, a known error shall be registered together with actions such as effective workarounds and temporary fixes.", "source": { "doc": "FitSM-1", "section": "PR10.3", "page": 10 } }, + { "id": "PR10.4", "text": "Up-to-date information on known errors and effective workarounds shall be maintained.", "source": { "doc": "FitSM-1", "section": "PR10.4", "page": 10 } } + ] + }, + { + "id": "PR11", + "process": "CONFM", + "source": { "doc": "FitSM-1", "section": "PR11", "page": 11 }, + "items": [ + { "id": "PR11.1", "text": "The scope of configuration management shall be defined together with the types of configuration items (CIs) and relationships to be considered.", "source": { "doc": "FitSM-1", "section": "PR11.1", "page": 11 } }, + { "id": "PR11.2", "text": "The level of detail of configuration information shall be sufficient to support effective control over CIs.", "source": { "doc": "FitSM-1", "section": "PR11.2", "page": 11 } }, + { "id": "PR11.3", "text": "Information on CIs and their relationships with other CIs shall be maintained in a configuration management database (CMDB).", "source": { "doc": "FitSM-1", "section": "PR11.3", "page": 11 } }, + { "id": "PR11.4", "text": "CIs shall be controlled and changes to CIs tracked in the CMDB.", "source": { "doc": "FitSM-1", "section": "PR11.4", "page": 11 } }, + { "id": "PR11.5", "text": "The information stored in the CMDB shall be verified at planned intervals.", "source": { "doc": "FitSM-1", "section": "PR11.5", "page": 11 } } + ] + }, + { + "id": "PR12", + "process": "CHM", + "source": { "doc": "FitSM-1", "section": "PR12", "page": 11 }, + "items": [ + { "id": "PR12.1", "text": "All changes shall be registered and classified in a consistent manner. Classification shall be based on defined criteria and consider different types of changes, including emergency changes and major changes.", "source": { "doc": "FitSM-1", "section": "PR12.1", "page": 11 } }, + { "id": "PR12.2", "text": "For each type of change, steps shall be defined for handling them in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR12.2", "page": 11 } }, + { "id": "PR12.3", "text": "Changes shall be assessed in a consistent manner, taking into consideration benefits, risks, potential impact, effort and technical feasibility.", "source": { "doc": "FitSM-1", "section": "PR12.3", "page": 11 } }, + { "id": "PR12.4", "text": "Changes shall be approved in a consistent manner. The required level of approval shall be determined based on defined criteria.", "source": { "doc": "FitSM-1", "section": "PR12.4", "page": 11 } }, + { "id": "PR12.5", "text": "Changes shall be subject to a post implementation review as needed, and closed in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR12.5", "page": 11 } }, + { "id": "PR12.6", "text": "A schedule of changes shall be maintained. It shall contain details of approved changes and intended deployment dates, which shall be communicated to interested parties.", "source": { "doc": "FitSM-1", "section": "PR12.6", "page": 11 } } + ] + }, + { + "id": "PR13", + "process": "RDM", + "source": { "doc": "FitSM-1", "section": "PR13", "page": 12 }, + "items": [ + { "id": "PR13.1", "text": "Release and deployment strategies shall be defined, together with the service components and CIs to which they are applied. Strategies shall be aligned with the frequency and impact of releases as well as the technology supporting deployment.", "source": { "doc": "FitSM-1", "section": "PR13.1", "page": 12 } }, + { "id": "PR13.2", "text": "Criteria for including approved changes in a release shall be defined, taking into consideration the applicable release and deployment strategy.", "source": { "doc": "FitSM-1", "section": "PR13.2", "page": 12 } }, + { "id": "PR13.3", "text": "Deployment of releases shall be planned, including acceptance criteria, as needed.", "source": { "doc": "FitSM-1", "section": "PR13.3", "page": 12 } }, + { "id": "PR13.4", "text": "Releases shall be built, tested and evaluated against acceptance criteria prior to being deployed. The extent of release testing shall be appropriate to the type of release and its potential impact on services.", "source": { "doc": "FitSM-1", "section": "PR13.4", "page": 12 } }, + { "id": "PR13.5", "text": "Deployment preparation shall consider steps to be taken in case of unsuccessful deployment.", "source": { "doc": "FitSM-1", "section": "PR13.5", "page": 12 } }, + { "id": "PR13.6", "text": "Deployment activities shall be evaluated for success or failure.", "source": { "doc": "FitSM-1", "section": "PR13.6", "page": 12 } } + ] + }, + { + "id": "PR14", + "process": "CSI", + "source": { "doc": "FitSM-1", "section": "PR14", "page": 12 }, + "items": [ + { "id": "PR14.1", "text": "Opportunities for improvement of services and processes shall be identified and registered, based on reports as well as results from measurements, assessments and audits of the SMS.", "source": { "doc": "FitSM-1", "section": "PR14.1", "page": 12 } }, + { "id": "PR14.2", "text": "Opportunities for improvement shall be assessed to decide on necessary actions.", "source": { "doc": "FitSM-1", "section": "PR14.2", "page": 12 } }, + { "id": "PR14.3", "text": "The implementation of actions for improvement shall be controlled in a consistent manner.", "source": { "doc": "FitSM-1", "section": "PR14.3", "page": 12 } } + ] + } + ] +} diff --git a/content/fitsm-3.0/roles.json b/content/fitsm-3.0/roles.json new file mode 100644 index 0000000..0b1867d --- /dev/null +++ b/content/fitsm-3.0/roles.json @@ -0,0 +1,1791 @@ +{ + "generic": { + "owner": { + "name": "Process owner", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 8 + }, + "tasks": [ + "Act as the primary contact point for concerns in the context of governing one specific ITSM process.", + "Define and approve goals and policies in the context of the process according to the overall SMS goals and policies.", + "Nominate the process manager, and ensure they are competent to fulfil this role.", + "Approve changes / improvements to the operational process, such as (significant) changes to the process definition.", + "Decide on the provision of resources dedicated to the process and its activities.", + "Based on process monitoring and reviews, decide on necessary changes in the process-specific goals, policies and provided resources." + ] + }, + "manager": { + "name": "Process manager", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 8 + }, + "tasks": [ + "Act as the primary contact point for operational concerns in the context of the process.", + "Maintain the process definition / description and ensure it is available to relevant persons.", + "Maintain an adequate level of awareness and competence of the people involved in the process.", + "Monitor and keep track of the process execution and results (incl. process reviews).", + "Manage risks that involve this process (unless there is a process-specific role that manages risks in this context).", + "Report on process performance to the process owner.", + "Escalate to the process owner, if necessary.", + "Identify opportunities for improving the effectiveness and efficiency of the process.", + "Additional tasks – depending on the specific process (see process-specific role models)." + ] + }, + "case-owner": { + "name": "Case owner", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [ + "Overall responsibility for one specific case occurring in a process context (e.g. one specific incident to be resolved).", + "Act as the primary contact point for all concerns in the context of that specific case.", + "Coordinate all activities required to handle / resolve the specific case.", + "Escalate exceptions to the process manager, where required.", + "Additional tasks – depending on the specific process (see process-specific role models)." + ] + }, + "staff": { + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [ + "Carry out tasks according to the defined / established process and, as applicable, its activities and procedures (e.g. the procedure of prioritizing an incident).", + "Report to case owners and / or process managers, as appropriate.", + "Contribute to the effectiveness and continual improvement of the process." + ] + } + }, + "roles": [ + { + "id": "SPM.owner", + "process": "SPM", + "kind": "owner", + "name": "Process owner SPM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 9 + }, + "tasks": [] + }, + { + "id": "SPM.manager", + "process": "SPM", + "kind": "manager", + "name": "Process manager SPM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 9 + }, + "tasks": [ + { + "text": "Maintain the service portfolio.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 9 + } + }, + { + "text": "Manage updates to the service portfolio.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 9 + } + }, + { + "text": "Ensure the lifecycle of new or changed services are managed and appropriate plans are created and maintained.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 9 + } + }, + { + "text": "Review the service portfolio at planned intervals.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + } + } + ] + }, + { + "id": "SPM.service-owner", + "process": "SPM", + "kind": "case-owner", + "name": "Case owner: Service owner", + "count": "1 per service", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + }, + "tasks": [ + { + "text": "Overall responsibility for one specific service that is part of the service portfolio.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + } + }, + { + "text": "Act as the primary contact point for all (process-independent) concerns in the context of that specific service.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + } + }, + { + "text": "Act as an “expert” for the service in both technical and non-technical concerns.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + } + }, + { + "text": "Maintain the core service documentation, such as the service specification / description.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + } + }, + { + "text": "Be kept informed of every event, situation or change connected to the service.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + } + }, + { + "text": "Be involved in tasks significantly related to the service as part of selected ITSM processes, in particular SPM and SLM (see process-level role templates).", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + } + }, + { + "text": "Report on the service to the SMS owner.", + "source": { + "doc": "FitSM-3", + "section": "6.1", + "page": 10 + } + } + ] + }, + { + "id": "SPM.staff", + "process": "SPM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "SLM.owner", + "process": "SLM", + "kind": "owner", + "name": "Process owner SLM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 10 + }, + "tasks": [] + }, + { + "id": "SLM.manager", + "process": "SLM", + "kind": "manager", + "name": "Process manager SLM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 10 + }, + "tasks": [ + { + "text": "Maintain the service catalogue.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 10 + } + }, + { + "text": "Manage updates to the service catalogue.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 10 + } + }, + { + "text": "Ensure the service catalogue is aligned with the service portfolio.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 10 + } + }, + { + "text": "Negotiate SLAs with customers.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 10 + } + }, + { + "text": "Propose and negotiate OLAs with internal groups or federation members.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 10 + } + }, + { + "text": "Propose and negotiate UAs with external suppliers.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 10 + } + }, + { + "text": "Ensure that all SLAs, OLAs and UAs are documented in a consistent manner e.g. through maintaining agreement templates.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + } + }, + { + "text": "Approve new or changed SLAs, OLAs and UAs.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + } + }, + { + "text": "Ensure SLAs, OLAs and UAs are aligned to each other.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + } + } + ] + }, + { + "id": "SLM.agreement-owner", + "process": "SLM", + "kind": "case-owner", + "name": "Case owner: SLA / OLA / UA owner", + "count": "1 per SLA, OLA and UA", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + }, + "tasks": [ + { + "text": "Maintain the SLA, OLA or UA under their ownership and ensure it is specified and documented according to relevant specifications.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + } + }, + { + "text": "Evaluate the fulfilment of the SLA, OLA or UA.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + } + }, + { + "text": "Ensure that violations of the targets defined in the SLA, OLA or UA are identified and investigated to prevent future recurrence.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + } + }, + { + "text": "Perform regular reviews of the SLA, OLA or UA.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + } + }, + { + "text": "Understand new or changed requirements on the SLA, OLA or UA under their ownership, and initiate necessary updates or other follow-up actions.", + "source": { + "doc": "FitSM-3", + "section": "6.2", + "page": 11 + } + } + ] + }, + { + "id": "SLM.staff", + "process": "SLM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "SRM.owner", + "process": "SRM", + "kind": "owner", + "name": "Process owner SRM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 11 + }, + "tasks": [] + }, + { + "id": "SRM.manager", + "process": "SRM", + "kind": "manager", + "name": "Process manager SRM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 11 + }, + "tasks": [ + { + "text": "Maintain the list of reports.", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 11 + } + }, + { + "text": "Review report specifications in regular intervals.", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 11 + } + }, + { + "text": "Monitor the production of accurate reports according to specifications.", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 11 + } + } + ] + }, + { + "id": "SRM.report-owner", + "process": "SRM", + "kind": "case-owner", + "name": "Case owner: Report owner", + "count": "1 per report", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 11 + }, + "tasks": [ + { + "text": "Maintain the report specification for the report under their ownership.", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 11 + } + }, + { + "text": "Produce and deliver the report according to the specification.", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 11 + } + }, + { + "text": "Ensure that the input / contributions required to produce the report is provided in time.", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 12 + } + }, + { + "text": "Understand new or changed requirements on the report under their ownership and update the report specification accordingly.", + "source": { + "doc": "FitSM-3", + "section": "6.3", + "page": 12 + } + } + ] + }, + { + "id": "SRM.staff", + "process": "SRM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "SACM.owner", + "process": "SACM", + "kind": "owner", + "name": "Process owner SACM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + }, + "tasks": [] + }, + { + "id": "SACM.manager", + "process": "SACM", + "kind": "manager", + "name": "Process manager SACM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + }, + "tasks": [ + { + "text": "Identify service availability and continuity requirements.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + } + }, + { + "text": "Ensure that the input / contributions required to produce service availability and continuity plans are provided by relevant parties.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + } + }, + { + "text": "Produce, maintain and review all service availability and continuity plans regularly.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + } + }, + { + "text": "Ensure that measures to increase service availability and continuity (according to plans) are planned and implemented under the control of the change management process.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + } + }, + { + "text": "Act as a contact point in case of questions regarding service availability and continuity requirements and measures.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + } + } + ] + }, + { + "id": "SACM.plan-owner", + "process": "SACM", + "kind": "case-owner", + "name": "Case owner: Availability plan owner / continuity plan owner", + "count": "1 per availability plan / continuity plan", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + }, + "tasks": [ + { + "text": "Create and maintain the availability or continuity plan under their ownership.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + } + }, + { + "text": "Ensure that relevant stakeholders in the context of the plan are consulted and informed when creating, updating or implementing the plan.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + } + }, + { + "text": "Ensure the plan and any updates to it are approved according by relevant authorities.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 12 + } + }, + { + "text": "Based on the contents of the final / approved plan, raise requests for changes or trigger the continual service improvement process, as required.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 13 + } + }, + { + "text": "In case of a continuity plan: Ensure that the needs for testing the plan are identified and tests of preventive or reactive measures are performed regularly.", + "source": { + "doc": "FitSM-3", + "section": "6.4", + "page": 13 + } + } + ] + }, + { + "id": "SACM.staff", + "process": "SACM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "CAPM.owner", + "process": "CAPM", + "kind": "owner", + "name": "Process owner CAPM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + }, + "tasks": [] + }, + { + "id": "CAPM.manager", + "process": "CAPM", + "kind": "manager", + "name": "Process manager CAPM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + }, + "tasks": [ + { + "text": "Identify service performance and capacity requirements.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + } + }, + { + "text": "Ensure that the input / contributions required to produce capacity plans are provided by relevant parties.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + } + }, + { + "text": "Produce, maintain and review capacity plans regularly.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + } + }, + { + "text": "Ensure that measures to increase service performance and capacity (according to plans) are planned and implemented under the control of the change management process.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + } + }, + { + "text": "Act as a contact point in case of questions regarding service performance and capacity requirements and measures.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + } + } + ] + }, + { + "id": "CAPM.capacity-plan-owner", + "process": "CAPM", + "kind": "case-owner", + "name": "Case owner: Capacity plan owner", + "count": "1 per capacity plan", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + }, + "tasks": [ + { + "text": "Create and maintain the capacity plan under their ownership.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + } + }, + { + "text": "Ensure that relevant stakeholders in the context of the plan are consulted and informed when creating, updating or implementing the plan.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 13 + } + }, + { + "text": "Ensure the plan and any updates to it are approved according by relevant authorities.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 14 + } + }, + { + "text": "Based on the contents of the final / approved plan, raise requests for changes or trigger the CSI process, as required.", + "source": { + "doc": "FitSM-3", + "section": "6.5", + "page": 14 + } + } + ] + }, + { + "id": "CAPM.staff", + "process": "CAPM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "ISM.owner", + "process": "ISM", + "kind": "owner", + "name": "Process owner ISM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + }, + "tasks": [] + }, + { + "id": "ISM.manager", + "process": "ISM", + "kind": "manager", + "name": "Process manager ISM (Information security manager / officer)", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + }, + "tasks": [ + { + "text": "Act as the primary contact of the service provider for all information security-related issues.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + } + }, + { + "text": "Monitor the status and progress of all activities connected to the process of information security management, in particular, the assessment and treatment of information security risks and handling of information security events and incidents.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + } + }, + { + "text": "Ensure that information security incidents are detected and classified as such and as quickly as possible handled in an effective way to minimise harm caused by them.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + } + }, + { + "text": "Ensure that all security-related documentation is maintained and up to date.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + } + }, + { + "text": "Ensure that security risks and controls are assigned to case owners.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + } + } + ] + }, + { + "id": "ISM.security-risk-owner", + "process": "ISM", + "kind": "case-owner", + "name": "Case owner: Security risk owner", + "count": "1 per security risk", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + }, + "tasks": [ + { + "text": "Maintain and review the specification / documentation of a specific security risk.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + } + }, + { + "text": "Act as a primary contact point and expert for the risk under their ownership.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 14 + } + } + ] + }, + { + "id": "ISM.security-control-owner", + "process": "ISM", + "kind": "case-owner", + "name": "Case owner: Security control owner", + "count": "1 per security control", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 15 + }, + "tasks": [ + { + "text": "Maintain and review the specification / documentation of a specific security control.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 15 + } + }, + { + "text": "Act as a primary contact point and expert for the control under their ownership.", + "source": { + "doc": "FitSM-3", + "section": "6.6", + "page": 15 + } + } + ] + }, + { + "id": "ISM.staff", + "process": "ISM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "CRM.owner", + "process": "CRM", + "kind": "owner", + "name": "Process owner CRM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + }, + "tasks": [] + }, + { + "id": "CRM.manager", + "process": "CRM", + "kind": "manager", + "name": "Process manager CRM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + }, + "tasks": [ + { + "text": "Maintain the customer database.", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + } + }, + { + "text": "Ensure that customer complaints are handled according to the process.", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + } + }, + { + "text": "Coordinate customer satisfaction surveys.", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + } + }, + { + "text": "Review the results from customer service reviews.", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + } + } + ] + }, + { + "id": "CRM.customer-relationship-manager", + "process": "CRM", + "kind": "case-owner", + "name": "Case owner: Customer relationship manager (Account manager)", + "count": "1 per identified customer", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + }, + "tasks": [ + { + "text": "Act as the primary contact point for a specific customer.", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + } + }, + { + "text": "Maintain the relationship with that customer by regular communication.", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + } + }, + { + "text": "Process formal customer complaints.", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + } + }, + { + "text": "Conduct, moderate and record customer service reviews.", + "source": { + "doc": "FitSM-3", + "section": "6.7", + "page": 15 + } + } + ] + }, + { + "id": "CRM.staff", + "process": "CRM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "SUPPM.owner", + "process": "SUPPM", + "kind": "owner", + "name": "Process owner SUPPM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.8", + "page": 16 + }, + "tasks": [] + }, + { + "id": "SUPPM.manager", + "process": "SUPPM", + "kind": "manager", + "name": "Process manager SUPPM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.8", + "page": 16 + }, + "tasks": [ + { + "text": "Maintain the supplier database.", + "source": { + "doc": "FitSM-3", + "section": "6.8", + "page": 16 + } + }, + { + "text": "Ensure that supplier performance is monitored according to the process.", + "source": { + "doc": "FitSM-3", + "section": "6.8", + "page": 16 + } + } + ] + }, + { + "id": "SUPPM.supplier-relationship-manager", + "process": "SUPPM", + "kind": "case-owner", + "name": "Case owner: Supplier relationship manager", + "count": "1 per identified supplier", + "source": { + "doc": "FitSM-3", + "section": "6.8", + "page": 16 + }, + "tasks": [ + { + "text": "Act as the primary contact point for a specific supplier.", + "source": { + "doc": "FitSM-3", + "section": "6.8", + "page": 16 + } + }, + { + "text": "Maintain the relationship with that supplier by regular communication.", + "source": { + "doc": "FitSM-3", + "section": "6.8", + "page": 16 + } + }, + { + "text": "Maintain mechanisms for monitoring the performance of the supplier.", + "source": { + "doc": "FitSM-3", + "section": "6.8", + "page": 16 + } + } + ] + }, + { + "id": "SUPPM.staff", + "process": "SUPPM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "ISRM.owner", + "process": "ISRM", + "kind": "owner", + "name": "Process owner ISRM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 16 + }, + "tasks": [] + }, + { + "id": "ISRM.manager", + "process": "ISRM", + "kind": "manager", + "name": "Process manager ISRM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 16 + }, + "tasks": [ + { + "text": "Ensure that all incidents and service requests are recorded, and that records are of sufficient quality to enable traceability and long-term analysis.", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 16 + } + }, + { + "text": "Monitor the overall progress of incident resolution and service request fulfilment and identify potential violations of target response and resolution times.", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 16 + } + } + ] + }, + { + "id": "ISRM.incident-owner", + "process": "ISRM", + "kind": "case-owner", + "name": "Case owner: Incident owner / service request owner", + "count": "1 per incident / service request", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 17 + }, + "tasks": [ + { + "text": "Coordinate and take over overall responsibility for all activities in the lifecycle of a specific incident or service request.", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 17 + } + }, + { + "text": "Monitor the progress of incident resolution or request fulfilment taking into account agreed timeframes.", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 17 + } + }, + { + "text": "Trigger reminders to those involved in incident resolution or request fulfilment and escalate to the process manager as required.", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 17 + } + }, + { + "text": "In case of a (potential) SLA violation, trigger communication and escalation as defined in the SLM process.", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 17 + } + }, + { + "text": "Ensure an adequate level of documentation for the specific incident or service request.", + "source": { + "doc": "FitSM-3", + "section": "6.9", + "page": 17 + } + } + ] + }, + { + "id": "ISRM.staff", + "process": "ISRM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "PM.owner", + "process": "PM", + "kind": "owner", + "name": "Process owner PM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 17 + }, + "tasks": [] + }, + { + "id": "PM.manager", + "process": "PM", + "kind": "manager", + "name": "Process manager PM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 17 + }, + "tasks": [ + { + "text": "Ensure that incident trends are regularly analysed to identify problems.", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 17 + } + }, + { + "text": "Ensure that identified problems are recorded, and that records are of sufficient quality.", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 17 + } + }, + { + "text": "Ensure that problems are analysed, information on known errors recorded and problems brought to closure.", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 17 + } + } + ] + }, + { + "id": "PM.problem-owner", + "process": "PM", + "kind": "case-owner", + "name": "Case owner: Problem owner", + "count": "1 per problem", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 17 + }, + "tasks": [ + { + "text": "Coordinate and take over overall responsibility for all activities in the lifecycle of a specific problem, including problem analysis and identification of options to handle the problem.", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 17 + } + }, + { + "text": "Monitor the progress of problem resolution and ensure that the problem is escalated effectively, if required.", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 18 + } + }, + { + "text": "Ensure the information in the KEDB on this problem / known error are up to date, including appropriate descriptions of potential workarounds.", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 18 + } + }, + { + "text": "Communicate the problem / known error and potential workarounds to relevant stakeholders (e.g. ISRM staff and users).", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 18 + } + }, + { + "text": "Depending on the selected option for dealing with the problem / known error, raise requests for changes or trigger the CSI process as required.", + "source": { + "doc": "FitSM-3", + "section": "6.10", + "page": 18 + } + } + ] + }, + { + "id": "PM.staff", + "process": "PM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "CONFM.owner", + "process": "CONFM", + "kind": "owner", + "name": "Process owner CONFM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + }, + "tasks": [] + }, + { + "id": "CONFM.manager", + "process": "CONFM", + "kind": "manager", + "name": "Process manager CONFM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + }, + "tasks": [ + { + "text": "Maintain and periodically review the scope and granularity of the CMDB.", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + } + }, + { + "text": "Maintain the definitions of all CI and relationship types.", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + } + }, + { + "text": "Plan regular verifications of the configuration information held in the CMDB.", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + } + }, + { + "text": "Ensure that configuration verifications are conducted and identified nonconformities addressed.", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + } + } + ] + }, + { + "id": "CONFM.ci-owner", + "process": "CONFM", + "kind": "case-owner", + "name": "Case owner: CI owner", + "count": "1 per CI", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + }, + "tasks": [ + { + "text": "Ensure that the information on a specific CI in the CMDB is accurate and up to date.", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + } + }, + { + "text": "Collaborate with the process manager and other CI owners to ensure that all information on the relationships from / to a specific CI are accurate and up to date.", + "source": { + "doc": "FitSM-3", + "section": "6.11", + "page": 18 + } + } + ] + }, + { + "id": "CONFM.staff", + "process": "CONFM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "CHM.owner", + "process": "CHM", + "kind": "owner", + "name": "Process owner CHM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + }, + "tasks": [] + }, + { + "id": "CHM.manager", + "process": "CHM", + "kind": "manager", + "name": "Process manager CHM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + }, + "tasks": [ + { + "text": "Plan, schedule, prepare and moderate change advisory board (CAB) meetings.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + }, + { + "text": "Maintain the list and descriptions of standard changes, together with relevant technical experts.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + }, + { + "text": "Ensure that all requests for changes are processed effectively, and in a timely manner.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + }, + { + "text": "Monitor the overall progress of change evaluation, approval and implementation.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + }, + { + "text": "Review the change records in regular intervals, to identify trends or nonconformities or poor documentation / traceability.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + } + ] + }, + { + "id": "CHM.change-owner", + "process": "CHM", + "kind": "case-owner", + "name": "Case owner: Change owner", + "count": "1 per change", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + }, + "tasks": [ + { + "text": "Control and coordinate all activities in the lifecycle of a specific change.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + }, + { + "text": "Monitor the progress of change evaluation and implementation for this change.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + }, + { + "text": "Ensure that the change record is complete and up to date at any time from recording the request for change to completion of the post implementation review.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + }, + { + "text": "As applicable, communicate with the Release owner of the release containing this change.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 19 + } + } + ] + }, + { + "id": "CHM.cab", + "process": "CHM", + "kind": "specific", + "name": "Change advisory board (CAB)", + "count": "1 board for a certain number of changes", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 20 + }, + "tasks": [ + { + "text": "Evaluate non-standard changes, taking into account at least: Benefits; Risks; Potential impact; Technical feasibility; Effort / cost.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 20 + } + }, + { + "text": "Decide on the approval of non-standard changes, based on the evaluation results.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 20 + } + }, + { + "text": "Decide which changes can be considered pre-approved in the future.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 20 + } + }, + { + "text": "Important notes: The CAB should be composed of (all) relevant stakeholders of the changes that are currently subject to evaluation and approval.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 20 + } + }, + { + "text": "Important notes: CAB meetings should take place at regular intervals, although the specific composition of the CAB may / will vary.", + "source": { + "doc": "FitSM-3", + "section": "6.12", + "page": 20 + } + } + ] + }, + { + "id": "CHM.staff", + "process": "CHM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "RDM.owner", + "process": "RDM", + "kind": "owner", + "name": "Process owner RDM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 20 + }, + "tasks": [] + }, + { + "id": "RDM.manager", + "process": "RDM", + "kind": "manager", + "name": "Process manager RDM", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 20 + }, + "tasks": [ + { + "text": "Maintain the overall release planning, including release cycles.", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 20 + } + }, + { + "text": "Manage the release and deployment strategies defined for the SMS.", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 20 + } + }, + { + "text": "Apply the release and deployment strategies to defined groups of components, as appropriate.", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 20 + } + }, + { + "text": "Review deployed releases for success.", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 20 + } + } + ] + }, + { + "id": "RDM.release-owner", + "process": "RDM", + "kind": "case-owner", + "name": "Case owner: Release owner", + "count": "1 per release", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 21 + }, + "tasks": [ + { + "text": "Identify the appropriate release and deployment strategy for a specific release.", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 21 + } + }, + { + "text": "Control and coordinate the activities in the lifecycle of a specific release, including planning, building, testing and deploying.", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 21 + } + }, + { + "text": "Ensure that the required documentation of the release (including release plans) is complete and of adequate quality.", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 21 + } + }, + { + "text": "Act as a single point of contact for the release for all stakeholders of this release, including the change manager, affected change owners, developers, problem manager and customer representatives.", + "source": { + "doc": "FitSM-3", + "section": "6.13", + "page": 21 + } + } + ] + }, + { + "id": "RDM.staff", + "process": "RDM", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + }, + { + "id": "CSI.owner", + "process": "CSI", + "kind": "owner", + "name": "Process owner CSI", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.14", + "page": 21 + }, + "tasks": [] + }, + { + "id": "CSI.manager", + "process": "CSI", + "kind": "manager", + "name": "Process manager CSI", + "count": "1 in total", + "source": { + "doc": "FitSM-3", + "section": "6.14", + "page": 21 + }, + "tasks": [ + { + "text": "Review the status and progress of ongoing improvements in regular intervals.", + "source": { + "doc": "FitSM-3", + "section": "6.14", + "page": 21 + } + } + ] + }, + { + "id": "CSI.improvement-owner", + "process": "CSI", + "kind": "case-owner", + "name": "Case owner: Improvement owner", + "count": "1 per improvement", + "source": { + "doc": "FitSM-3", + "section": "6.14", + "page": 21 + }, + "tasks": [ + { + "text": "Maintain the improvement under their ownership.", + "source": { + "doc": "FitSM-3", + "section": "6.14", + "page": 21 + } + }, + { + "text": "Coordinate the activities to implement the improvement.", + "source": { + "doc": "FitSM-3", + "section": "6.14", + "page": 21 + } + } + ] + }, + { + "id": "CSI.staff", + "process": "CSI", + "kind": "staff", + "name": "Process staff member", + "source": { + "doc": "FitSM-3", + "section": "5", + "page": 9 + }, + "tasks": [] + } + ] +} diff --git a/fitsm-data.js b/fitsm-data.js deleted file mode 100644 index a3255df..0000000 --- a/fitsm-data.js +++ /dev/null @@ -1,916 +0,0 @@ -// SPDX-FileCopyrightText: ITEMO e.V. (FitSM content) -// SPDX-FileCopyrightText: 2026 PNED G.I.E. -// -// SPDX-License-Identifier: CC-BY-4.0 - -/* - * FitSM process model data. - * Sources (all CC BY 4.0, ITEMO e.V., www.fitsm.eu): - * FitSM-0 Overview and vocabulary v3.0 – definitions (databases, records) - * FitSM-1 Requirements v3.0.1 – PR1–PR14 requirements - * FitSM-2 Process activities v3.0.2 – objectives, activities, inputs/outputs, key interfaces - * FitSM-3 Role model v3.0.1 – roles and tasks - */ - -const GROUPS = { - agree: { name: "Portfolio, levels & reporting" }, - quality: { name: "Service quality" }, - rel: { name: "Relationships" }, - ops: { name: "Operations" }, - control: { name: "Control" }, - improve: { name: "Improvement" } -}; - -/* FitSM-3 §5 – common tasks shared by every process */ -const GENERIC_TASKS = { - owner: [ - "Act as the primary contact point for concerns in the context of governing one specific ITSM process.", - "Define and approve goals and policies in the context of the process according to the overall SMS goals and policies.", - "Nominate the process manager, and ensure they are competent to fulfil this role.", - "Approve changes / improvements to the operational process, such as (significant) changes to the process definition.", - "Decide on the provision of resources dedicated to the process and its activities.", - "Based on process monitoring and reviews, decide on necessary changes in the process-specific goals, policies and provided resources." - ], - manager: [ - "Act as the primary contact point for operational concerns in the context of the process.", - "Maintain the process definition / description and ensure it is available to relevant persons.", - "Maintain an adequate level of awareness and competence of the people involved in the process.", - "Monitor and keep track of the process execution and results (incl. process reviews).", - "Manage risks that involve this process (unless there is a process-specific role that manages risks in this context).", - "Report on process performance to the process owner.", - "Escalate to the process owner, if necessary.", - "Identify opportunities for improving the effectiveness and efficiency of the process." - ], - caseOwner: [ - "Overall responsibility for one specific case occurring in a process context (e.g. one specific incident to be resolved).", - "Act as the primary contact point for all concerns in the context of that specific case.", - "Coordinate all activities required to handle / resolve the specific case.", - "Escalate exceptions to the process manager, where required." - ], - staff: [ - "Carry out tasks according to the defined / established process and, as applicable, its activities and procedures (e.g. the procedure of prioritizing an incident).", - "Report to case owners and / or process managers, as appropriate.", - "Contribute to the effectiveness and continual improvement of the process." - ] -}; - -/* Builds the FitSM-3 role set for one process */ -function roles(code, managerTasks, caseOwners, extra) { - const list = [ - { name: `Process owner ${code}`, type: "owner", count: "1 in total", specific: [] }, - { name: `Process manager ${code}`, type: "manager", count: "1 in total", specific: managerTasks } - ]; - (caseOwners || []).forEach(c => list.push({ name: `Case owner: ${c.name}`, type: "caseOwner", count: c.count, specific: c.tasks, noGeneric: c.noGeneric })); - (extra || []).forEach(r => list.push(r)); - list.push({ name: `Process staff member (${code})`, type: "staff", count: "As needed", specific: [] }); - return list; -} - -const PROCESSES = [ - /* ───────────── PR1 SPM ───────────── */ - { - id: "SPM", num: "PR1", name: "Service Portfolio Management", group: "agree", - pos: { x: 370, y: 90 }, - objective: "To maintain the service portfolio and to manage services through their lifecycle", - questions: [ - "What does the service provider do for its customers, and how can this be structured into services?", - "How can the service provider use their capabilities to meet future customer needs?", - "How is the design and implementation of new or changed services planned?", - "Who does the service provider rely on when providing services?" - ], - requirements: [ - ["PR1.1", "A service portfolio shall be maintained. All services shall be specified as part of the service portfolio."], - ["PR1.2", "Proposals for new or changed services shall be evaluated based on predicted demand, required resources and expected benefits."], - ["PR1.3", "The evolution of services through their lifecycle shall be managed. This shall include the planning of new services and major alterations to existing services. Plans shall consider timescales, responsibilities, new or changed technology, communication and service acceptance criteria."], - ["PR1.4", "For each service, the internal and external suppliers involved in delivering the service shall be identified, including, as relevant, federation members. Their contact points, roles and responsibilities shall be determined."] - ], - setup: [ - "Define a way to document the service portfolio.", - "Define a way to describe / specify a specific service (e.g. service specification template) including the lifecycle phases the service may move through (e.g. proposed, planned, production, retired).", - "Set up an initial service portfolio (including service specifications) covering at least all live services provided to customers, as far as they are in the scope of the SMS.", - "Create a map of the bodies / parties (organisations, federation members) involved in delivering services — describe the role of each party and identify a single contact point for each.", - "Define a way to deal with changed demand and new service proposals — create a service proposal template and write down the assessment criteria for proposals." - ], - inputs: [ - "Any information indicating demand for services, including (potential) customer demand and requirements", - "Understanding of the service provider’s resources, capabilities, limitations and constraints", - "Information on any existing services (e.g. the current service portfolio)" - ], - outputs: [ - "Complete and up-to-date service portfolio", - "Valid and consistent service specifications", - "Plans for new or changed services (and related requests for changes)" - ], - activities: [ - { name: "Manage demand and service proposals", procedures: ["Identify demand for new or changed services", "Create service proposal", "Evaluate service proposal"] }, - { name: "Maintain the service portfolio", procedures: ["Add a new service to the service portfolio", "Update service in the service portfolio", "Retire service from the service portfolio"] }, - { name: "Manage services through their lifecycle", procedures: ["Design and plan a new or changed service", "Oversee the implementation (of the plan for a new or changed service)"] } - ], - databases: [ - { name: "Service portfolio", src: "FitSM-0 §6.69 · FitSM-1 PR1.1", - desc: "Internal list that details all the services offered by a service provider, including those in preparation, live and discontinued. For each service it may include its value proposition, target customer base, service description, relevant technical specifications, cost and price, risks to the service provider and service level packages offered.", - usedBy: ["SLM"] }, - { name: "Service specifications", src: "FitSM-2 PR1 · FitSM-1 PR1.1", - desc: "One specification per service, following a service specification template, stored as part of the service portfolio. It records the lifecycle phase of the service (e.g. proposed, planned, production, retired) and the internal and external suppliers involved in delivering it, with their contact points, roles and responsibilities (PR1.4).", - usedBy: ["SLM", "SUPPM"] }, - { name: "Service proposals & service design and transition plans", src: "FitSM-0 §6.65 note 2 · FitSM-2 PR1", - desc: "Service proposals (a smaller subset of the specification template) evaluated against documented assessment criteria, and — for approved new or majorly altered services — the service design and transition package (SDTP): requirements and service acceptance criteria, project plan, communication and training plans, technical plans, resource plans and deployment schedules.", - usedBy: ["CHM", "SUPPM"] }, - { name: "Map of service delivery parties", src: "FitSM-2 PR1 initial setup", - desc: "A map of the bodies / parties (organisations, federation members) involved in delivering services, describing the role of each party in service provisioning and a single contact point for each.", - usedBy: ["SUPPM"] } - ], - roles: roles("SPM", - ["Maintain the service portfolio.", "Manage updates to the service portfolio.", "Ensure the lifecycle of new or changed services are managed and appropriate plans are created and maintained.", "Review the service portfolio at planned intervals."], - [{ name: "Service owner", count: "1 per service", noGeneric: true, tasks: [ - "Overall responsibility for one specific service that is part of the service portfolio.", - "Act as the primary contact point for all (process-independent) concerns in the context of that specific service.", - "Act as an “expert” for the service in both technical and non-technical concerns.", - "Maintain the core service documentation, such as the service specification / description.", - "Be kept informed of every event, situation or change connected to the service.", - "Be involved in tasks significantly related to the service as part of selected ITSM processes, in particular SPM and SLM.", - "Report on the service to the SMS owner."] }]) - }, - - /* ───────────── PR2 SLM ───────────── */ - { - id: "SLM", num: "PR2", name: "Service Level Management", group: "agree", - pos: { x: 370, y: 300 }, - objective: "To maintain service catalogues, and to define and evaluate agreements on service quality with customers and suppliers", - questions: [ - "How are relevant parts of the service portfolio presented to customers?", - "Which service targets are required by customers? What are the resulting SLAs?", - "Which operational targets need to be fulfilled by suppliers to support the service targets agreed with customers? What are the resulting OLAs and UAs?", - "How is the fulfilment of SLAs, OLAs and UAs evaluated? How are customers informed of SLA violations?" - ], - requirements: [ - ["PR2.1", "A service catalogue shall be maintained."], - ["PR2.2", "For all services delivered to customers, service level agreements (SLAs) shall be in place and reviewed at planned intervals."], - ["PR2.3", "Service performance shall be evaluated against service targets defined in SLAs."], - ["PR2.4", "For supporting services or service components, underpinning agreements (UAs) and operational level agreements (OLAs) shall be agreed as needed and reviewed at planned intervals."], - ["PR2.5", "Performance of supporting services and service components shall be evaluated against targets defined in UAs and OLAs."] - ], - setup: [ - "Define the minimum structure, format and content for service catalogues.", - "Create an initial service catalogue based on the information in the service portfolio.", - "Define a basic / default SLA valid for all services provided to customers, where no specific / individual SLAs are in place.", - "Define templates for individual SLAs, OLAs and UAs.", - "Identify the most critical supporting service components and agree OLAs and UAs with internal and external suppliers.", - "Agree individual SLAs with customers for the most important / critical services.", - "Define a standard way to notify customers of SLA violations." - ], - inputs: ["Service portfolio together with service specifications", "General and specific service level requirements"], - outputs: ["Up-to-date service catalogue covering all information that are relevant for customers", "Default SLA and individual SLAs with customers", "Supporting OLAs and UAs, aligned with SLAs"], - activities: [ - { name: "Maintain service catalogues", procedures: ["Create a new service catalogue", "Add, update or remove services from a catalogue", "Retire a service catalogue"] }, - { name: "Maintain SLAs", procedures: ["Define and negotiate / agree a new SLA", "Evaluate SLA fulfilment", "Notify customer of an SLA violation", "Review, update or terminate an SLA"] }, - { name: "Maintain supporting agreements (OLAs and UAs)", procedures: ["Define and negotiate / agree a new OLA / UA", "Evaluate OLA / UA fulfilment", "Escalate an OLA / UA violation to the supplier", "Review, update or terminate an OLA / UA"] } - ], - databases: [ - { name: "Service catalogue(s)", src: "FitSM-0 §6.62 · FitSM-1 PR2.1", - desc: "Customer-facing list of all live services offered along with relevant information about these services. A service catalogue can be regarded as a filtered version of — and the customers’ view on — the service portfolio. Based on one service portfolio, one or more service catalogues can be created.", - usedBy: ["CRM"] }, - { name: "Agreements register (SLAs, OLAs, UAs)", src: "FitSM-0 §6.45, §6.64, §6.76 · FitSM-1 PR2.2–PR2.5", - desc: "The documented default SLA and individual SLAs (agreements between a customer and the service provider specifying the service and its service targets), OLAs (with internal suppliers / federation members) and UAs (with external suppliers), each with its operational or service targets, owner and review dates. Agreements follow the templates defined in initial setup and are kept aligned with each other.", - usedBy: ["SRM", "SACM", "CAPM", "ISM", "CRM", "SUPPM", "ISRM"] }, - { name: "Agreement evaluation data", src: "FitSM-2 PR2 · FitSM-1 PR2.3, PR2.5", - desc: "Results of evaluating service performance against SLA service targets and supporting-service performance against OLA / UA operational targets, including recorded violations and customer notifications. It is the data basis for service reports and supplier evaluation.", - usedBy: ["SRM", "SUPPM"] } - ], - roles: roles("SLM", - ["Maintain the service catalogue.", "Manage updates to the service catalogue.", "Ensure the service catalogue is aligned with the service portfolio.", "Negotiate SLAs with customers.", "Propose and negotiate OLAs with internal groups or federation members.", "Propose and negotiate UAs with external suppliers.", "Ensure that all SLAs, OLAs and UAs are documented in a consistent manner e.g. through maintaining agreement templates.", "Approve new or changed SLAs, OLAs and UAs.", "Ensure SLAs, OLAs and UAs are aligned to each other."], - [{ name: "SLA / OLA / UA owner", count: "1 per SLA, OLA and UA", tasks: [ - "Maintain the SLA, OLA or UA under their ownership and ensure it is specified and documented according to relevant specifications.", - "Evaluate the fulfilment of the SLA, OLA or UA.", - "Ensure that violations of the targets defined in the SLA, OLA or UA are identified and investigated to prevent future recurrence.", - "Perform regular reviews of the SLA, OLA or UA.", - "Understand new or changed requirements on the SLA, OLA or UA under their ownership, and initiate necessary updates or other follow-up actions."] }]) - }, - - /* ───────────── PR3 SRM ───────────── */ - { - id: "SRM", num: "PR3", name: "Service Reporting Management", group: "agree", - pos: { x: 650, y: 90 }, - objective: "To specify reports on services and processes and ensure they are produced and delivered", - questions: [ - "Which reports are required by customers and other interested parties?", - "Which reports are required by internal stakeholders in order to effectively manage the SMS?", - "What is the required frequency and content of these reports?", - "Are reports actually produced and distributed as required and agreed?" - ], - requirements: [ - ["PR3.1", "Required reports shall be identified. Reporting shall cover performance of services and processes against defined targets, significant events and detected nonconformities."], - ["PR3.2", "Reports shall be agreed with their recipients and specified. The specification of each report shall include its identity, purpose, audience, frequency, content, format and method of delivery."], - ["PR3.3", "Reports shall be produced and delivered to their recipients according to specifications."] - ], - setup: [ - "Create a list of all reports that are currently produced or will be produced on a regular basis.", - "Specify every identified report: unique name (ID), purpose, audience / addressee, frequency, intended contents, format and method of delivery.", - "Define templates for reports to standardise / harmonise the report structure and support effective and repeatable reporting." - ], - inputs: ["Reporting requirements (e.g. from SLAs)"], - outputs: ["List of all (agreed) reports", "Specification of all reports", "Reports"], - activities: [ - { name: "Identify reporting requirements", procedures: ["Derive targets, events and nonconformities to be reported to customers based on SLAs", "Identify targets, events and nonconformities to be reported to internal stakeholders to support management of the SMS"] }, - { name: "Maintain report specifications", procedures: ["Define / specify a new report", "Update a report specification", "Terminate a report"] }, - { name: "Monitor the production and distribution of reports", procedures: ["Verify the production and distribution of reports according to specifications", "Initiate follow-up actions in case of inaccurate reporting"] } - ], - databases: [ - { name: "Report list & report specifications", src: "FitSM-1 PR3.2 · FitSM-2 PR3", - desc: "The list of all agreed reports, and for each one its specification: identity (unique name / ID), purpose, audience, frequency, content, format and method of delivery, based on standard report templates.", - usedBy: [] }, - { name: "Produced reports", src: "FitSM-0 §6.56", - desc: "Reports are structured records communicating results gathered through measurement, monitoring, assessment, audit or observation — e.g. a service report detailing the performance of a service versus the service targets defined in an SLA. Recipients may be customers, suppliers, federation members, service owners and the SMS owner.", - usedBy: ["CRM", "CSI"] } - ], - roles: roles("SRM", - ["Maintain the list of reports.", "Review report specifications in regular intervals.", "Monitor the production of accurate reports according to specifications."], - [{ name: "Report owner", count: "1 per report", tasks: [ - "Maintain the report specification for the report under their ownership.", - "Produce and deliver the report according to the specification.", - "Ensure that the input / contributions required to produce the report is provided in time.", - "Understand new or changed requirements on the report under their ownership and update the report specification accordingly."] }]) - }, - - /* ───────────── PR4 SACM ───────────── */ - { - id: "SACM", num: "PR4", name: "Service Availability & Continuity Management", group: "quality", - pos: { x: 650, y: 215 }, - objective: "To ensure sufficient service availability and continuity to meet service targets", - questions: [ - "How are the requirements for service availability and continuity determined?", - "How are the measures planned that have to be taken to meet the requirements?", - "How is service availability monitored?" - ], - requirements: [ - ["PR4.1", "Service availability and continuity requirements shall be identified and reviewed at planned intervals, taking into consideration SLAs."], - ["PR4.2", "Service availability and continuity risks shall be assessed at planned intervals."], - ["PR4.3", "Appropriate measures shall be taken to reduce the probability and impact of identified availability and continuity risks and meet identified requirements."], - ["PR4.4", "Availability of services and service components shall be monitored."] - ], - setup: [ - "Identify the most critical service availability and continuity requirements based on SLAs and other sources of information.", - "Define the structure and format of a (generic) service availability and continuity plan.", - "Define an approach to monitor service availability (and continuity) and to record the results on an ongoing basis." - ], - inputs: ["Service availability and continuity requirements (e.g. from SLAs)", "Risk factors having impact on the capability of delivering services according to agreed availability and continuity targets"], - outputs: ["Service availability and continuity plans", "Service availability data", "Requests for change"], - activities: [ - { name: "Identify service availability and continuity requirements", procedures: ["Derive availability targets from SLAs", "Identify continuity requirements based on SLAs and business impact analysis"] }, - { name: "Maintain and implement service availability and continuity plans", procedures: ["Assess risks related to service availability and continuity", "Create service continuity and availability plans", "Implement preventive measures from plans", "Review, update or terminate service continuity and availability plans"] }, - { name: "Evaluate service availability and continuity", procedures: ["Monitor service availability", "Perform service continuity tests for reactive measures from plans"] } - ], - databases: [ - { name: "Availability & continuity plans", src: "FitSM-2 PR4 · FitSM-1 PR4.2–PR4.3", - desc: "Plans following the generic plan structure defined in initial setup. They capture availability and continuity requirements (from SLAs and business impact analysis), assessed availability and continuity risks, and the preventive and reactive measures to reduce their probability and impact — including the continuity tests to be performed.", - usedBy: ["CHM"] }, - { name: "Service availability data", src: "FitSM-2 PR4 · FitSM-1 PR4.4", - desc: "Ongoing records of monitored availability of services and service components, and results of continuity tests. Availability is the ability of a service or service component to fulfil its intended function at a specific time or over a specific period of time (FitSM-0 §6.4).", - usedBy: ["SRM"] } - ], - roles: roles("SACM", - ["Identify service availability and continuity requirements.", "Ensure that the input / contributions required to produce service availability and continuity plans are provided by relevant parties.", "Produce, maintain and review all service availability and continuity plans regularly.", "Ensure that measures to increase service availability and continuity (according to plans) are planned and implemented under the control of the change management process.", "Act as a contact point in case of questions regarding service availability and continuity requirements and measures."], - [{ name: "Availability plan owner / continuity plan owner", count: "1 per availability plan / continuity plan", tasks: [ - "Create and maintain the availability or continuity plan under their ownership.", - "Ensure that relevant stakeholders in the context of the plan are consulted and informed when creating, updating or implementing the plan.", - "Ensure the plan and any updates to it are approved by relevant authorities.", - "Based on the contents of the final / approved plan, raise requests for changes or trigger the continual service improvement process, as required.", - "In case of a continuity plan: ensure that the needs for testing the plan are identified and tests of preventive or reactive measures are performed regularly."] }]) - }, - - /* ───────────── PR5 CAPM ───────────── */ - { - id: "CAPM", num: "PR5", name: "Capacity Management", group: "quality", - pos: { x: 650, y: 320 }, - objective: "To ensure sufficient capacity and service performance to meet service targets", - questions: [ - "How are the requirements for service performance and capacity determined?", - "How are the measures planned that have to be taken to meet the requirements?", - "How is service performance and utilisation monitored?" - ], - requirements: [ - ["PR5.1", "Service capacity and performance requirements shall be identified and reviewed at planned intervals, taking into consideration SLAs and predicted demand."], - ["PR5.2", "Current capacity and utilisation shall be identified."], - ["PR5.3", "Future capacity shall be planned to meet identified requirements, considering human, technical and financial resources."], - ["PR5.4", "Performance of services and service components shall be analysed based on monitoring the degree of capacity utilisation and identifying operational warnings and exceptions."] - ], - setup: [ - "Define the structure and format of a (generic) capacity plan.", - "Define an approach to monitor service performance and capacity (including utilisation of resources) and to record the results on an ongoing basis." - ], - inputs: ["Service performance and capacity requirements (e.g. from SLAs)", "Current level of capacities plus information on the past, current and future (predicted) utilisation of resources", "Information on available resources and constraints"], - outputs: ["Capacity plans (reflecting demands, planned upgrades, downgrades and reallocations of resources)", "Capacity and service performance monitoring plans / concept", "Capacity and service performance monitoring records / reports"], - activities: [ - { name: "Identify service capacity and performance requirements", procedures: ["Derive performance targets from SLAs", "Translate performance targets into capacity requirements"] }, - { name: "Maintain and implement capacity plans", procedures: ["Create capacity plans", "Ensure capacity according to plans", "Review, update or terminate capacity plans"] }, - { name: "Evaluate service performance", procedures: ["Monitor performance of services and service components", "Monitor capacity including assessment against thresholds", "Respond when capacity thresholds are exceeded"] } - ], - databases: [ - { name: "Capacity plans", src: "FitSM-2 PR5 · FitSM-1 PR5.3", - desc: "Plans reflecting demands, planned upgrades, downgrades and reallocations of resources, considering human, technical and financial resources. Capacity is the maximum extent to which a certain element of the infrastructure (such as a CI) can be used — e.g. total disk capacity, network bandwidth or maximum transaction throughput (FitSM-0 §6.7).", - usedBy: ["CHM"] }, - { name: "Capacity & performance monitoring records", src: "FitSM-2 PR5 · FitSM-1 PR5.2, PR5.4", - desc: "Records of current capacity and utilisation, performance of services and service components, thresholds and threshold violations (operational warnings and exceptions), collected according to the monitoring concept defined in initial setup.", - usedBy: ["SRM"] } - ], - roles: roles("CAPM", - ["Identify service performance and capacity requirements.", "Ensure that the input / contributions required to produce capacity plans are provided by relevant parties.", "Produce, maintain and review capacity plans regularly.", "Ensure that measures to increase service performance and capacity (according to plans) are planned and implemented under the control of the change management process.", "Act as a contact point in case of questions regarding service performance and capacity requirements and measures."], - [{ name: "Capacity plan owner", count: "1 per capacity plan", tasks: [ - "Create and maintain the capacity plan under their ownership.", - "Ensure that relevant stakeholders in the context of the plan are consulted and informed when creating, updating or implementing the plan.", - "Ensure the plan and any updates to it are approved by relevant authorities.", - "Based on the contents of the final / approved plan, raise requests for changes or trigger the CSI process, as required."] }]) - }, - - /* ───────────── PR6 ISM ───────────── */ - { - id: "ISM", num: "PR6", name: "Information Security Management", group: "quality", - pos: { x: 650, y: 425 }, - objective: "To preserve confidentiality, integrity and availability of information related to managing and delivering services", - questions: [ - "How are information security requirements determined?", - "How are information security controls and policies established, based on an understanding of relevant risks?", - "How are information security events monitored and information security incidents handled?", - "How are access rights managed?" - ], - requirements: [ - ["PR6.1", "Information security requirements shall be identified and information security policies defined and reviewed at planned intervals."], - ["PR6.2", "Information security risks shall be assessed at planned intervals."], - ["PR6.3", "Physical, technical and organisational information security controls shall be implemented to reduce the probability and impact of identified information security risks and meet identified requirements."], - ["PR6.4", "Information security events and incidents shall be handled in a consistent manner."], - ["PR6.5", "Access control, including provisioning of access rights, shall be carried out in a consistent manner."] - ], - setup: [ - "Define a scheme to classify information assets according to their sensitivity / criticality.", - "Define a way to document an inventory of (information) assets.", - "Identify, describe and classify the most important information assets.", - "Identify the most important links between service components (information-processing systems / facilities) and the information assets.", - "Define a method / scheme to identify and assess information security risks.", - "Perform an initial risk assessment focused on the most significant information security risks.", - "Define clear information security policies as a basis for effective information security governance.", - "Define a way to document information security controls and to monitor their status and progress of implementation.", - "Identify and document the most important technical, physical and organisational information security controls in place." - ], - inputs: ["Information security requirements (from SLAs, legislation, contracts)", "Assets to be protected", "Relevant risk factors (vulnerabilities, hazards)"], - outputs: ["Up-to-date inventory of information assets", "Approved information security policies", "Up-to-date information security risk assessment", "Documented information security controls", "Reports on information security events, incidents and follow-up actions", "Documented information on access rights and their reviews"], - activities: [ - { name: "Identify information security requirements", procedures: ["Derive information security requirements from SLAs", "Identify information (assets) to be protected and their needs in terms of confidentiality, integrity and availability"] }, - { name: "Maintain and implement information security controls and policies", procedures: ["Assess risks related to information security", "Create information security policies and define other controls", "Implement information security controls", "Review, update or terminate information security policies and other controls"] }, - { name: "Evaluate information security", procedures: ["Monitor, record and classify information security events", "Identify and handle information security incidents"] }, - { name: "Perform access control", procedures: ["Process requests for access rights", "Provide access rights", "Modify or revoke access rights", "Review access rights (at regular intervals)"] } - ], - databases: [ - { name: "Information asset inventory", src: "FitSM-2 PR6", - desc: "Inventory of information assets, each classified by sensitivity / criticality according to the classification scheme, with their needs in terms of confidentiality, integrity and availability and their links to the service components (information-processing systems / facilities) that handle them.", - usedBy: [] }, - { name: "Information security risk assessment (risk register)", src: "FitSM-1 PR6.2 · FitSM-0 §6.58", - desc: "Up-to-date assessment of information security risks based on the identified assets and the defined risk method. A risk combines the probability of a threat, the vulnerability of an asset to it and its impact. Each risk has a security risk owner.", - usedBy: [] }, - { name: "Security policies & controls register", src: "FitSM-1 PR6.1, PR6.3 · FitSM-0 §6.31", - desc: "Approved information security policies and documented physical, technical and organisational information security controls (means of controlling or treating one or more risks), with their implementation status and progress. Each control has a security control owner.", - usedBy: ["CHM"] }, - { name: "Security event & incident records", src: "FitSM-1 PR6.4 · FitSM-0 §6.32–6.33", - desc: "Records of monitored and classified information security events (occurrences indicating a possible breach of information security) and information security incidents (events with significant probability of negative impact on service delivery), with handling and follow-up actions.", - usedBy: [] }, - { name: "Access rights records", src: "FitSM-1 PR6.5 · FitSM-2 PR6", - desc: "Documented information on requested, provided, modified and revoked access rights, and the results of their periodic reviews.", - usedBy: [] } - ], - roles: roles("ISM", - ["Act as the primary contact of the service provider for all information security-related issues.", "Monitor the status and progress of all activities connected to the process of information security management, in particular, the assessment and treatment of information security risks and handling of information security events and incidents.", "Ensure that information security incidents are detected and classified as such and as quickly as possible handled in an effective way to minimise harm caused by them.", "Ensure that all security-related documentation is maintained and up to date.", "Ensure that security risks and controls are assigned to case owners."], - [ - { name: "Security risk owner", count: "1 per security risk", tasks: ["Maintain and review the specification / documentation of a specific security risk.", "Act as a primary contact point and expert for the risk under their ownership."] }, - { name: "Security control owner", count: "1 per security control", tasks: ["Maintain and review the specification / documentation of a specific security control.", "Act as a primary contact point and expert for the control under their ownership."] } - ]).map(r => r.type === "manager" ? { ...r, name: "Process manager ISM (Information security manager / officer)" } : r) - }, - - /* ───────────── PR7 CRM ───────────── */ - { - id: "CRM", num: "PR7", name: "Customer Relationship Management", group: "rel", - pos: { x: 110, y: 170 }, - objective: "To establish and maintain good relationships with customers receiving services", - questions: [ - "Who are the customers and users of the IT services?", - "How are the relationships with customers managed, and what are the best ways to get or stay in touch with your customers?", - "Are the services matching customer needs and leading to customer satisfaction?", - "How are customer complaints handled?" - ], - requirements: [ - ["PR7.1", "Service customers shall be identified."], - ["PR7.2", "For each customer, there shall be a designated contact responsible for managing the relationship with them."], - ["PR7.3", "Channels used to communicate with each customer, including mechanisms for service ordering, escalation and complaint shall be established."], - ["PR7.4", "Service reviews with customers shall be conducted at planned intervals."], - ["PR7.5", "Service complaints from customers shall be handled in a consistent manner."], - ["PR7.6", "Customer satisfaction shall be managed."] - ], - setup: [ - "Set up an initial customer database, and for each service customer document the most important information including contact information.", - "Decide on general communication channels to be used for customer engagement (e.g. ordering, escalation and complaints).", - "Define a way to perform and document the results of a service review.", - "Define a way to record, respond to and follow-up a customer complaint.", - "Define a way to evaluate customer satisfaction on a regular basis, e.g. (online) surveys." - ], - inputs: ["Information on service customers", "Current service catalogue", "Customer demands and requirements", "Existing SLAs with customers", "Customer complaints"], - outputs: ["Up-to-date database of service customers (customer database)", "Service review reports", "Customer complaints records", "Customer satisfaction reports"], - activities: [ - { name: "Maintain the customer database", procedures: ["Add a new customer to the customer database (including contact information)", "Update the information on a customer in the customer database", "Remove a customer from the customer database"] }, - { name: "Perform customer service reviews", procedures: ["Plan and prepare service reviews with customers", "Perform and record a service review with a customer"] }, - { name: "Handle customer complaints", procedures: ["Register, address and close a customer complaint", "Track the implementation status of actions following a customer complaint", "Review all customer complaints and follow-up actions periodically"] }, - { name: "Manage customer satisfaction", procedures: ["Plan and implement measures to assess customer satisfaction", "Initiate follow-up actions in response to insufficient customer satisfaction"] } - ], - databases: [ - { name: "Customer database", src: "FitSM-2 PR7 · FitSM-1 PR7.1–PR7.3 · FitSM-0 §6.18", - desc: "Up-to-date database of service customers — organisations or parts of organisations that commission the service provider to receive one or more services. For each customer it records the most important information, including contact information, the designated customer relationship manager and the agreed communication channels (ordering, escalation, complaints).", - usedBy: ["SLM"] }, - { name: "Service review records", src: "FitSM-0 §6.72 · FitSM-1 PR7.4", - desc: "Documented results of service reviews: periodic evaluations of the quality and performance of a service together with the customer, from which opportunities for improvement and follow-up actions are identified.", - usedBy: ["SLM", "CSI"] }, - { name: "Customer complaint records", src: "FitSM-1 PR7.5 · FitSM-2 PR7", - desc: "Registered customer complaints with their handling, closure and the implementation status of follow-up actions, reviewed periodically.", - usedBy: ["CSI", "CHM"] }, - { name: "Customer satisfaction results", src: "FitSM-1 PR7.6 · FitSM-2 PR7", - desc: "Customer satisfaction reports from regular evaluations (e.g. online surveys), and the follow-up actions initiated in response to insufficient satisfaction.", - usedBy: ["CSI"] } - ], - roles: roles("CRM", - ["Maintain the customer database.", "Ensure that customer complaints are handled according to the process.", "Coordinate customer satisfaction surveys.", "Review the results from customer service reviews."], - [{ name: "Customer relationship manager (Account manager)", count: "1 per identified customer", tasks: [ - "Act as the primary contact point for a specific customer.", - "Maintain the relationship with that customer by regular communication.", - "Process formal customer complaints.", - "Conduct, moderate and record customer service reviews."] }]) - }, - - /* ───────────── PR8 SUPPM ───────────── */ - { - id: "SUPPM", num: "PR8", name: "Supplier Relationship Management", group: "rel", - pos: { x: 110, y: 420 }, - objective: "To establish and maintain healthy relationships with internal and external suppliers and to monitor their performance", - questions: [ - "Who are the suppliers supporting the delivery of IT services?", - "How are the relationships with suppliers managed?", - "What are the best ways to get or stay in touch with your suppliers?", - "Are the suppliers performing as agreed and required?" - ], - requirements: [ - ["PR8.1", "Internal and external suppliers shall be identified."], - ["PR8.2", "For each supplier, there shall be a designated contact responsible for managing the relationship with them."], - ["PR8.3", "Channels used to communicate with each supplier, including escalation mechanisms, shall be established."], - ["PR8.4", "Suppliers shall be evaluated at planned intervals."] - ], - setup: [ - "Set up an initial supplier database (covering all internal and external suppliers).", - "For each supplier, document the most important information including contact details both on the supplier side and on the service provider side (supplier relationship manager).", - "Understand which supplier services or service components need to be monitored, and how the monitoring will take place." - ], - inputs: ["Information on suppliers", "Information on supplier offerings", "OLAs with internal suppliers", "UAs with external suppliers"], - outputs: ["Up-to-date supplier database", "Supplier evaluation results"], - activities: [ - { name: "Maintain the supplier database", procedures: ["Add a new supplier to the supplier database (including contact information)", "Update the information on a supplier in the supplier database", "Remove a supplier from the supplier database"] }, - { name: "Monitor supplier performance", procedures: ["Evaluate supplier performance", "Together with the supplier, agree on follow-up actions in response to insufficient supplier performance", "Track the implementation status of agreed follow-up actions with suppliers"] } - ], - databases: [ - { name: "Supplier database", src: "FitSM-2 PR8 · FitSM-1 PR8.1–PR8.3 · FitSM-0 §6.74", - desc: "Up-to-date database of all internal and external suppliers — parties that provide a (supporting) service or service component the service provider needs to deliver services (in a federation, federation members are internal suppliers). For each supplier: contact details on both sides (incl. the supplier relationship manager), communication and escalation channels, and which supplier services / components are monitored and how.", - usedBy: ["SPM", "SLM"] }, - { name: "Supplier evaluation records", src: "FitSM-1 PR8.4 · FitSM-2 PR8", - desc: "Results of periodic supplier performance evaluations (against OLA / UA operational targets), agreed follow-up actions and their implementation status.", - usedBy: [] } - ], - roles: roles("SUPPM", - ["Maintain the supplier database.", "Ensure that supplier performance is monitored according to the process."], - [{ name: "Supplier relationship manager", count: "1 per identified supplier", tasks: [ - "Act as the primary contact point for a specific supplier.", - "Maintain the relationship with that supplier by regular communication.", - "Maintain mechanisms for monitoring the performance of the supplier."] }]) - }, - - /* ───────────── PR9 ISRM ───────────── */ - { - id: "ISRM", num: "PR9", name: "Incident & Service Request Management", group: "ops", - pos: { x: 370, y: 640 }, - objective: "To restore agreed service operation after the occurrence of an incident and to respond to user service requests", - questions: [ - "How are incidents and service requests handled?", - "What information can be used to support the effective handling and resolution of incidents?", - "How are customers involved?", - "How are major incidents distinguished from other incidents and handled accordingly?" - ], - requirements: [ - ["PR9.1", "All incidents and service requests shall be registered, classified and prioritised in a consistent manner, taking into account service targets from SLAs."], - ["PR9.2", "Incidents shall be resolved and service requests fulfilled, taking into consideration information from SLAs and on known errors, as relevant."], - ["PR9.3", "Functional and hierarchical escalation of incidents and service requests shall be carried out in a consistent manner."], - ["PR9.4", "Customers and users shall be kept informed of the progress of incidents and service requests, as appropriate."], - ["PR9.5", "Closure of incidents and service requests shall be carried out in a consistent manner."], - ["PR9.6", "Major incidents shall be identified based on defined criteria, and handled in a consistent manner."] - ], - setup: [ - "Set up a tool (e.g. ticket / workflow tool) supporting recording and handling (classification, prioritisation, escalation, closure) of incidents and service requests.", - "Define a procedure for recording incidents and service requests (sources and channels, required format, how they are recorded).", - "Define a procedure for classifying incidents and service requests (classification scheme and how to apply it).", - "Define a procedure for prioritising incidents and service requests (prioritisation scheme and how priority is calculated).", - "Define a procedure for escalating incidents and service requests (functional and hierarchical escalation paths).", - "Define a procedure for closing incidents and service requests (including required user communication and confirmation).", - "Define the criteria for identifying a major incident, and a procedure for dealing with major incidents from recording to closure, including a major incident review.", - "Identify well-known and recurring incidents and describe the concrete steps to manage each from recording to closure.", - "Identify standardised service requests based on service descriptions and SLAs and describe the concrete steps to fulfil each." - ], - inputs: ["Incidents reported by users or identified by the service provider", "Service requests raised by users", "Configuration information (CMDB)"], - outputs: ["Incident records", "Service request records", "Major incident review reports", "Requests for changes raised to trigger the change management process, in order to commence the fulfilment of service requests", "Up-to-date descriptions of step-by-step workflows for standard incidents and service requests", "Regular incident reports"], - activities: [ - { name: "Manage incidents and service requests", procedures: ["Register incident or service request", "Classify and prioritise incident or service request including checking against major incident criteria", "Escalate incident or service request as required", "Resolve incident or fulfil service request", "Close incident or service request"] }, - { name: "Manage major incidents", procedures: ["Identify incident as major incident based on agreed criteria", "Assign a major incident coordinator for the major incident", "Handle major incident with highest priority", "Inform stakeholders and escalate major incident as required", "Resolve major incident", "Perform major incident review and close the major incident"] }, - { name: "Manage workflows needed to resolve incidents and fulfil service requests", procedures: ["Maintain the step-by-step workflows for well-known and recurring incidents taking into account the KEDB", "Maintain workflows for standardised service requests"] } - ], - databases: [ - { name: "Incident & service request records (ticket tool)", src: "FitSM-0 §6.29, §6.53, §6.71 · FitSM-2 PR9", - desc: "Records of every incident (unplanned disruption or degradation of service quality versus agreed service levels) and service request (user request for information, advice, access to a service or a change), held in the ticket / workflow tool with classification, priority, escalation history, resolution and closure status.", - usedBy: ["PM"] }, - { name: "Standard workflow library", src: "FitSM-2 PR9", - desc: "Up-to-date step-by-step workflows for well-known and recurring incidents (maintained taking the KEDB into account) and for standardised service requests, identified from service descriptions and SLAs.", - usedBy: [] }, - { name: "Major incident review reports", src: "FitSM-2 PR9 · FitSM-0 §6.40", - desc: "Documented reviews of major incidents — incidents that (may) have significant impact on the customer — performed before the major incident is closed.", - usedBy: ["PM", "CSI"] } - ], - roles: roles("ISRM", - ["Ensure that all incidents and service requests are recorded, and that records are of sufficient quality to enable traceability and long-term analysis.", "Monitor the overall progress of incident resolution and service request fulfilment and identify potential violations of target response and resolution times."], - [{ name: "Incident owner / service request owner", count: "1 per incident / service request", tasks: [ - "Coordinate and take over overall responsibility for all activities in the lifecycle of a specific incident or service request.", - "Monitor the progress of incident resolution or request fulfilment taking into account agreed timeframes.", - "Trigger reminders to those involved in incident resolution or request fulfilment and escalate to the process manager as required.", - "In case of a (potential) SLA violation, trigger communication and escalation as defined in the SLM process.", - "Ensure an adequate level of documentation for the specific incident or service request."] }]) - }, - - /* ───────────── PR10 PM ───────────── */ - { - id: "PM", num: "PR10", name: "Problem Management", group: "ops", - pos: { x: 650, y: 640 }, - objective: "To identify and investigate problems in order to reduce their impact or prevent them from causing further incidents", - questions: [ - "How are problems identified?", - "How are problems investigated and handled in a way that their impact is minimised?", - "What information on known errors and workarounds need to be maintained?" - ], - requirements: [ - ["PR10.1", "Problems shall be identified and registered in a consistent manner, based on analysing patterns and trends in the occurrence of incidents."], - ["PR10.2", "Problems shall be investigated to identify actions to resolve them or reduce their impact on services."], - ["PR10.3", "If a problem is not permanently resolved, a known error shall be registered together with actions such as effective workarounds and temporary fixes."], - ["PR10.4", "Up-to-date information on known errors and effective workarounds shall be maintained."] - ], - setup: [ - "Define a standardised and repeatable way to register problems, known errors and related workarounds, and set up an initial known error database (KEDB).", - "Set up a tool (e.g. ticket / workflow tool) supporting the recording and handling (classification, prioritisation, escalation, closure) of identified problems.", - "Make sure relevant information on incidents, including incident records and reports, and the CMDB are accessible to problem management staff.", - "Ensure staff involved in both ISRM and PM are aware of the different goals and perspectives of these processes." - ], - inputs: ["Statistics on incidents and service requests (for trend analysis)", "Incident and service request records", "Other relevant sources of information to identify (new) problems, including change and release records", "Configuration information (CMDB)"], - outputs: ["Up-to-date KEDB with information (records) on problems, known errors and related workarounds", "Requests for changes raised to trigger the change management process, in order to resolve the underlying root cause(s) of identified problems / known errors"], - activities: [ - { name: "Identify problems", procedures: ["Perform regular incident pattern and trend analysis to identify (potential) problems", "Register a problem"] }, - { name: "Handle problems", procedures: ["Classify and prioritise a problem", "Identify the root cause and categorise the problem as a known error", "Identify one or more workarounds where possible", "Assess options for resolution of a problem, and resolve a problem where appropriate", "Close a problem (following resolution or when no longer relevant)"] }, - { name: "Maintain the KEDB", procedures: ["Add a known error (including one or more workarounds) to the KEDB", "Update or deactivate a known error record in the KEDB"] } - ], - databases: [ - { name: "Known error database (KEDB)", src: "FitSM-2 PR10 · FitSM-0 §6.38, §6.80", - desc: "Up-to-date store of records on problems, known errors and related workarounds. A known error is a problem which has not (yet) been resolved, but for which there are documented workarounds or measures to reduce or prevent negative impact on services. A workaround circumvents or mitigates the symptoms of a known error (also called a temporary fix).", - usedBy: ["ISRM"] }, - { name: "Problem records", src: "FitSM-0 §6.50 · FitSM-1 PR10.1", - desc: "Records of registered problems — underlying causes of one or more incidents that require further investigation — with classification, priority, root cause analysis, resolution options and closure status, held in the problem ticket / workflow tool.", - usedBy: ["CHM", "CSI"] } - ], - roles: roles("PM", - ["Ensure that incident trends are regularly analysed to identify problems.", "Ensure that identified problems are recorded, and that records are of sufficient quality.", "Ensure that problems are analysed, information on known errors recorded and problems brought to closure."], - [{ name: "Problem owner", count: "1 per problem", tasks: [ - "Coordinate and take over overall responsibility for all activities in the lifecycle of a specific problem, including problem analysis and identification of options to handle the problem.", - "Monitor the progress of problem resolution and ensure that the problem is escalated effectively, if required.", - "Ensure the information in the KEDB on this problem / known error are up to date, including appropriate descriptions of potential workarounds.", - "Communicate the problem / known error and potential workarounds to relevant stakeholders (e.g. ISRM staff and users).", - "Depending on the selected option for dealing with the problem / known error, raise requests for changes or trigger the CSI process as required."] }]) - }, - - /* ───────────── PR11 CONFM ───────────── */ - { - id: "CONFM", num: "PR11", name: "Configuration Management", group: "control", - pos: { x: 950, y: 720 }, - objective: "To provide and maintain a logical model of configuration items in support of other service management activities", - questions: [ - "For the services offered: What is considered a CI, and what is not?", - "What information needs to be maintained in the CMDB for each CI?", - "How to ensure that the information in the CMDB is correct and up-to-date?" - ], - requirements: [ - ["PR11.1", "The scope of configuration management shall be defined together with the types of configuration items (CIs) and relationships to be considered."], - ["PR11.2", "The level of detail of configuration information shall be sufficient to support effective control over CIs."], - ["PR11.3", "Information on CIs and their relationships with other CIs shall be maintained in a configuration management database (CMDB)."], - ["PR11.4", "CIs shall be controlled and changes to CIs tracked in the CMDB."], - ["PR11.5", "The information stored in the CMDB shall be verified at planned intervals."] - ], - setup: [ - "Define the scope of the configuration management process and the integrated CMDB.", - "Agree the level of detail of configuration information to be collected.", - "Identify and define CI types (including their attributes) and relationship types.", - "Based on the defined scope, identify all existing sources of configuration information in the environment of the service provider.", - "Define the concept for integrating available sources of configuration information and add missing configuration information to the integrated CMDB, including selecting supporting tools." - ], - inputs: ["Relevant information / data on configuration items (CIs) and their relationships", "Information on changes to CIs"], - outputs: ["Up-to-date logical model of all relevant CIs and their attributes and relationships, reflected by the records stored in the CMDB", "Configuration verification reports"], - activities: [ - { name: "Maintain configuration information", procedures: ["Record new CI in the CMDB (create a configuration record)", "Update information on a CI"] }, - { name: "Verify configuration information", procedures: ["Plan configuration verification", "Perform configuration verification (to identify errors or inconsistencies in configuration information and trigger corrective actions)"] } - ], - databases: [ - { name: "Configuration management database (CMDB)", src: "FitSM-0 §6.15–6.16 · FitSM-1 PR11.3", - desc: "Store for data about configuration items (CIs). A CMDB is not necessarily a single database covering all CIs — it may be composed of multiple data stores. Each CI record holds the CI’s attributes and its relationships with other CIs, service components and services. CIs range from technical components (hardware, network components, software) to documents (SLAs, manuals, licence documentation).", - usedBy: ["ISRM", "PM", "RDM", "CHM", "SPM", "SLM", "SRM", "SACM", "CAPM", "ISM", "CRM", "SUPPM", "CSI"] }, - { name: "CI type & relationship type definitions", src: "FitSM-1 PR11.1 · FitSM-2 PR11", - desc: "Definition of the scope of configuration management, the CI types (with their attributes) and relationship types to be considered, and the agreed level of detail of configuration information.", - usedBy: [] }, - { name: "Configuration verification reports", src: "FitSM-1 PR11.5 · FitSM-2 PR11", - desc: "Results of planned verifications of the information stored in the CMDB, identifying errors or inconsistencies and the corrective actions triggered.", - usedBy: ["CSI"] } - ], - roles: roles("CONFM", - ["Maintain and periodically review the scope and granularity of the CMDB.", "Maintain the definitions of all CI and relationship types.", "Plan regular verifications of the configuration information held in the CMDB.", "Ensure that configuration verifications are conducted and identified nonconformities addressed."], - [{ name: "Configuration item (CI) owner", count: "1 per CI", tasks: [ - "Ensure that the information on a specific CI in the CMDB is accurate and up to date.", - "Collaborate with the process manager and other CI owners to ensure that all information on the relationships from / to a specific CI are accurate and up to date."] }]) - }, - - /* ───────────── PR12 CHM ───────────── */ - { - id: "CHM", num: "PR12", name: "Change Management", group: "control", - pos: { x: 950, y: 425 }, - objective: "To plan, approve and review changes in a controlled manner to avoid adverse impact on services", - questions: [ - "What types of changes are considered, and how are changes classified accordingly?", - "How are different types of changes assessed and approved?", - "How do we know if a change was successful?", - "How are changes planned and coordinated with deployment?", - "How to ensure that information on planned changes are available to relevant parties?" - ], - requirements: [ - ["PR12.1", "All changes shall be registered and classified in a consistent manner. Classification shall be based on defined criteria and consider different types of changes, including emergency changes and major changes."], - ["PR12.2", "For each type of change, steps shall be defined for handling them in a consistent manner."], - ["PR12.3", "Changes shall be assessed in a consistent manner, taking into consideration benefits, risks, potential impact, effort and technical feasibility."], - ["PR12.4", "Changes shall be approved in a consistent manner. The required level of approval shall be determined based on defined criteria."], - ["PR12.5", "Changes shall be subject to a post implementation review as needed, and closed in a consistent manner."], - ["PR12.6", "A schedule of changes shall be maintained. It shall contain details of approved changes and intended deployment dates, which shall be communicated to interested parties."] - ], - setup: [ - "Set up a tool (e.g. ticket / workflow tool) supporting the recording and handling (classification, evaluation, approval, implementation, post implementation review) of changes.", - "Define a standardised way of recording requests for changes (RFCs) and resulting approved changes (sources and channels, required format, recording).", - "Define the criteria for identifying emergency changes, and a standardised way of dealing with them from recording to closure, including an emergency change review.", - "Identify well-known and recurring changes, create a standardised change for each and describe the concrete steps to manage it from recording to closure.", - "Create a schedule of changes (including those in releases to provide an overview of change implementation)." - ], - inputs: ["Requests for changes (RFCs)", "Information on planned releases and deployments"], - outputs: ["Change records", "Up-to-date schedule of changes", "Post implementation review reports", "Up-to-date list of (pre-defined) standard changes and step-by-step workflows for handling them"], - activities: [ - { name: "Manage change evaluation and approval", procedures: ["Register a change based on a request for change (RFC)", "Classify a change, including checking against major change and emergency change criteria", "Assess a change", "Approve or reject a change (considering special conditions for major or emergency changes)"] }, - { name: "Manage change implementation and review (in connection with RDM where applicable)", procedures: ["Plan and schedule a change (including technical and non-technical actions)", "Implement a change", "Perform a post implementation review (considering special conditions for major or emergency changes)", "Close a change"] } - ], - databases: [ - { name: "Change records (RFCs)", src: "FitSM-0 §6.8, §6.57 · FitSM-1 PR12.1", - desc: "Records of every request for change (a documented proposal for a change) and the resulting change — an alteration (addition, removal, modification, replacement) of a CI or another entity requiring change control — with classification (incl. major / emergency), assessment, approval, implementation, PIR and closure.", - usedBy: ["CONFM", "PM"] }, - { name: "Schedule of changes", src: "FitSM-1 PR12.6", - desc: "Up-to-date schedule containing details of approved changes and their intended deployment dates, communicated to interested parties. It is the basis for planning and scheduling releases.", - usedBy: ["RDM"] }, - { name: "Standard changes catalogue", src: "FitSM-2 PR12 · FitSM-1 PR12.2", - desc: "Up-to-date list of pre-defined standard changes (well-known, recurring changes that can be considered pre-approved) with step-by-step workflows for handling them.", - usedBy: [] }, - { name: "Post implementation review reports", src: "FitSM-0 §6.48 · FitSM-1 PR12.5", - desc: "Reviews performed after a change is implemented to determine whether it was successful; depth varies with the type and complexity of the change.", - usedBy: ["CSI"] } - ], - roles: roles("CHM", - ["Plan, schedule, prepare and moderate change advisory board (CAB) meetings.", "Maintain the list and descriptions of standard changes, together with relevant technical experts.", "Ensure that all requests for changes are processed effectively, and in a timely manner.", "Monitor the overall progress of change evaluation, approval and implementation.", "Review the change records in regular intervals, to identify trends or nonconformities or poor documentation / traceability."], - [{ name: "Change owner", count: "1 per change", tasks: [ - "Control and coordinate all activities in the lifecycle of a specific change.", - "Monitor the progress of change evaluation and implementation for this change.", - "Ensure that the change record is complete and up to date at any time from recording the RFC to completion of the post implementation review.", - "As applicable, communicate with the release owner of the release containing this change."] }], - [{ name: "Change advisory board (CAB)", type: "board", count: "1 board for a certain number of changes", specific: [ - "Evaluate non-standard changes, taking into account at least benefits, risks, potential impact, technical feasibility and effort / cost.", - "Decide on the approval of non-standard changes, based on the evaluation results.", - "Decide which changes can be considered pre-approved in the future."], - notes: ["The CAB should be composed of (all) relevant stakeholders of the changes that are currently subject to evaluation and approval.", "CAB meetings should take place at regular intervals, although the specific composition of the CAB may / will vary."] }]) - }, - - /* ───────────── PR13 RDM ───────────── */ - { - id: "RDM", num: "PR13", name: "Release & Deployment Management", group: "control", - pos: { x: 1150, y: 560 }, - objective: "To bundle changes into appropriate types of releases and to effectively deploy them", - questions: [ - "How are different release and deployment strategies applied to different CIs?", - "Which changes are included in which kinds of releases?", - "How can releases be planned and tested prior to deployment?", - "How do we know if a release was successful?", - "How can unsuccessful deployments be reversed?" - ], - requirements: [ - ["PR13.1", "Release and deployment strategies shall be defined, together with the service components and CIs to which they are applied. Strategies shall be aligned with the frequency and impact of releases as well as the technology supporting deployment."], - ["PR13.2", "Criteria for including approved changes in a release shall be defined, taking into consideration the applicable release and deployment strategy."], - ["PR13.3", "Deployment of releases shall be planned, including acceptance criteria, as needed."], - ["PR13.4", "Releases shall be built, tested and evaluated against acceptance criteria prior to being deployed. The extent of release testing shall be appropriate to the type of release and its potential impact on services."], - ["PR13.5", "Deployment preparation shall consider steps to be taken in case of unsuccessful deployment."], - ["PR13.6", "Deployment activities shall be evaluated for success or failure."] - ], - setup: [ - "Define a standardised way of defining and planning releases, based on approved changes and the schedule of changes.", - "Define criteria for identifying different types of releases, such as major, minor or emergency releases.", - "Define release and deployment strategies for all CIs under control of change management: the components and CIs they apply to and under what conditions, the frequency and manner of release, and the testing to be performed.", - "Define a way to record the results of release and deployment testing and evaluation of acceptance criteria." - ], - inputs: ["Information on approved changes", "Change schedule", "Any release and deployment planning constraints or requirements"], - outputs: ["Defined and successfully deployed releases", "Information / reports on the success and failure of releases"], - activities: [ - { name: "Release planning", procedures: ["Build a release, based on the applicable release and deployment strategy", "Test a release"] }, - { name: "Release deployment", procedures: ["Plan and perform communication and training for users and support staff", "Prepare deployment of a release", "Deploy a release", "Review a release for success", "Inform stakeholders of the results of the release", "Close a release"] } - ], - databases: [ - { name: "Release records", src: "FitSM-0 §6.54 · FitSM-2 PR13", - desc: "Records of each release — a set of one or more changes grouped together and deployed as a logical unit — including release type (major, minor, emergency), release plan, test results and evaluation against acceptance criteria, deployment outcome and success / failure reports.", - usedBy: ["CHM", "CONFM", "ISRM", "PM"] }, - { name: "Release & deployment strategies", src: "FitSM-0 §6.55 · FitSM-1 PR13.1", - desc: "The approaches taken to manage releases and their deployment for a given set of service components and CIs — e.g. continuous integration or fixed release cycles with emergency releases in between — covering planning, building, testing, evaluating, accepting and deploying.", - usedBy: [] } - ], - roles: roles("RDM", - ["Maintain the overall release planning, including release cycles.", "Manage the release and deployment strategies defined for the SMS.", "Apply the release and deployment strategies to defined groups of components, as appropriate.", "Review deployed releases for success."], - [{ name: "Release owner", count: "1 per release", tasks: [ - "Identify the appropriate release and deployment strategy for a specific release.", - "Control and coordinate the activities in the lifecycle of a specific release, including planning, building, testing and deploying.", - "Ensure that the required documentation of the release (including release plans) is complete and of adequate quality.", - "Act as a single point of contact for the release for all stakeholders of this release, including the change manager, affected change owners, developers, problem manager and customer representatives."] }]) - }, - - /* ───────────── PR14 CSI ───────────── */ - { - id: "CSI", num: "PR14", name: "Continual Service Improvement Management", group: "improve", - pos: { x: 1150, y: 90 }, - objective: "To plan, implement and review improvements to services and processes", - questions: [ - "How are opportunities for improving services and processes identified and evaluated?", - "How is the implementation of actions for improvement controlled and monitored?" - ], - requirements: [ - ["PR14.1", "Opportunities for improvement of services and processes shall be identified and registered, based on reports as well as results from measurements, assessments and audits of the SMS."], - ["PR14.2", "Opportunities for improvement shall be assessed to decide on necessary actions."], - ["PR14.3", "The implementation of actions for improvement shall be controlled in a consistent manner."] - ], - setup: [ - "Identify all relevant sources of potential suggestions for improvement.", - "Define a standardised way to record suggestions for improvements from the identified sources.", - "Set up a tool (e.g. ticket / workflow tool) supporting the recording and handling (including prioritisation, evaluation, approval) of suggestions for improvement." - ], - inputs: ["Suggestions for improvements", "Results from measurements, assessments and audits of the SMS (nonconformities, deficiencies in process effectiveness and efficiency, deficiencies in service performance)", "Customer feedback from service reviews, complaints and satisfaction analysis / surveys", "Other sources of improvements"], - outputs: ["Improvements to services or the SMS", "Requests for changes"], - activities: [ - { name: "Manage evaluation of improvements", procedures: ["Identify and register an opportunity / suggestion for improvement", "Evaluate an opportunity / suggestion for improvement"] }, - { name: "Manage implementation of improvements", procedures: ["Initiate an action to address an improvement", "Track the status and progress of improvement actions"] } - ], - databases: [ - { name: "Improvement register", src: "FitSM-2 PR14 · FitSM-0 §6.28", - desc: "Registered opportunities / suggestions for improvement from all identified sources, with their evaluation, priority, approval or rejection, and the improvement actions initiated with their status and progress. An improvement is an action to increase the conformity, effectiveness or efficiency of the SMS, a process or activity, or the quality or performance of a service or service component.", - usedBy: ["CHM"] } - ], - roles: roles("CSI", - ["Review the status and progress of ongoing improvements in regular intervals."], - [{ name: "Improvement owner", count: "1 per improvement", tasks: ["Maintain the improvement under their ownership.", "Coordinate the activities to implement the improvement."] }]) - } -]; - -/* - * Key interfaces (FitSM-2 “Key interfaces” tables). - * sender = text from the sending process's “To process / Output” table - * receiver = text from the receiving process's “From process / Input” table - * route = optional waypoints for drawing; pair = offset for two-way links - */ -const INTERFACES = [ - { from: "CRM", to: "SPM", items: ["Identified customer requirements"], - sender: "Identified customer requirements as a factor to be considered to identify demand for new or changed services", - receiver: "Identified customer requirements as a factor to be considered to identify demand for new or changed services" }, - { from: "SUPPM", to: "SPM", pair: 1, items: ["Information on suppliers"], - sender: "Information on suppliers as a basis for identifying suppliers involved in the delivery of a given service", - receiver: "Information on suppliers as a basis for identifying suppliers involved in the delivery of a given service" }, - { from: "SPM", to: "SUPPM", pair: 1, items: ["Information on internal and external suppliers involved in delivering a given service", "Plans for new or changed services"], - sender: "Information on internal and external suppliers involved in delivering a given service (part of plans for new or changed services) as a basis for the identification of new suppliers", - receiver: "Information on internal and external suppliers involved in delivering a given service (part of plans for new or changed services) as a basis for the identification of new suppliers" }, - { from: "SPM", to: "SLM", items: ["Service portfolio", "Service specifications"], - sender: "Service portfolio together with service specifications as a basis for creating the service catalogue", - receiver: "Service portfolio together with service specifications as a basis for creating the service catalogue" }, - { from: "SPM", to: "CHM", items: ["Requests for changes (RFCs)", "Plans for new or changed services"], route: [[410, 165], [830, 165]], - sender: "Requests for changes to trigger changes to configuration items (CIs) as required to implement plans for new or changed services", - receiver: "Request for change to trigger the CHM process (listed by CHM as an input from any process)" }, - { from: "CRM", to: "SLM", pair: 1, items: ["Information on customers", "Customer-specific service level requirements"], - sender: "Information on customers and identified customer-specific service level requirements (e.g. based on customer feedback or resulting from service reviews with customers) as a basis for defining SLAs", - receiver: "Information on customers and identified customer-specific service level requirements (e.g. based on customer feedback or resulting from service reviews with customers) as a basis for defining SLAs" }, - { from: "SLM", to: "CRM", pair: 1, items: ["Service catalogue", "SLAs", "Service reports"], - sender: "Service catalogue for available services that are offered to customers. SLAs reflecting what has been agreed with customers together with service reports to support service reviews with customers", - receiver: "Service catalogue for available services that are offered to customers. SLAs reflecting what has been agreed with customers together with service reports to support service reviews with customers" }, - { from: "SUPPM", to: "SLM", pair: 1, items: ["Information on suppliers"], - sender: "Information on suppliers as a basis for new or updated OLAs and UAs", - receiver: "Information on suppliers as a basis for defining OLAs and UAs" }, - { from: "SLM", to: "SUPPM", pair: 1, items: ["OLAs", "UAs", "Reports on operational targets"], - sender: "OLAs and UAs together with reports on operational targets to support supplier performance evaluation", - receiver: "OLAs and UAs together with reports on operational targets to support supplier performance evaluation" }, - { from: "SLM", to: "SRM", items: ["SLAs with agreed service targets (reporting requirements)", "Data from evaluation of SLAs, OLAs and UAs"], - sender: "SLAs with agreed service targets as a basis for identifying service reporting requirements, i.e. understanding the reporting requirements agreed in SLAs. Data from evaluation of SLAs, OLAs and UAs as a basis for reports", - receiver: "SLAs with agreed service targets as a basis for identifying service reporting requirements, i.e. understanding the reporting requirements agreed in SLAs. Data from evaluation of SLAs, OLAs and UAs as a basis for reports" }, - { from: "SLM", to: "SACM", items: ["SLAs with agreed availability and continuity targets"], - sender: "SLAs with agreed service availability and continuity targets as a basis for identifying overall availability and continuity requirements", - receiver: "SLAs with agreed service availability and continuity targets as a basis for identifying overall availability and continuity requirements" }, - { from: "SLM", to: "CAPM", items: ["SLAs with agreed capacity and performance targets"], - sender: "SLAs with agreed capacity and performance targets as a basis for identifying overall capacity and performance requirements", - receiver: "SLAs with agreed capacity and performance targets as a basis for identifying overall capacity and performance requirements" }, - { from: "SLM", to: "ISM", items: ["SLAs with agreed information security targets"], - sender: "SLAs with agreed information security targets as a basis for identifying overall security requirements", - receiver: "SLAs with agreed information security targets as a basis for identifying overall security requirements" }, - { from: "SLM", to: "ISRM", items: ["SLAs with agreed service targets"], - sender: "Service level agreements (SLAs) containing information on agreed service targets to enable prioritisation of incidents and service requests", - receiver: "SLAs containing information on agreed service targets to enable prioritisation of incidents and service requests", - note: "FitSM-2 v3.0.2 prints this output in the SPM interface table, while ISRM names SLM as its source. SLAs are an SLM output, so the diagram draws it as SLM → ISRM." }, - { from: "SACM", to: "SRM", items: ["Service availability data"], - sender: "Service availability data as a basis for reports", receiver: "Service availability data as a basis for reports" }, - { from: "CAPM", to: "SRM", items: ["Performance and utilisation data"], route: [[765, 300], [765, 104]], - sender: "Performance and utilisation data as a basis for reports", receiver: "Performance and utilisation data as a basis for reports" }, - { from: "SRM", to: "CRM", items: ["Relevant (service) reports"], route: [[500, 128]], - sender: "Relevant reports as a basis for managing customer relationships and customer satisfaction", - receiver: "Relevant reports as a basis for managing customer relationships and customer satisfaction" }, - { from: "SRM", to: "CSI", items: ["Service reports"], - sender: "Service reports as an information basis related to opportunities for improving services and the SMS", - receiver: "Service reports as an information basis related to opportunities for improving services and the SMS" }, - { from: "SACM", to: "CHM", items: ["Requests for changes (RFCs)"], - sender: "Requests for change addressing required updates or modifications to CIs as a basis for implementing the measures necessary to enable the IT service environment to meet identified availability and continuity requirements", - receiver: "Request for change to trigger the CHM process (listed by CHM as an input from any process)" }, - { from: "CAPM", to: "CHM", items: ["Requests for changes (RFCs)"], - sender: "Requests for changes addressing required updates or modifications to CIs as a basis for implementing the capacity planning to enable the IT service environment to meet identified capacity and performance requirements", - receiver: "Request for change to trigger the CHM process (listed by CHM as an input from any process)" }, - { from: "ISM", to: "CHM", items: ["Requests for changes (RFCs)"], - sender: "Requests for changes addressing required updates or modifications to CIs as a basis for implementing the information security controls as far as they relate to CIs supporting the services", - receiver: "Request for change to trigger the CHM process (listed by CHM as an input from any process)" }, - { from: "CRM", to: "CHM", items: ["Requests for changes (RFCs)"], route: [[232, 205], [232, 522], [800, 522]], - sender: "Requests for changes (e.g. to address insufficient customer satisfaction, feedback from service reviews or customer complaints)", - receiver: "Request for change to trigger the CHM process (listed by CHM as an input from any process)" }, - { from: "CRM", to: "CSI", items: ["Suggestions for improvement"], route: [[110, 28], [1150, 28]], - sender: "Suggestions for improvement (e.g. to address insufficient customer satisfaction, feedback from service reviews or customer complaints)", - receiver: "Suggestions for improving services and the SMS that require control and coordination through the CSI process (listed by CSI as an input from any process)" }, - { from: "ISRM", to: "PM", pair: 1, items: ["Trend information on incidents", "Incident tickets and reports"], - sender: "Trend information on incidents, including information from incident tickets and reports, to enable pattern and trend analysis", - receiver: "Trend information on incidents, including information from incident tickets and reports, to enable pattern and trend analysis" }, - { from: "PM", to: "ISRM", pair: 1, items: ["Known error database (KEDB)", "Known errors and workarounds"], - sender: "Known error database (KEDB) containing information on known errors and related workarounds to support the resolution of incidents caused by known errors", - receiver: "Known error database (KEDB) containing information on known errors and related workarounds to support the resolution of incidents caused by known errors" }, - { from: "ISRM", to: "CHM", items: ["Requests for changes (RFCs)"], - sender: "Requests for changes required to resolve incidents or to fulfil service requests", - receiver: "Request for change to trigger the CHM process (listed by CHM as an input from any process)" }, - { from: "PM", to: "CHM", items: ["Requests for changes (RFCs)"], - sender: "Requests for changes to resolve / eliminate problems", - receiver: "Request for change to trigger the CHM process (listed by CHM as an input from any process)" }, - { from: "CONFM", to: "ISRM", items: ["Configuration information (CMDB)"], route: [[870, 768], [370, 768]], - sender: "Configuration information from the CMDB to support process activities (listed by CONFM as an output to any process)", - receiver: "CMDB containing information on configuration items and their relationships to support the classification, prioritisation, escalation and resolution of incidents and the fulfilment of service requests" }, - { from: "CONFM", to: "PM", items: ["Configuration information (CMDB)"], - sender: "Configuration information from the CMDB to support process activities (listed by CONFM as an output to any process)", - receiver: "CMDB containing information on configuration items and their relationships to support the classification, prioritisation and investigation of problems" }, - { from: "CONFM", to: "RDM", pair: 1, items: ["Configuration information (CMDB)"], - sender: "Configuration information from the CMDB to support process activities (listed by CONFM as an output to any process)", - receiver: "Configuration information (CMDB) as a basis for informed decisions in deployment planning" }, - { from: "RDM", to: "CONFM", pair: 1, items: ["Information on the deployment of releases", "Changes to CIs included in the releases"], - sender: "Information on the deployment of releases (and the changes to CIs included in the releases) required to update the CMDB and (if necessary) introduce new CI types", - receiver: "Information on the deployment of releases (and the changes to CIs included in the releases) required to update the CMDB and (if necessary) introduce new CI types" }, - { from: "RDM", to: "ISRM", items: ["Information on planned or recently deployed releases"], route: [[460, 562]], - sender: "Information on planned or recently deployed releases to support incident resolution (e.g. to understand if incidents are potentially related to releases)", - receiver: "Information on planned or recently deployed releases to support incident resolution (e.g. to understand if incidents are potentially related to releases)" }, - { from: "CHM", to: "CONFM", pair: 1, items: ["Information on planned, approved and / or implemented changes to CIs"], - sender: "Information on planned, approved and / or implemented changes to CIs to be reflected in the CMDB", - receiver: "Information on the deployment of releases (and the changes to CIs included in the releases) required to update the CMDB and (if necessary) introduce new CI types", - note: "FitSM-2 v3.0.2 lists CHM as the source of this CONFM input, but the wording matches RDM’s output. Both CHM (changes to CIs) and RDM (deployed releases) keep the CMDB up to date." }, - { from: "CONFM", to: "CHM", pair: 1, items: ["Configuration information (CMDB)"], - sender: "Configuration information from the CMDB to support process activities (listed by CONFM as an output to any process)", - receiver: "Not listed explicitly by CHM; CONFM supplies configuration information to any process, including impact assessment of changes.", - note: "Implied by CONFM’s “To: Any” interface rather than a named row in FitSM-2." }, - { from: "CHM", to: "RDM", pair: 1, items: ["Approved and planned changes ready for deployment", "Change schedule with proposed deployment dates"], - sender: "Approved and planned changes that are ready for deployment to be considered for future / upcoming releases (depending on defined criteria and applicable release and deployment strategies). Change schedule with proposed deployment dates for planned and approved changes / basis for planning and scheduling releases", - receiver: "Approved and planned changes that are ready for deployment to be considered for future / upcoming releases (depending on defined criteria and applicable release and deployment strategies). Change schedule with proposed deployment dates for planned and approved changes / basis for planning and scheduling releases" }, - { from: "RDM", to: "CHM", pair: 1, items: ["Release records (information on deployed releases)"], - sender: "Information on deployed releases (release records) to allow for post implementation review of the bundled changes", - receiver: "Information on planned releases and deployments (CHM process input)" }, - { from: "CSI", to: "CHM", items: ["Requests for changes (RFCs)"], - sender: "Requests for changes to trigger the change management process, in order to implement improvements (where needed)", - receiver: "Request for change to trigger the CHM process (listed by CHM as an input from any process)" } -]; - -/* “Any process” interfaces — drawn as badges on the node, not as arrows */ -const ANY_INTERFACES = [ - { process: "CONFM", dir: "out", items: ["Configuration information (CMDB)"], - text: "Configuration information from the CMDB to support process activities" }, - { process: "CHM", dir: "in", items: ["Requests for changes (RFCs)"], - text: "Request for change to trigger the CHM process" }, - { process: "CSI", dir: "in", items: ["Suggestions for improvement"], - text: "Suggestions for improving services and the SMS that require control and coordination through the CSI process" } -]; diff --git a/index.html b/index.html index 01e0ba6..b0453f1 100644 --- a/index.html +++ b/index.html @@ -1,628 +1,54 @@ + - - - -FitSM Process Map - - - - - - + + + FitSM Process Map + + - -
-
-

FitSM Process Map

-

FitSM v3 · 14 processes · interfaces · select a process or an arrow

-
-
- -
- -
-
- -

Click a box for its details · click an arrow for the interface

- -
- -
-
Content from FitSM-0 v3.0, FitSM-1 v3.0.1, FitSM-2 v3.0.2 and FitSM-3 v3.0.1 by ITEMO e.V., licensed CC BY 4.0 — fitsm.eu. Process groupings are a study aid, not part of the standard.
- - - + + +
+
+
+ +
+
+

Loading

+
+ +

+
+ +
+

+

+
+ + + + diff --git a/package-lock.json b/package-lock.json new file mode 100644 index 0000000..bf27bca --- /dev/null +++ b/package-lock.json @@ -0,0 +1,13 @@ +{ + "name": "fitsm-process-map", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "fitsm-process-map", + "engines": { + "node": ">=22" + } + } + } +} diff --git a/package-lock.json.license b/package-lock.json.license new file mode 100644 index 0000000..53be6e0 --- /dev/null +++ b/package-lock.json.license @@ -0,0 +1,2 @@ +SPDX-FileCopyrightText: 2026 PNED G.I.E. +SPDX-License-Identifier: CC-BY-4.0 diff --git a/package.json b/package.json new file mode 100644 index 0000000..c8c43f9 --- /dev/null +++ b/package.json @@ -0,0 +1,12 @@ +{ + "name": "fitsm-process-map", + "private": true, + "type": "module", + "scripts": { + "check": "node scripts/check.js", + "test": "node --test" + }, + "engines": { + "node": ">=22" + } +} diff --git a/scripts/check.js b/scripts/check.js index 19dac5c..7517e07 100644 --- a/scripts/check.js +++ b/scripts/check.js @@ -1,106 +1,429 @@ +#!/usr/bin/env node // SPDX-FileCopyrightText: 2026 PNED G.I.E. // -// SPDX-License-Identifier: Apache-2.0 +// SPDX-License-Identifier: CC-BY-4.0 /* - * Consistency checks for the FitSM Process Map. No dependencies: `node scripts/check.js`. - * - fitsm-data.js loads and every cross-reference (interfaces, "used by", groups) resolves - * - every process has requirements, roles with tasks, databases and activities with procedures - * - nodes and routed arrows stay inside the diagram's viewBox - * - the inline script in index.html is valid JavaScript and the data file is referenced + * Consistency and contrast checks over the content store. + * Contract: specs/001-fitsm-process-map/contracts/check-cli.md + * + * node scripts/check.js [--content ] [--editions ] [--quiet] + * + * Exit 0: no errors. Exit 1: errors. Exit 2: could not run (missing or invalid files). + * Uses Node built-ins only. */ -"use strict"; -const fs = require("fs"); -const path = require("path"); -const vm = require("vm"); - -const root = path.join(__dirname, ".."); -const errors = []; -const fail = msg => errors.push(msg); - -/* ── Load data ───────────────────────────── */ -const ctx = {}; -vm.createContext(ctx); -try { - const src = fs.readFileSync(path.join(root, "fitsm-data.js"), "utf8"); - vm.runInContext(`${src}\n;this.__data = { GROUPS, GENERIC_TASKS, PROCESSES, INTERFACES, ANY_INTERFACES };`, ctx, { filename: "fitsm-data.js" }); -} catch (e) { - console.error(`fitsm-data.js failed to load: ${e.message}`); - process.exit(1); + +import { readFileSync, existsSync, readdirSync } from "node:fs"; +import { resolve, join, basename, dirname } from "node:path"; +import { execFileSync } from "node:child_process"; +import { fileURLToPath } from "node:url"; + +const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), ".."); +const FILES = ["edition", "processes", "requirements", "roles", "activities", "records", "interfaces", "map"]; +const ROLE_KINDS = ["owner", "manager", "case-owner", "staff", "specific"]; +const SIDES = ["n", "s", "e", "w"]; +const PATTERNS = { + code: /^[A-Z]{2,6}$/, + general: /^GR[1-7]$/, + processGroup: /^PR([1-9]|1[0-4])$/, + slug: /^[a-z][a-z0-9-]*$/, + activity: /^[A-Z]{2,6}\.(A\d+|S)$/, + colour: /^#[0-9a-fA-F]{6}$/, +}; + +/* ---------- CLI ---------- */ + +const args = process.argv.slice(2); +const opts = { content: null, editions: "content/editions.json", quiet: false }; +for (let i = 0; i < args.length; i++) { + if (args[i] === "--content") opts.content = args[++i]; + else if (args[i] === "--editions") opts.editions = args[++i]; + else if (args[i] === "--quiet") opts.quiet = true; + else fail(2, `Unknown option ${args[i]}`); +} + +const findings = []; +let itemsChecked = 0; + +function report(level, edition, file, item, message) { + findings.push({ level, line: `${level.padEnd(7)} ${edition ? `${edition}/` : ""}${file}: ${item}: ${message}` }); +} +function fail(code, message) { + console.error(message); + process.exit(code); +} + +/* ---------- loading ---------- */ + +function readJson(path, label) { + if (!existsSync(path)) fail(2, `error ${label}: file not found`); + try { + return JSON.parse(readFileSync(path, "utf8")); + } catch (e) { + fail(2, `error ${label}: not valid JSON (${e.message})`); + } +} + +const editions = []; +if (opts.content) { + editions.push({ id: basename(resolve(opts.content)), dir: resolve(opts.content) }); +} else { + const editionsPath = resolve(opts.editions); + const list = readJson(editionsPath, "editions.json"); + if (!list || !Array.isArray(list.editions)) fail(2, "error editions.json: editions: must be an array"); + if (!list.editions.some((e) => e.id === list.current)) { + report("error", "", "editions.json", "current", `"${list.current}" is not a listed edition`); + } + for (const e of list.editions) { + const dir = resolve(dirname(editionsPath), e.path); + if (!existsSync(dir)) fail(2, `error editions.json: editions.${e.id}: directory "${e.path}" not found`); + editions.push({ id: e.id, dir }); + } +} + +for (const edition of editions) checkEdition(edition); +checkScripts(); + +const errors = findings.filter((f) => f.level === "error").length; +const warnings = findings.length - errors; +for (const f of findings) console.error(f.line); +if (!opts.quiet) console.log(`${errors} errors, ${warnings} warnings, ${itemsChecked} items checked across ${editions.length} edition(s)`); +process.exit(errors ? 1 : 0); + +/* ---------- per-edition checks ---------- */ + +function checkEdition({ id: ed, dir }) { + const d = {}; + for (const name of FILES) d[name] = readJson(join(dir, `${name}.json`), `${ed}/${name}.json`); + const err = (file, item, msg) => report("error", ed, `${file}.json`, item, msg); + const warn = (file, item, msg) => report("warning", ed, `${file}.json`, item, msg); + + // 3. Shape + const shapeOk = + isObj(d.edition) && isObj(d.edition.documents) && + Array.isArray(d.processes) && + isObj(d.requirements) && Array.isArray(d.requirements.general) && Array.isArray(d.requirements.process) && + isObj(d.roles) && isObj(d.roles.generic) && Array.isArray(d.roles.roles) && + Array.isArray(d.activities) && Array.isArray(d.records) && Array.isArray(d.interfaces) && + isObj(d.map) && Array.isArray(d.map.lines) && isObj(d.map.stations) && isObj(d.map.routes) && isObj(d.map.grid) && isObj(d.map.transfer); + if (!shapeOk) { + err("edition", "shape", "one or more files do not have the expected top-level shape"); + return; + } + const docs = new Set(Object.keys(d.edition.documents)); + const hasSource = (file, item, source) => { + itemsChecked++; + if (!isObj(source) || !source.doc || !source.section) { + err(file, item, "missing source"); + return; + } + if (!docs.has(source.doc)) err(file, item, `source document "${source.doc}" is not in edition.json`); + }; + + // 4. Ids and processes + const codes = new Set(); + const aliases = new Map(); + for (const p of d.processes) { + if (!PATTERNS.code.test(p.code || "")) err("processes", p.code || "?", "code does not match ^[A-Z]{2,6}$"); + if (codes.has(p.code)) err("processes", p.code, "duplicate code"); + codes.add(p.code); + } + for (const p of d.processes) { + for (const a of p.aliases || []) { + if (!PATTERNS.code.test(a || "")) err("processes", "aliases", `"${a}" does not match ^[A-Z]{2,6}$`); + if (codes.has(a)) err("processes", "aliases", `"${a}" is already a process code`); + else if (aliases.has(a)) err("processes", "aliases", `"${a}" is used by more than one process`); + else aliases.set(a, p.code); + } + } + if (d.processes.length !== 14) err("processes", "count", `expected 14 processes, found ${d.processes.length}`); + + for (const p of d.processes) { + if (!isObj(p.objective) || !p.objective.text) err("processes", p.code, "missing objective"); + else hasSource("processes", `${p.code}.objective`, p.objective.source); + for (const [i, io] of (p.inputs || []).entries()) hasSource("processes", `${p.code}.inputs[${i}]`, io.source); + for (const [i, io] of (p.outputs || []).entries()) hasSource("processes", `${p.code}.outputs[${i}]`, io.source); + for (const [i, f] of (p.externalFlows || []).entries()) { + const item = `${p.code}.externalFlows[${i}]`; + if (!["in", "out"].includes(f.direction)) err("processes", item, `direction "${f.direction}" is not "in" or "out"`); + if (!f.party) err("processes", item, "party is empty"); + if (!f.item) err("processes", item, "item is empty"); + if (codes.has(f.party) || aliases.has(f.party)) err("processes", item, `party "${f.party}" is a process code; move this flow to interfaces.json`); + hasSource("processes", item, f.source); + } + } + + // Requirements + const groupIds = new Set(); + const reqIds = new Set(); + const groupByProcess = new Map(); + if (d.requirements.general.length !== 7) err("requirements", "general", `expected 7 general groups, found ${d.requirements.general.length}`); + if (d.requirements.process.length !== 14) err("requirements", "process", `expected 14 process groups, found ${d.requirements.process.length}`); + for (const [kind, groups] of [["general", d.requirements.general], ["process", d.requirements.process]]) { + for (const g of groups) { + const pattern = kind === "general" ? PATTERNS.general : PATTERNS.processGroup; + if (!pattern.test(g.id || "")) err("requirements", g.id || "?", `id does not match ${pattern}`); + if (groupIds.has(g.id)) err("requirements", g.id, "duplicate group id"); + groupIds.add(g.id); + hasSource("requirements", g.id, g.source); + if (kind === "general" && !g.name) err("requirements", g.id, "missing name"); + if (kind === "process") { + if (!codes.has(g.process)) err("requirements", g.id, `process "${g.process}" does not exist`); + else if (groupByProcess.has(g.process)) err("requirements", g.id, `process "${g.process}" already has group ${groupByProcess.get(g.process)}`); + else groupByProcess.set(g.process, g.id); + } + if (!Array.isArray(g.items) || !g.items.length) err("requirements", g.id, "items is empty"); + for (const item of g.items || []) { + if (!item.id || !item.id.startsWith(`${g.id}.`)) err("requirements", item.id || `${g.id}.?`, `id must start with "${g.id}."`); + if (reqIds.has(item.id)) err("requirements", item.id, "duplicate requirement id"); + reqIds.add(item.id); + if (!item.text) err("requirements", item.id, "missing text"); + hasSource("requirements", item.id, item.source); + } + } + } + for (const p of d.processes) { + if (!groupByProcess.has(p.code)) err("requirements", "process", `no requirement group for process "${p.code}"`); + if (p.requirements && groupByProcess.get(p.code) !== p.requirements) err("processes", p.code, `requirements "${p.requirements}" does not match group ${groupByProcess.get(p.code) || "(none)"}`); + } + + // Roles + for (const kind of ["owner", "manager", "case-owner", "staff"]) { + const g = d.roles.generic[kind]; + if (!isObj(g) || !Array.isArray(g.tasks) || !g.tasks.length) err("roles", `generic.${kind}`, "missing generic tasks"); + else hasSource("roles", `generic.${kind}`, g.source); + } + const roleIds = new Set(); + const kindsByProcess = new Map(); + for (const r of d.roles.roles) { + const item = r.id || "?"; + const [proc, slug] = (r.id || "").split("."); + if (!proc || !slug || !PATTERNS.slug.test(slug) || proc !== r.process) err("roles", item, "id must be ."); + if (roleIds.has(r.id)) err("roles", item, "duplicate role id"); + roleIds.add(r.id); + if (!codes.has(r.process)) err("roles", item, `process "${r.process}" does not exist`); + if (!ROLE_KINDS.includes(r.kind)) err("roles", item, `kind "${r.kind}" is not one of ${ROLE_KINDS.join(", ")}`); + if (!r.name) err("roles", item, "missing name"); + hasSource("roles", item, r.source); + if (!Array.isArray(r.tasks)) err("roles", item, "tasks must be an array (may be empty)"); + for (const [i, t] of (r.tasks || []).entries()) { + if (!t.text) err("roles", `${item}.tasks[${i}]`, "missing text"); + hasSource("roles", `${item}.tasks[${i}]`, t.source); + } + if (!kindsByProcess.has(r.process)) kindsByProcess.set(r.process, new Set()); + kindsByProcess.get(r.process).add(r.kind); + } + + // Activities + const activityIds = new Set(); + const activitiesByProcess = new Map(); + for (const a of d.activities) { + const item = a.id || "?"; + if (!PATTERNS.activity.test(a.id || "") || !a.id.startsWith(`${a.process}.`)) err("activities", item, "id must be .A or .S"); + if (activityIds.has(a.id)) err("activities", item, "duplicate activity id"); + activityIds.add(a.id); + if (!codes.has(a.process)) err("activities", item, `process "${a.process}" does not exist`); + if (!a.name) err("activities", item, "missing name"); + if (!Array.isArray(a.procedure) || !a.procedure.length) err("activities", item, "procedure is empty"); + hasSource("activities", item, a.source); + activitiesByProcess.set(a.process, (activitiesByProcess.get(a.process) || 0) + 1); + } + + // Records + const recordIds = new Set(); + for (const r of d.records) { + const item = r.id || "?"; + if (!PATTERNS.slug.test(r.id || "")) err("records", item, "id must be a slug"); + if (recordIds.has(r.id)) err("records", item, "duplicate record id"); + recordIds.add(r.id); + if (!r.name) err("records", item, "missing name"); + if (!isObj(r.definition) || !r.definition.text) err("records", item, "missing definition"); + else hasSource("records", `${item}.definition`, r.definition.source); + if (!Array.isArray(r.usedBy) || !r.usedBy.length) err("records", item, "usedBy is empty"); + for (const [i, u] of (r.usedBy || []).entries()) { + if (!codes.has(u.process)) err("records", `${item}.usedBy[${i}]`, `process "${u.process}" does not exist`); + if (u.derived !== true) warn("records", `${item}.usedBy[${i}]`, "derived is not true; FitSM does not list records per process"); + hasSource("records", `${item}.usedBy[${i}]`, u.source); + } + } + + // Interfaces + const interfaceIds = new Set(); + for (const i of d.interfaces) { + const item = i.id || "?"; + const [a, b] = i.processes || []; + if (!a || !b || a === b || !codes.has(a) || !codes.has(b)) { + for (const c of [a, b]) if (c && !codes.has(c)) err("interfaces", item, `process "${c}" does not exist`); + if (a && a === b) err("interfaces", item, "the two processes must differ"); + if (!a || !b) err("interfaces", item, "processes must list two codes"); + } + const expected = [a, b].filter(Boolean).sort().join("-"); + if (i.id !== expected) err("interfaces", item, `id must be "${expected}" (codes in alphabetical order)`); + if (interfaceIds.has(i.id)) err("interfaces", item, "duplicate interface"); + interfaceIds.add(i.id); + const descriptions = i.descriptions || []; + const flows = i.flows || []; + if (!descriptions.length && !flows.length) err("interfaces", item, "no description and no flow"); + for (const [k, desc] of descriptions.entries()) { + if (!desc.text) err("interfaces", `${item}.descriptions[${k}]`, "missing text"); + hasSource("interfaces", `${item}.descriptions[${k}]`, desc.source); + } + for (const [k, f] of flows.entries()) { + const fi = `${item}.flows[${k}]`; + if (![a, b].includes(f.from) || ![a, b].includes(f.to) || f.from === f.to) err("interfaces", fi, `flow ${f.from} → ${f.to} is not between ${a} and ${b}`); + if (!f.item) err("interfaces", fi, "missing item"); + hasSource("interfaces", fi, f.source); + } + itemsChecked++; + } + + // 7. Completeness per process (roles, activities, line membership) + const lineMembership = new Map(); + for (const line of d.map.lines) for (const s of line.stations || []) lineMembership.set(s, (lineMembership.get(s) || 0) + 1); + for (const p of d.processes) { + const kinds = kindsByProcess.get(p.code) || new Set(); + for (const kind of ["owner", "manager", "staff"]) if (!kinds.has(kind)) err("roles", p.code, `no role of kind "${kind}"`); + if (!activitiesByProcess.get(p.code)) err("activities", p.code, "no activity"); + if (!lineMembership.get(p.code)) err("map", "lines", `process "${p.code}" is on no line`); + } + + // 10. Map + const { grid, stations, routes, lines, transfer, background } = d.map; + const positive = (n) => Number.isInteger(n) && n > 0; + const gridOk = positive(grid.unit) && positive(grid.cols) && positive(grid.rows); + if (!gridOk) err("map", "grid", "unit, cols and rows must be positive integers"); + const cells = new Map(); + for (const [code, s] of Object.entries(stations)) { + if (!codes.has(code)) err("map", `stations.${code}`, `process "${code}" does not exist`); + if (!Number.isInteger(s.x) || !Number.isInteger(s.y) || s.x < 0 || s.y < 0 || (gridOk && (s.x > grid.cols || s.y > grid.rows))) err("map", `stations.${code}`, "position is outside the grid"); + if (!SIDES.includes(s.label)) err("map", `stations.${code}`, `label "${s.label}" is not n, s, e or w`); + const cell = `${s.x},${s.y}`; + if (cells.has(cell)) err("map", `stations.${code}`, `shares cell ${cell} with ${cells.get(cell)}`); + cells.set(cell, code); + } + for (const code of codes) if (!stations[code]) err("map", "stations", `no station for process "${code}"`); + for (const id of interfaceIds) if (!routes[id]) err("map", "routes", `no route for interface "${id}"`); + for (const [id, waypoints] of Object.entries(routes)) { + if (!interfaceIds.has(id)) { + err("map", `routes.${id}`, "no interface with this id"); + continue; + } + const [a, b] = id.split("-"); + if (!stations[a] || !stations[b] || !Array.isArray(waypoints)) continue; + // Waypoints are grid points: [x, y] non-negative integers within the grid. + let badWaypoint = false; + for (const [k, w] of waypoints.entries()) { + const isPoint = Array.isArray(w) && w.length === 2 && Number.isInteger(w[0]) && Number.isInteger(w[1]) && w[0] >= 0 && w[1] >= 0; + if (!isPoint || (gridOk && (w[0] > grid.cols || w[1] > grid.rows))) { + err("map", `routes.${id}`, `waypoint ${k} is not a grid point [x, y] within the grid`); + badWaypoint = true; + } + } + if (badWaypoint) continue; + const points = [[stations[a].x, stations[a].y], ...waypoints, [stations[b].x, stations[b].y]]; + for (let k = 1; k < points.length; k++) { + const dx = Math.abs(points[k][0] - points[k - 1][0]); + const dy = Math.abs(points[k][1] - points[k - 1][1]); + if (!(dx === 0 || dy === 0 || dx === dy)) err("map", `routes.${id}`, `segment ${k} from (${points[k - 1]}) to (${points[k]}) is not horizontal, vertical or 45°`); + } + } + const lineIds = new Set(); + if (!PATTERNS.colour.test(background || "")) err("map", "background", `colour "${background}" is not #rrggbb`); + if (!PATTERNS.colour.test(transfer.colour || "")) err("map", "transfer", `colour "${transfer.colour}" is not #rrggbb`); + else checkContrast("transfer", transfer.colour); + // The transfer stroke must be thinner than the line stroke the stylesheet draws (FR-003). + if (typeof transfer.width !== "number" || !(transfer.width >= 1 && transfer.width <= 10 && transfer.width < lineStrokeWidth())) { + err("map", "transfer", `width ${transfer.width} is not a number between 1 and 10 below the line stroke`); + } + if (grid.margin !== undefined) { + const m = grid.margin; + if (!isObj(m) || !Number.isInteger(m.x) || !Number.isInteger(m.y) || m.x < 0 || m.y < 0) { + err("map", "grid.margin", "x and y must be non-negative integers"); + } + } + for (const line of lines) { + const item = `lines.${line.id || "?"}`; + if (!PATTERNS.slug.test(line.id || "")) err("map", item, "id must be a slug"); + if (lineIds.has(line.id)) err("map", item, "duplicate line id"); + lineIds.add(line.id); + if (!line.name) err("map", item, "missing name"); + if (!Array.isArray(line.stations) || line.stations.length < 2) err("map", item, "a line needs at least two stations"); + for (const s of line.stations || []) if (!codes.has(s)) err("map", item, `process "${s}" does not exist`); + // labelSide is optional: line names are shown in the legend, not on the map. + if (line.labelSide !== undefined) { + if (!SIDES.includes(line.labelSide)) err("map", item, `labelSide "${line.labelSide}" is not n, s, e or w`); + const first = stations[(line.stations || [])[0]]; + if (first && first.label === line.labelSide) err("map", item, `labelSide "${line.labelSide}" is the same side as station ${line.stations[0]}'s label`); + } + if (!PATTERNS.colour.test(line.colour || "")) err("map", item, `colour "${line.colour}" is not #rrggbb`); + else checkContrast(item, line.colour); + // 12. Connectivity through same-line connections (warning) + const members = (line.stations || []).filter((s) => codes.has(s)); + if (members.length >= 2) { + const adjacency = new Map(members.map((m) => [m, []])); + for (const i of d.interfaces) { + const [a, b] = i.processes || []; + if (adjacency.has(a) && adjacency.has(b)) { adjacency.get(a).push(b); adjacency.get(b).push(a); } + } + const seen = new Set([members[0]]); + const queue = [members[0]]; + while (queue.length) for (const n of adjacency.get(queue.shift())) if (!seen.has(n)) { seen.add(n); queue.push(n); } + const unreachable = members.filter((m) => !seen.has(m)); + if (unreachable.length) warn("map", item, `stations ${members[0]} and ${unreachable.join(", ")} are not connected through this line`); + } + itemsChecked++; + } + itemsChecked += d.processes.length; + + function checkContrast(item, colour) { + if (!PATTERNS.colour.test(background || "")) return; + const ratio = contrast(colour, background); + if (ratio < 3) err("map", item, `colour ${colour} has contrast ${ratio.toFixed(1)}:1 against background (needs 3:1)`); + } +} + +/* ---------- 13. scripts parse ---------- */ + +function checkScripts() { + // Resolved from this script's location, so the check works from any working directory. + const files = []; + if (existsSync(join(ROOT, "src"))) for (const f of readdirSync(join(ROOT, "src"))) if (f.endsWith(".js")) files.push(join("src", f)); + files.push(join("scripts", "check.js")); + for (const file of files) { + if (!existsSync(join(ROOT, file))) continue; + try { + execFileSync(process.execPath, ["--check", join(ROOT, file)], { stdio: "pipe" }); + } catch (e) { + report("error", "", file, "syntax", String(e.stderr || e.message).trim().split("\n").pop()); + } + itemsChecked++; + } +} + +/* ---------- helpers ---------- */ + +/* Line stroke width in px, read from styles.css (`--connection-stroke`) so the stylesheet + * stays the single source; 6 if the stylesheet is missing or no longer declares it. */ +function lineStrokeWidth() { + const css = join(ROOT, "styles.css"); + const found = existsSync(css) ? readFileSync(css, "utf8").match(/--connection-stroke:\s*(\d+(?:\.\d+)?)/) : null; + return found ? Number(found[1]) : 6; +} + +function isObj(v) { + return v !== null && typeof v === "object" && !Array.isArray(v); +} + +/* WCAG 2.1 relative luminance and contrast ratio. */ +function luminance(hex) { + const channel = (c) => { + const s = c / 255; + return s <= 0.03928 ? s / 12.92 : ((s + 0.055) / 1.055) ** 2.4; + }; + const n = parseInt(hex.slice(1), 16); + return 0.2126 * channel(n >> 16) + 0.7152 * channel((n >> 8) & 255) + 0.0722 * channel(n & 255); } -const { GROUPS, GENERIC_TASKS, PROCESSES, INTERFACES, ANY_INTERFACES } = ctx.__data; - -/* ── Processes ───────────────────────────── */ -const VIEW = { w: 1260, h: 800 }, NODE = { hw: 78, hh: 33 }; -const ids = new Set(); -if (PROCESSES.length !== 14) fail(`expected 14 processes, found ${PROCESSES.length}`); - -PROCESSES.forEach((p, i) => { - const at = `process ${p.id || "#" + i}`; - if (!p.id || ids.has(p.id)) fail(`${at}: missing or duplicate id`); - ids.add(p.id); - if (!/^PR\d+$/.test(p.num)) fail(`${at}: invalid number "${p.num}"`); - if (!GROUPS[p.group]) fail(`${at}: unknown group "${p.group}"`); - if (!p.name || !p.objective) fail(`${at}: missing name or objective`); - - const { x, y } = p.pos || {}; - if (!(x - NODE.hw >= 0 && x + NODE.hw <= VIEW.w && y - NODE.hh >= 0 && y + NODE.hh <= VIEW.h)) fail(`${at}: node at (${x}, ${y}) is outside the diagram`); - - if (!p.requirements.length) fail(`${at}: no requirements`); - p.requirements.forEach(([rid, text]) => { - if (!rid.startsWith(p.num + ".")) fail(`${at}: requirement ${rid} does not belong to ${p.num}`); - if (!text) fail(`${at}: requirement ${rid} has no text`); - }); - - if (!p.roles.length) fail(`${at}: no roles`); - p.roles.forEach(r => { - const generic = r.noGeneric ? [] : (GENERIC_TASKS[r.type] || []); - if (!r.name || !r.count) fail(`${at}: role without name or count`); - if (!r.specific.length && !generic.length) fail(`${at}: role "${r.name}" has no tasks`); - }); - - if (!p.databases.length) fail(`${at}: no databases`); - p.databases.forEach(d => { - if (!d.name || !d.desc || !d.src) fail(`${at}: database "${d.name}" is missing name, description or source`); - (d.usedBy || []).forEach(u => { if (!PROCESSES.some(q => q.id === u)) fail(`${at}: database "${d.name}" used by unknown process "${u}"`); }); - }); - - if (!p.activities.length) fail(`${at}: no activities`); - p.activities.forEach(a => { if (!a.procedures.length) fail(`${at}: activity "${a.name}" has no procedures`); }); -}); - -/* ── Interfaces ──────────────────────────── */ -const pairs = new Set(); -INTERFACES.forEach((f, i) => { - const at = `interface #${i} ${f.from}→${f.to}`; - if (!ids.has(f.from) || !ids.has(f.to)) fail(`${at}: unknown process`); - if (f.from === f.to) fail(`${at}: points to itself`); - if (pairs.has(f.from + ">" + f.to)) fail(`${at}: duplicate`); - pairs.add(f.from + ">" + f.to); - if (!f.items || !f.items.length) fail(`${at}: no inputs/outputs listed`); - if (!f.sender || !f.receiver) fail(`${at}: missing relationship description`); - (f.route || []).forEach(([x, y]) => { - if (!(x >= 0 && x <= VIEW.w && y >= 0 && y <= VIEW.h)) fail(`${at}: route point (${x}, ${y}) is outside the diagram`); - }); -}); -ANY_INTERFACES.forEach((a, i) => { - if (!ids.has(a.process)) fail(`"any" interface #${i}: unknown process "${a.process}"`); - if (!["in", "out"].includes(a.dir)) fail(`"any" interface #${i}: dir must be "in" or "out"`); -}); - -/* ── Page ────────────────────────────────── */ -const html = fs.readFileSync(path.join(root, "index.html"), "utf8"); -if (!/