@abarcenas/ai-workflow-template 1.23.0 → 1.26.0

package/.agents/skills/architecture-blueprint-generator/SKILL.md

@@ -5,6 +5,9 @@ description: 'Comprehensive project architecture blueprint generator that analyz
 
 # Comprehensive Project Architecture Blueprint Generator
 
+> **Pre-discovery:** Load the `context-map` skill first to build a scoped file-level map via graphify. The context map feeds into the full blueprint below.
+> **Graphify:** All codebase discovery uses `graphify query`, `graphify path`, and `graphify explain` against `graphify-out/graph.json`. Grep/glob/read are fallbacks only when graphify returns no results.
+
 ## Configuration Variables
 ${PROJECT_TYPE="Auto-detect|.NET|Java|React|Angular|Python|Node.js|Flutter|Other"} <!-- Primary technology -->
 ${ARCHITECTURE_PATTERN="Auto-detect|Clean Architecture|Microservices|Layered|MVVM|MVC|Hexagonal|Event-Driven|Serverless|Monolithic|Other"} <!-- Primary architectural pattern -->
@@ -19,18 +22,45 @@ ${FOCUS_ON_EXTENSIBILITY=true|false} <!-- Emphasize extension points and pattern
 
 "Create a comprehensive 'Project_Architecture_Blueprint.md' document that thoroughly analyzes the architectural patterns in the codebase to serve as a definitive reference for maintaining architectural consistency. Use the following approach:
 
+### 0. Graphify-First Discovery
+
+Before any grep, glob, or manual file reads, leverage the project's knowledge graph for token-efficient discovery:
+
+**0a. Bootstrap the graph if needed:**
+If `graphify-out/graph.json` does not exist, generate it first:
+```
+graphify .
+```
+This builds the knowledge graph with AST-extracted relationships and community structure. All subsequent discovery steps query the graph.
+
+**0b. Architecture detection via graph queries (primary):**
+- `graphify query "architecture pattern layers dependencies"` — discover architectural structure
+- `graphify query "technology stack frameworks packages imports"` — detect tech stack
+- `graphify query "key interfaces abstractions design patterns"` — identify core abstractions
+- `graphify query "cross-cutting concerns authentication logging configuration"` — find cross-cutting concern implementations
+
+**0c. Relationship mapping via graph (primary):**
+- `graphify path "<ComponentA>" "<ComponentB>"` — trace dependency chains between subsystems
+- `graphify explain "<component>"` — deep-dive on a single node's connections and patterns
+- `graphify query "circular dependency"` — detect layer violations and dependency cycles
+
+**0d. Broad architecture scan:**
+Read `graphify-out/GRAPH_REPORT.md` `## Communities` and `## God Nodes` sections for community structure and hub nodes. Use `graphify-out/wiki/index.md` for agent-navigable wiki if it exists.
+
+**0e. Fallback to grep/glob/read:**
+Only when graphify queries return no relevant results (rare for well-structured codebases), fall back to grep/glob/file-reads. Graphify subgraph results are typically 200-800 tokens vs. 3000+ tokens for raw grep output.
+
 ### 1. Architecture Detection and Analysis
-- ${PROJECT_TYPE == "Auto-detect" ? "Analyze the project structure to identify all technology stacks and frameworks in use by examining:
-  - Project and configuration files
-  - Package dependencies and import statements
-  - Framework-specific patterns and conventions
-  - Build and deployment configurations" : "Focus on ${PROJECT_TYPE} specific patterns and practices"}
-  
-- ${ARCHITECTURE_PATTERN == "Auto-detect" ? "Determine the architectural pattern(s) by analyzing:
-  - Folder organization and namespacing
-  - Dependency flow and component boundaries
-  - Interface segregation and abstraction patterns
-  - Communication mechanisms between components" : "Document how the ${ARCHITECTURE_PATTERN} architecture is implemented"}
+- ${PROJECT_TYPE == "Auto-detect" ? "Use graphify queries to identify all technology stacks and frameworks in use:
+  - `graphify query \"technology stack frameworks dependencies imports\"` for tech stack
+  - `graphify query \"build configuration deployment infrastructure\"` for build/deploy config
+  - Read `graphify-out/GRAPH_REPORT.md` `## Communities` for community-level technology groupings" : "Focus on ${PROJECT_TYPE} specific patterns and practices"}
+
+- ${ARCHITECTURE_PATTERN == "Auto-detect" ? "Determine the architectural pattern(s) by querying the graph structure:
+  - `graphify query \"layer dependency direction boundaries\"` reveals dependency flow
+  - `graphify query \"interfaces abstractions contract segregation\"` reveals interface patterns
+  - `graphify path` between key subsystems reveals communication mechanisms
+  - `graphify explain \"<layer-name>\"` deep-dives into each architectural layer" : "Document how the ${ARCHITECTURE_PATTERN} architecture is implemented"}
 
 ### 2. Architectural Overview
 - Provide a clear, concise explanation of the overall architectural approach
@@ -39,17 +69,29 @@ ${FOCUS_ON_EXTENSIBILITY=true|false} <!-- Emphasize extension points and pattern
 - Note any hybrid architectural patterns or adaptations of standard patterns
 
 ### 3. Architecture Visualization
+
+Extract component relationships from the graph before building diagrams:
+- `graphify query "component subsystem module relationships dependencies"` — discover subsystems
+- `graphify path "<SubsystemA>" "<SubsystemB>"` — verify dependency directions between specific subsystems
+- `graphify explain "<subsystem>"` — deep-dive into a subsystem's internal structure and connections
+- Use `graphify-out/GRAPH_REPORT.md` `## Surprising Connections` for non-obvious cross-boundary links
+
 ${DIAGRAM_TYPE != "None" ? `Create ${DIAGRAM_TYPE} diagrams at multiple levels of abstraction:
-- High-level architectural overview showing major subsystems
-- Component interaction diagrams showing relationships and dependencies
-- Data flow diagrams showing how information moves through the system
+- High-level architectural overview showing major subsystems (from graph community structure)
+- Component interaction diagrams showing relationships and dependencies (from graph edges)
+- Data flow diagrams showing how information moves through the system (from `graphify path` traces)
 - Ensure diagrams accurately reflect the actual implementation, not theoretical patterns` : "Describe the component relationships based on actual code dependencies, providing clear textual explanations of:
-- Subsystem organization and boundaries
-- Dependency directions and component interactions
-- Data flow and process sequences"}
+- Subsystem organization and boundaries (from graph communities)
+- Dependency directions and component interactions (from graph edges)
+- Data flow and process sequences (from `graphify path` traces)"}
 
 ### 4. Core Architectural Components
-For each architectural component discovered in the codebase:
+Discover components via the graph first, then deep-dive:
+- Identify major components from `graphify-out/GRAPH_REPORT.md` `## God Nodes` (hub nodes with highest degree)
+- Use `graphify explain "<component>"` to get all connected nodes and relationships for each god node
+- Use `graphify path "<component>" "<other>"` to trace specific interaction patterns between components
+
+For each architectural component discovered:
 
 - **Purpose and Responsibility**:
   - Primary function within the architecture
@@ -321,6 +363,9 @@ Create a clear architectural guide for implementing new features:
 
 Include information about when this blueprint was generated and recommendations for keeping it updated as the architecture evolves.
 
+### Post-Generation: Keep Graph Current
+After the blueprint is generated, run `graphify update .` to incrementally re-extract any changed files. This keeps the graph aligned with newly documented architecture understanding, so future queries (`graphify query`, `graphify path`, `graphify explain`) return up-to-date results without rebuilding the entire graph.
+
 ### ${INCLUDES_DECISION_RECORDS ? "18" : INCLUDES_CODE_EXAMPLES ? "17" : "16"}. Populate Agent Knowledge Base
 
 Write the discovered architecture details into the persistent knowledge system so all orchestrator agents (researcher, architect, implementer, coder, tracker) inherit this context without rediscovery:

package/.agents/skills/context-map/SKILL.md

@@ -5,6 +5,9 @@ description: "Generate a map of all files relevant to a task before making chang
 
 # Context Map
 
+> **Wired into:** `architecture-blueprint-generator` loads this skill as its pre-discovery step to build a scoped file-level map before generating the full blueprint.
+> **Graphify:** All discovery uses `graphify query`, `graphify path`, and `graphify explain` against `graphify-out/graph.json`. Grep/glob are fallbacks only.
+
 Before implementing any changes, analyze the codebase and create a context map.
 
 ## Task
@@ -13,10 +16,30 @@ Before implementing any changes, analyze the codebase and create a context map.
 
 ## Instructions
 
-1. Search the codebase for files related to this task
-2. Identify direct dependencies (imports/exports)
-3. Find related tests
-4. Look for similar patterns in existing code
+### Graphify-First Discovery
+
+1. **Bootstrap graph if needed:** Check `graphify-out/graph.json`. If missing, run `graphify .` first. The graph provides relationship data that grep alone cannot discover.
+
+2. **Discover related files:** Use `graphify query "{{task_description}}"` to find files and nodes relevant to the task. For multi-concept tasks, run separate queries per concept and merge results.
+
+3. **Identify direct dependencies:** Use `graphify path "<source>" "<target>"` between key components to trace dependency chains. This reveals import/export relationships without scanning every file.
+
+4. **Find related tests:** Use `graphify query "test spec <task_keywords>"` to surface test files connected to the relevant components.
+
+5. **Discover similar patterns:** Use `graphify explain "<pattern_or_component>"` to find existing implementations and connected nodes that follow the same pattern.
+
+### Fallback (graphify unavailable or no results)
+
+If `graphify-out/graph.json` is missing and cannot be generated, or queries return no results:
+
+1. Search the codebase for files related to this task (grep/glob)
+2. Identify direct dependencies (imports/exports via grep)
+3. Find related tests (glob `**/*.test.*` / `**/*.spec.*`)
+4. Look for similar patterns in existing code (grep for class/function patterns)
+
+### Post-Generation
+
+After the context map is created, run `graphify update .` to sync the graph with any newly identified relationships. This keeps future context-map invocations efficient.
 
 ## Output Format
 

package/.agents/skills/conventional-commit/SKILL.md

@@ -17,13 +17,13 @@ description: "Prompt and workflow for generating conventional commit messages us
 2. Run `git diff` or `git diff --cached` to inspect changes.
 3. Stage your changes with `git add <file>`.
 4. Construct your commit message using the following XML structure.
-5. After generating your commit message, Copilot will automatically run the following command in your integrated terminal (no confirmation needed):
+5. Run the following command in your terminal:
 
 ```bash
 git commit -m "type(scope): description"
 ```
 
-6. Just execute this prompt and Copilot will handle the commit for you in the terminal.
+6. Run the commit command in your terminal.
 
 ### Commit Message Structure
 

package/.agents/skills/github-issues/SKILL.md

@@ -87,7 +87,7 @@ State values: `open`, `closed`
 ```json
 {
   "owner": "github",
-  "repo": "awesome-copilot",
+  "repo": "example-project",
   "title": "[Bug] Login page crashes when using SSO",
   "body": "## Description\nThe login page crashes when users attempt to authenticate using SSO.\n\n## Steps to Reproduce\n1. Navigate to login page\n2. Click 'Sign in with SSO'\n3. Page crashes\n\n## Expected Behavior\nSSO authentication should complete and redirect to dashboard.\n\n## Actual Behavior\nPage becomes unresponsive and displays error.\n\n## Environment\n- Browser: [To be filled]\n- OS: [To be filled]\n\n## Additional Context\nReported by user.",
   "labels": ["bug"]
@@ -103,7 +103,7 @@ State values: `open`, `closed`
 ```json
 {
   "owner": "github",
-  "repo": "awesome-copilot",
+  "repo": "example-project",
   "title": "[Feature] Add dark mode support",
   "body": "## Summary\nAdd dark mode theme option for improved user experience and accessibility.\n\n## Motivation\n- Reduces eye strain in low-light environments\n- Increasingly expected by users\n- Improves accessibility\n\n## Proposed Solution\nImplement theme toggle with system preference detection.\n\n## Acceptance Criteria\n- [ ] Toggle switch in settings\n- [ ] Persists user preference\n- [ ] Respects system preference by default\n- [ ] All UI components support both themes\n\n## Alternatives Considered\nNone specified.\n\n## Additional Context\nHigh priority request.",
   "labels": ["enhancement", "high-priority"]

package/.agents/skills/graphify-framework-aware/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: graphify-framework-aware
+description: Prepares framework-aware exclusions before graphify knowledge graph generation. Invoke alongside /graphify. Automatically detects Angular, Hugo, Next.js, Svelte, Jekyll, Flutter, WordPress, and Docusaurus projects and excludes their boilerplate files so the graph focuses on your custom code. Triggers on: /graphify, graphify, knowledge graph, codebase graph.
+license: MIT
+allowed-tools: Bash
+---
+
+# graphify-framework-aware
+
+Automatically detects your project's framework and configures `.graphifyignore` to exclude framework boilerplate so graphify's knowledge graph focuses on your custom code.
+
+## When to Use
+
+Invoke this skill BEFORE running the standard `/graphify` pipeline. The skill is idempotent — running it multiple times is safe, and it will not duplicate patterns.
+
+Use when:
+- Running `/graphify` on a project for the first time
+- Running `/graphify --update` to rebuild an existing graph
+- After adding a new framework to a project
+- After changing build tooling or project structure
+
+Skip when:
+- The project has no supported framework markers
+- The `.graphifyignore` was already generated and the project structure hasn't changed
+- Graph is already built and framework exclusions were already applied
+
+## Workflow
+
+### Step 1: Apply framework exclusions
+
+Run the detection and apply script:
+
+```bash
+python3 <skill-base>/scripts/fw-exclude.py apply <project-path>
+```
+
+This script:
+1. Scans the project root for framework marker files (e.g., `angular.json`, `hugo.toml`)
+2. Generates appropriate `.graphifyignore` patterns for each detected framework
+3. Idempotently writes/updates `.graphifyignore` between marker comments
+
+The script outputs a one-line summary:
+```
+graphify-framework-aware: detected angular, nextjs — wrote 8 exclusion patterns to .graphifyignore
+```
+
+If no frameworks are detected, the script exits with code 2 and prints:
+```
+No supported frameworks detected.
+```
+
+### Step 2: Inspect the result (optional)
+
+To preview what will be excluded without modifying files:
+
+```bash
+python3 <skill-base>/scripts/fw-exclude.py show <project-path>
+```
+
+To see detected frameworks as JSON:
+
+```bash
+python3 <skill-base>/scripts/fw-exclude.py detect <project-path>
+```
+
+### Step 3: Proceed with graphify
+
+After exclusions are applied, invoke the standard graphify pipeline:
+
+```
+invoke skill: "graphify"
+```
+
+The `.graphifyignore` file will be read by graphify's detection step, and framework boilerplate files will be excluded from the knowledge graph.
+
+### Step 4: Verify (optional)
+
+Check the generated `.graphifyignore` at the project root. The framework patterns are in a clearly delimited section:
+
+```
+# ===== graphify-framework-aware (auto-generated) =====
+# auto-detected framework: angular
+**/*.spec.ts
+**/*.harness.ts
+e2e/
+...
+# ===== end graphify-framework-aware =====
+```
+
+User-added patterns outside this block are never modified. To re-include a framework-excluded path, add a `!` negation pattern anywhere *after* the marker block (graphify reads `.graphifyignore` with last-match-wins semantics).
+
+## Supported Frameworks
+
+| Framework | Marker |
+|-----------|--------|
+| Angular | `angular.json` |
+| Next.js | `next.config.{js,ts,mjs}` |
+| Svelte | `svelte.config.js` |
+| Hugo | `hugo.{toml,yaml,json}` |
+| Jekyll | `_config.yml` |
+| Docusaurus | `docusaurus.config.{js,ts}` |
+| Flutter | `pubspec.yaml` (content-verified) |
+| WordPress | `wp-config.php` |
+
+See [Framework Registry](./references/framework-registry.md) for the full list of exclusion patterns per framework and instructions for adding new frameworks.
+
+## Script Reference
+
+[`scripts/fw-exclude.py`](./scripts/fw-exclude.py) — Python 3.10+, no dependencies beyond stdlib.
+
+```
+usage: fw-exclude.py <detect|show|apply> <project-path>
+
+detect  Print JSON of detected frameworks and their markers.
+show    Print FW exclusion patterns (dry-run, no files written).
+apply   Idempotently write/update .graphifyignore with FW patterns.
+```
+
+## Interaction with graphify
+
+- graphify reads `.graphifyignore` (and falls back to `.gitignore`) during its `detect()` step
+- Framework patterns are appended with last-match-wins semantics — user `!` patterns override them
+- Directories already skipped by graphify's built-in `_SKIP_DIRS` (`node_modules/`, `.next/`, `.angular/`, `dist/`, `build/`, etc.) are NOT duplicated in the generated patterns
+- This skill must run **before** invoking the graphify skill so the `.graphifyignore` is in place when graphify scans files
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| "No supported frameworks detected" | Project may use an unsupported framework. Add markers to `fw-exclude.py` or create `.graphifyignore` manually. |
+| Too many files excluded | Check `.graphifyignore` marker block. Add `!` negation patterns after the block to re-include. |
+| `pubspec.yaml` falsely detected as Flutter | Script checks for `flutter` keyword in the file content. Add `!` patterns if needed. |
+| Hugo `config.toml` not detected | Script verifies content for Hugo-specific keys (`baseURL`, `title`). Rename to `hugo.toml` or add patterns manually. |

package/.agents/skills/graphify-framework-aware/references/framework-registry.md

@@ -0,0 +1,95 @@
+# Framework Exclusion Registry
+
+This document defines the framework detection markers and exclusion patterns used by `graphify-framework-aware`. Each framework entry includes its detection markers, default exclusions, and any special heuristics applied.
+
+## Adding a New Framework
+
+1. Add detection marker(s) to `FRAMEWORK_MARKERS` in `scripts/fw-exclude.py`.
+2. Add exclusion patterns to `FRAMEWORK_EXCLUDES`.
+3. If complex detection logic is needed (e.g., Hugo theme detection), add it to the `_post_process_excludes()` function.
+4. Update this document with the new framework's entry.
+
+## Supported Frameworks
+
+### Angular
+
+| Attribute | Value |
+|-----------|-------|
+| **Marker file** | `angular.json` |
+| **Excluded** | `**/*.spec.ts`, `**/*.harness.ts`, `e2e/`, `src/environments/`, `karma.conf.js`, `src/test.ts` |
+| **Kept** | `src/app/` (user components, services, modules), `src/assets/` |
+| **Already handled by graphify** | `.angular/`, `node_modules/`, `dist/` |
+
+### Next.js
+
+| Attribute | Value |
+|-----------|-------|
+| **Marker file** | `next.config.js`, `next.config.ts`, `next.config.mjs` |
+| **Excluded** | `next-env.d.ts`, `out/` |
+| **Kept** | `src/app/`, `src/pages/`, `src/components/` |
+| **Already handled by graphify** | `.next/`, `node_modules/` |
+
+### Svelte / SvelteKit
+
+| Attribute | Value |
+|-----------|-------|
+| **Marker file** | `svelte.config.js` |
+| **Excluded** | `build/`, `**/*.test.ts` |
+| **Kept** | `src/` (all user code) |
+| **Already handled by graphify** | `.svelte-kit/`, `node_modules/` |
+
+### Hugo
+
+| Attribute | Value |
+|-----------|-------|
+| **Marker file** | `hugo.toml`, `hugo.yaml`, `hugo.json` |
+| **Excluded (always)** | `public/`, `resources/` |
+| **Excluded (conditional)** | `archetypes/` (unless modified by user), `layouts/` (unless user has custom layouts at root), theme-internal dirs (when theme is vendored via git submodule) |
+| **Kept** | `content/`, `data/`, `static/`, `assets/`, user `layouts/` with custom templates |
+| **Heuristics** | Detects git submodules in `themes/` to exclude theme boilerplate. Detects `layouts/` structure at project root to determine if user has custom templates. |
+
+### Jekyll
+
+| Attribute | Value |
+|-----------|-------|
+| **Marker file** | `_config.yml` |
+| **Excluded** | `_site/`, `.jekyll-cache/`, `.jekyll-metadata` |
+| **Kept** | `_posts/`, `_pages/`, `_data/`, `_includes/`, `_layouts/`, `_sass/`, `assets/` |
+| **Already handled by graphify** | `node_modules/` |
+
+### Docusaurus
+
+| Attribute | Value |
+|-----------|-------|
+| **Marker file** | `docusaurus.config.js`, `docusaurus.config.ts` |
+| **Excluded** | `.docusaurus/`, `build/` |
+| **Kept** | `docs/`, `src/`, `blog/`, `static/`, `sidebars.js` |
+| **Already handled by graphify** | `node_modules/` |
+
+### Flutter
+
+| Attribute | Value |
+|-----------|-------|
+| **Marker file** | `pubspec.yaml` (content-verified for `flutter` keyword) |
+| **Excluded** | `.dart_tool/`, `build/`, `.flutter-plugins`, `.flutter-plugins-dependencies` |
+| **Kept** | `lib/` (user code), `test/` (user tests) |
+| **Already handled by graphify** | — |
+
+### WordPress
+
+| Attribute | Value |
+|-----------|-------|
+| **Marker file** | `wp-config.php` |
+| **Excluded** | `wp-admin/`, `wp-includes/`, `wp-content/languages/`, `wp-content/upgrade/` |
+| **Kept** | `wp-content/themes/` (custom themes), `wp-content/plugins/` (custom plugins) |
+| **Already handled by graphify** | `node_modules/` |
+
+## Noise Directories Handled by graphify (not duplicated)
+
+The following directories are already excluded by graphify's built-in `_SKIP_DIRS` list. The framework-aware skill does NOT duplicate these patterns:
+
+`.angular/`, `.cache/`, `.dart_tool/`, `.graphify/`, `.idea/`, `.next/`, `.nuxt/`, `.parcel-cache/`, `.pytest_cache/`, `.ruff_cache/`, `.serverless/`, `.svelte-kit/`, `.terraform/`, `.tox/`, `.turbo/`, `.venv/`, `__.pycache__/`, `build/`, `coverage/`, `dist/`, `dist-protected/`, `env/`, `graphify-out/`, `lib64/`, `node_modules/`, `out/`, `site-packages/`, `snapshots/`, `storybook-static/`, `target/`, `venv/`, `visual-tests/`
+
+## Noise Files Handled by graphify (not duplicated)
+
+`package-lock.json`, `yarn.lock`, `pnpm-lock.yaml`, `Cargo.lock`, `poetry.lock`, `Gemfile.lock`, `composer.lock`, `go.sum`, `go.work.sum`