@adityaaria/spark 6.0.22 → 6.0.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adityaaria/spark",
-  "version": "6.0.22",
+  "version": "6.0.24",
   "description": "SPARK skills and runtime bootstrap for coding agents",
   "type": "module",
   "publishConfig": {

package/skills/project-scanner/SKILL.md

@@ -26,25 +26,31 @@ If the repository is extremely large and analyzing all four pillars sequentially
 
 ## Target Extraction Artifacts
 
-Your final analysis must thoroughly document these four pillars:
+Your final analysis must thoroughly document these five pillars:
 
-### 1. API CONTRACT
+### 1. ARCHITECTURE GRAPH (MERMAID)
+You MUST generate a high-level visual representation of the project's architecture using Mermaid.js syntax.
+- **Format:** Use a standard ````mermaid` code block.
+- **Contents:** Map out the relationships between the Client (Frontend), Gateway, Services, and Database/Storage.
+- **Syntax rules:** You may use standard flowchart arrows (`-->`, `-.->`, `==>`), but ensure the graph represents the actual architecture of the scanned codebase, not a generic template.
+
+### 2. API CONTRACT
 Identify how the application communicates internally and externally.
 - **Priority Target:** Actively search for Swagger (`swagger.yaml`, `swagger.json`) or OpenAPI specifications. These are the single source of truth for the API contract.
 - **Secondary Targets:** Discover REST/GraphQL endpoints, gRPC protos, ORM schemas, Data Transfer Objects (DTOs), and core data models.
 - **Legacy Traps:** Flag any endpoints that violate current conventions or bypass standard authentication/validation layers.
 
-### 2. WORKFLOW
+### 3. WORKFLOW
 Identify how the project is built, run, tested, and deployed.
 - **Targets:** CI/CD pipelines (e.g., `.github/workflows`, `.gitlab-ci.yml`), build scripts (Makefiles, Gradle, NPM scripts), Dockerfiles, and deployment scripts.
 - **Testing:** Identify the test framework, strategy (Unit, Integration, E2E), and explicitly highlight critical areas that lack test coverage.
 
-### 3. BUSINESS FLOW & DOMAINS
+### 4. BUSINESS FLOW & DOMAINS
 Identify the core business logic and user journeys.
 - **Targets:** Core domains, domain services, use cases, and state machines.
 - **Domain Mapping:** Draft a list of business domains (e.g., Auth, Checkout, Inventory). Note their complexity, risk level, and the specific modules/packages that own them. Avoid forcing a domain split if the project is small.
 
-### 4. STANDARDS & ANTI-PATTERNS
+### 5. STANDARDS & ANTI-PATTERNS
 Identify conventions, rules, and technical debt enforced or found in the codebase.
 - **Targets:** Code styling conventions, linting rules, architectural patterns (e.g., MVC, Hexagonal, Clean Architecture).
 - **Anti-Pattern Detection (CRITICAL):** Actively search for and document legacy traps:
@@ -60,6 +66,6 @@ Identify conventions, rules, and technical debt enforced or found in the codebas
 - `[ ]` **Step 1:** Announce skill usage exactly as required.
 - `[ ]` **Step 2:** Identify if the workspace contains multiple independent projects (e.g., frontend vs backend). If so, plan to scan and generate `.docs/` for EACH project separately.
 - `[ ]` **Step 3:** Scan root configuration files and prioritize searching for Swagger/OpenAPI specifications.
-- `[ ]` **Step 4:** Scan source directory structures to infer the language, framework, and architectural patterns.
+- `[ ]` **Step 4:** Scan source directory structures and generate a ````mermaid` architecture graph detailing the core components and their relationships.
 - `[ ]` **Step 5:** Analyze testing frameworks, CI/CD workflows, and actively hunt for anti-patterns and legacy traps.
 - `[ ]` **Step 6 (CRITICAL):** You MUST use your file-writing tools to physically create the `.docs/` directory (inside each project root if multi-repo) and save the markdown files (e.g. `PROJECT_SCAN.md`, `API_CONTRACT.md`) into it. DO NOT just print the summary into the chat! You must physically write the files to disk.

package/skills/using-spark/SKILL.md

@@ -54,7 +54,7 @@ Skills speak in actions ("dispatch a subagent", "create a todo", "read a file")
 
 **Invoke relevant or requested skills BEFORE any response or action.** Even a 1% chance a skill might apply means that you should invoke the skill to check. If an invoked skill turns out to be wrong for the situation, you don't need to use it.
 
-**CRITICAL:** If the user mentions a specific skill by name (e.g., "scan project", "project-scanner", "run deployment"), you MUST invoke that skill IMMEDIATELY as your very first tool call. Do not answer conversationally. Do not ask for confirmation. Execute the skill first.
+**CRITICAL:** If the user's prompt matches the purpose of ANY existing skill, or mentions a skill by name, you MUST invoke that skill IMMEDIATELY as your very first tool call. Do not answer conversationally. Do not ask for confirmation. Execute the skill first.
 
 ## Announcement Format
 When you invoke a skill, you MUST announce it to the developer using exactly this format as the very first thing you say:

package/src/dashboard/public/index.html

@@ -652,6 +652,18 @@ ${steps}
                         let l = line.trim();
                         if (!l || l.startsWith('graph') || l.startsWith('flowchart') || l.startsWith('subgraph') || l.startsWith('end')) return;
 
+                        // Normalize Mermaid links (dotted, thick, solid without arrow, and inline labels)
+                        l = l.replace(/-\.->/g, '-->')
+                             .replace(/==>/g, '-->')
+                             .replace(/---/g, '-->')
+                             .replace(/-\.-/g, '-->')
+                             .replace(/===/g, '-->');
+                             
+                        // Normalize inline labels like A -- label --> B to A -->|label| B
+                        l = l.replace(/--\s*([^>]+?)\s*-->/g, '-->|$1|')
+                             .replace(/-\.\s*([^>]+?)\s*\.->/g, '-->|$1|')
+                             .replace(/==\s*([^>]+?)\s*==>/g, '-->|$1|');
+
                         const parts = l.split('-->');
                         if (parts.length >= 2) {
                             let fromPart = parts[0].trim();