feature/61-run-config-templates

README.md

@@ -54,7 +54,7 @@ The plugin currently focuses on:
 * navigation support (`Go To Declaration`, symbol search, and related navigation paths)
 * completion for existing specification item IDs while editing `Covers:` entries in supported specification documents and coverage-tag targets in files supported by the OpenFastTrace Tag Importer
 * bundled OFT live templates for common specification items, including a scenario template
-* project-wide or selected-resource OFT tracing from `Tools | OpenFastTrace | Trace Project` or through custom OpenFastTrace run configurations
+* project-wide or selected-resource OFT tracing through custom OpenFastTrace run configurations, including pre-configured templates
 * clickable specification item IDs directly from the trace output window, including generated IDs created from coverage tags
 * IntelliJ Test Runner UI output for OpenFastTrace traces by default, grouped by source file, specification item, and trace link
 * quick access to the OpenFastTrace user guide from the IDE help menu
@@ -80,11 +80,11 @@ For manual IDE testing, launch a sandbox IDE with the plugin:
 
 ## Trace Settings
 
-After the sandbox IDE opens a project, configure trace scope under `Settings | Tools | OpenFastTrace`. By default, `Trace Project` scans the whole opened project. If you switch to selected-resource tracing, the plugin includes IntelliJ source roots, IntelliJ test roots, and one default additional project-relative path entry, `doc/`, until you change it. Additional files or directories are entered one per line.
+After the sandbox IDE opens a project, configure trace scope under `Settings | Tools | OpenFastTrace`. The plugin includes IntelliJ source roots, IntelliJ test roots, and one default additional project-relative path entry, `doc/`, until you change it. Additional files or directories are entered one per line.
 
 ## Run Configurations
 
-You can create and run a dedicated `OpenFastTrace` run configuration from the IDE's run/debug toolbar. The plugin traces the configured inputs in the background and shows the result in IntelliJ's Test Runner UI by default. The result tree groups source files, specification items, and trace links with pass/fail status and navigation back to source.
+You can create and run a dedicated `OpenFastTrace` run configuration from the IDE's run/debug toolbar. The plugin provides pre-configured templates (e.g., "User requirements", "Design and above", "Typical project", "Unfiltered") to quickly set up common scanning scenarios. The plugin traces the configured inputs in the background and shows the result in IntelliJ's Test Runner UI by default. The result tree groups source files, specification items, and trace links with pass/fail status and navigation back to source.
 
 Run configurations can select plain text output instead. In that mode, the plugin shows the text report in an IDE output tab with ANSI colors preserved. You can click specification item IDs in the report to jump to their declarations, including source-side items generated from coverage tags.
 

doc/changes/changelog.md

@@ -1,5 +1,6 @@
 # Changelog
 
+* [0.9.0](changes_0.9.0.md)
 * [0.8.1](changes_0.8.1.md)
 * [0.8.0](changes_0.8.0.md)
 * [0.7.0](changes_0.7.0.md)

doc/changes/changes_0.9.0.md

@@ -0,0 +1,23 @@
+# OpenFastTrace IntelliJ Plugin 0.9.0, released 2026-06-27
+
+Version 0.9.0 introduces specialized run configuration templates and improves the metadata shown by JetBrains plugin surfaces. Before installing or updating the plugin, users can now see a clearer overview of what OpenFastTrace support does in the IDE and read the current release notes from the maintained project changelog.
+
+Users can now quickly set up common OpenFastTrace scanning scenarios using pre-configured templates when creating a new run configuration:
+* **User requirements**: Scans `doc/` for core artifact types (`feat, req, scn, bconstr`).
+* **Design and above**: Scans `doc/` for all artifact types, including design and build artifacts.
+* **Typical project**: Scans `doc/` and all project source directories.
+* **Unfiltered**: Scans the entire project without any filters.
+
+The `Tools | OpenFastTrace | Trace Project` menu has been removed, as the new run configuration templates provide a more flexible and discoverable way to start an OpenFastTrace scan.
+
+## Bundled OpenFastTrace
+
+OpenFastTrace 4.5.0
+
+## Features
+
+* #61: Replace global OFT scan with specialized run configuration templates
+
+## Documentation
+
+* #51: Complete Marketplace-facing plugin metadata

doc/changesets/61-replace-global-scan-with-run-config-templates.md

@@ -0,0 +1,76 @@
+# GH-61 Feature: Replace global OFT scan with specialized run configuration templates
+
+## Goal
+
+Remove the redundant global OpenFastTrace scan menu and provide specialized run configuration templates to allow users to quickly set up common scanning scenarios.
+
+## Scope
+
+In scope:
+
+* Remove the 'Trace Project' action and its associated 'OpenFastTrace' menu group from the IntelliJ 'Tools' menu.
+* Introduce the following pre-configured run configuration templates:
+    - **User requirements**: Scans `doc/`, excludes source directories, filters for artifact types: `feat, req, scn, bconstr`.
+    - **Design and above**: Scans `doc/`, excludes source directories, filters for artifact types: `feat, req, scn, bconstr, arch, dsn, constr, bld`.
+    - **Typical project**: Scans `doc/` and all project source directories, with no artifact type filtering.
+    - **Unfiltered**: Scans the entire project (`.`) with no filters.
+* Leverage the IntelliJ `ConfigurationFactory` mechanism to provide these templates as sub-items in the "Add New Configuration" menu.
+
+Out of scope:
+
+* Adding new configuration options beyond what is currently supported.
+* Changing the trace execution engine or result presentation.
+
+## Design References
+
+* [System Requirements](../system_requirements.md)
+* [Quality Requirements](../design/quality_requirements.md)
+* [Runtime View](../design/runtime_view.md)
+
+## Strategy
+
+We will update `OftRunConfigurationType` to register multiple `ConfigurationFactory` instances. Each factory will be initialized with a specific `OftTraceSettingsSnapshot` to provide the template behavior. The `OftRunConfigurationFactory` will be modified to accept these initial settings.
+
+The global action `OftTraceProjectAction` and its registration in `plugin.xml` will be removed.
+
+## Task List
+
+- [x] Create and checkout a new Git branch `feature/61-run-config-templates`
+
+### Requirements And Design
+
+- [x] Update `doc/system_requirements.md` to remove the global trace action and document run configuration templates.
+- [x] Stop and ask user for a review of the system requirements
+- [x] Update `doc/design/runtime_view.md` to reflect the multi-factory approach for run configurations.
+- [x] Stop and ask user for a review of the design
+
+### Implementation
+
+- [ ] Implement the logic to ignore trailing numbers in `impl`, `utest`, and `itest` IDs during tracing.
+- [x] Modify `OftRunConfigurationFactory` to support template-based initialization.
+- [x] Update `OftRunConfigurationType` to register the four requested templates.
+- [x] Remove `OftTraceProjectAction.java` and any classes only used by it.
+- [x] Remove `Oft.ToolsMenu` and related actions from `src/main/resources/META-INF/plugin.xml`.
+
+### Verification
+
+- [ ] Add a verification test for ignoring trailing numbers in implementation and test artifact types.
+- [x] Update `OftRunConfigurationTest` to verify template-based initialization.
+- [ ] Run `check` task to ensure all tests pass and requirements trace is clean.
+- [ ] Keep the OpenFastTrace trace clean
+- [ ] Keep required build and plugin verification tasks green
+
+### Update user documentation
+
+- [x] Update `README.md` to reflect the removal of the Tools menu and the addition of run configuration templates.
+
+## Version and Changelog Update
+
+- [ ] Check if the current version mentioned in the build scripts and code parameters is the same as the latest GitHub release.
+- [x] Raise the version to 0.9.0 (this is a feature release)
+- [x] Write the changelog entry for 0.9.0 in `doc/changes/changes_0.9.0.md`
+- [x] Update `doc/changes/changelog.md` to include 0.9.0
+- [x] Update version in `build.gradle.kts`
+- [x] Write the bundled OpenFastTrace version into the fixed changelog location for 0.9.0
+- [x] Update release date to today
+- [ ] Ensure that issue list contains the GitHub issue number and title

doc/demo/plugin-demo.md

@@ -7,15 +7,15 @@ This script is for a short live demonstration of the plugin using the isolated e
 1. Install the IntelliJ Presenter Plugin.
 2. Install the OpenFastTrace IntelliJ plugin from the latest GitHub release as described below, or launch a sandbox IDE with `./gradlew manualTestIde`.
 3. Open `doc/demo/example` as the IntelliJ project for the demo.
-4. Open `Settings | Tools | OpenFastTrace`, select `Trace selected resources`, clear `Include IntelliJ source directories` and `Include IntelliJ test directories`, and set `Additional project-relative files or directories (one per line)` to:
+4. Open `Run | Edit Configurations...`, add an `OpenFastTrace` configuration, select `Trace selected resources`, clear `Include IntelliJ source directories` and `Include IntelliJ test directories`, and set `Additional project-relative files or directories (one per line)` to:
 
    ```text
    doc/demo/example
    ```
 
-   Apply the settings. The validation area should show no errors.
+   Apply the configuration. The validation area should show no errors.
 5. Open `excuse-of-the-day.md` and `excuse-of-the-day.sh`.
-6. Run `Tools | OpenFastTrace | Trace Project` once. The starting demo project should trace green.
+6. Run the `OpenFastTrace` configuration once. The starting demo project should trace green.
 
 ## Installing the Plugin from GitHub
 
@@ -37,11 +37,11 @@ For a local development build or rehearsal without installing a release artifact
 
 > Today we are going to make one tiny change to a tiny project and let the IDE keep track of the requirement trace chain while we work.
 > We use OpenFastTrace and the IntelliJ plugin to make our life easier.
-> The example is deliberately small. But the concepts of working with requirement tracing translates nicely to larger projects.
+> The example is deliberately small. But the concept of working with requirement tracing translates nicely to larger projects.
 
 ### 1. Show Trace Scope Configuration
 
-Open `Settings | Tools | OpenFastTrace` and show the selected-resource configuration from the preparation: `Trace selected resources`, both IntelliJ directory checkboxes cleared, and the additional paths set to `doc/demo/example`.
+Open the `OpenFastTrace` run configuration editor and show the selected-resource configuration from the preparation: `Trace selected resources`, both IntelliJ directory checkboxes cleared, and the additional paths set to `doc/demo/example`.
 
 > The demonstration has a narrow scope. A Markdown specification and the shell implementation, both found under a `doc/demo/example` in this project.
 > Every trace run now checks only the files we want in this example.
@@ -50,7 +50,7 @@ Open `Settings | Tools | OpenFastTrace` and show the selected-resource configura
 
 Open `excuse-of-the-day.md` and point out the highlighted OFT item IDs, `Needs:`, and `Covers:` entries.
 
-> Let's first take look at a specification file.
+> Let's first take a look at a specification file.
 > This is still plain Markdown. The IDE just stops treating the trace parts like wallpaper, which is helpful to identify OFT specification items in text.
 
 ### 3. Find the Existing Feature
@@ -100,7 +100,7 @@ Run `Tools | OpenFastTrace | Trace Project`. The trace should be red because `ds
 
 In `excuse-of-the-day.sh`, add the coverage tag `# [impl->dsn~homework-excuse~1]`. Type the target side partially and invoke completion after `impl->` to select `dsn~homework-excuse~1`, then point out the highlighted tag.
 
-> The script stays ordinary shell. The OFT tag is a comment for Bash and evidence for the trace.
+> The script stays an ordinary shell. The OFT tag is a comment for Bash and evidence for the trace.
 
 ### 11. Run the Green Trace and Open the Guide
 

doc/design/building_block_view.md

@@ -238,29 +238,28 @@ Covers:
 Needs: bld, itest
 
 ### Trace Configuration Integration
-`dsn~trace-configuration-integration~1`
+`dsn~trace-configuration-integration~2`
 
-The plugin provides a trace-configuration component that stores OpenFastTrace trace-scope settings per IntelliJ project and through dedicated run configurations. It exposes those settings through project configuration UI and the run configuration editor, resolves the selected-resource options and filters into a normalized OpenFastTrace input set and filter criteria, stores the run-configuration result-view selection, treats the IntelliJ Test Runner UI as the result-view default when no selection is stored, and owns the plugin resource used as the OpenFastTrace run-configuration icon.
+The plugin provides a trace-configuration component that stores OpenFastTrace trace-scope settings through dedicated run configurations. It provides pre-configured templates for common scanning scenarios. It exposes those settings through the run configuration editor, resolves the selected-resource options and filters into a normalized OpenFastTrace input set and filter criteria, stores the run-configuration result-view selection, treats the IntelliJ Test Runner UI as the result-view default when no selection is stored, and owns the plugin resource used as the OpenFastTrace run-configuration icon.
 
 Covers:
 - `scn~test-runner-as-default-run-configuration-result-view~1`
 - `scn~select-plain-text-trace-result-view~1`
 - `scn~select-test-runner-trace-result-view~1`
 - `scn~show-openfasttrace-icon-for-run-configurations~1`
+- `scn~use-run-configuration-templates~1`
 
 Needs: impl, itest
 
 ### Trace Action Integration
-`dsn~trace-action-integration~2`
+`dsn~trace-action-integration~3`
 
-The plugin provides a trace-action component that contributes an `OpenFastTrace` action group with a `Trace Project` action under the global `Tools` menu. This component is responsible for exposing the entry only in an opened project context and for handing the action invocation to trace-configuration resolution, trace execution, and the default IntelliJ Test Runner UI presentation.
+The plugin provides a trace-action component that is responsible for handing the trace invocation to trace-configuration resolution, trace execution, and the default IntelliJ Test Runner UI presentation.
 
 Covers:
-- `scn~show-trace-project-action-in-tools-menu~1`
-- `scn~disable-trace-project-action-without-open-project~1`
-- `scn~run-trace-project-in-background~1`
-- `scn~show-trace-project-in-test-runner-ui-by-default~1`
-- `scn~reject-trace-project-without-valid-project-path~1`
+- `scn~run-trace-project-in-background~2`
+- `scn~show-trace-result-in-test-runner-ui-by-default~2`
+- `scn~reject-trace-without-valid-project-path~1`
 
 Needs: impl, itest
 
@@ -272,9 +271,9 @@ The plugin provides a trace-execution service that accepts the effective OpenFas
 Because OpenFastTrace discovers importers and reporters through Java `ServiceLoader`, this service executes OFT import and report-rendering calls with the plugin class loader as the thread context class loader and restores the previous context loader afterward.
 
 Covers:
-- `scn~run-trace-project-in-background~1`
+- `scn~run-trace-project-in-background~2`
 - `scn~trace-selected-project-resources~1`
-- `scn~reject-trace-project-without-valid-project-path~1`
+- `scn~reject-trace-without-valid-project-path~1`
 - `scn~show-successful-trace-output-in-ide-output-window~2`
 - `scn~show-resolved-trace-inputs-in-trace-output-window~1`
 - `scn~show-failing-trace-output-in-ide-output-window~1`