@atlashub/smartstack-cli 3.4.0 → 3.4.1

package/templates/skills/business-analyse/steps/step-00-init.md

@@ -1,6 +1,6 @@
 ---
 name: step-00-init
-description: Initialize Business Analysis - Parse flags, route use case, create feature.json
+description: Initialize Business Analysis - Auto-detect new/update, create feature.json
 next_step: steps/step-01-cadrage.md
 ---
 
@@ -8,182 +8,24 @@ next_step: steps/step-01-cadrage.md
 
 # Step 00: Initialize Business Analysis
 
-Initialize the business analysis workflow by parsing input flags, routing to the appropriate use case handler, and creating the initial feature.json structure.
+Initialize the business analysis workflow by auto-detecting whether this is a new application or an update to an existing one, then creating the initial feature.json structure.
 
 ## Flow
 
-1. Parse command flags and determine use case
-2. Route to specialized handler (question, refactoring, micro, or new feature)
-3. MCP health check (non-blocking)
-4. Interactive mode (if enabled)
-5. Validate business context
-6. Determine application and module
-7. Select language
-8. Generate feature ID
-9. Create output directory structure
-10. Create initial feature.json
-11. Update config
-12. Display summary
-13. Load next step
-
-## Step 1: Parse Command Flags
-
-Parse all command-line arguments to determine execution mode and routing.
-
-### Default Values
-```yaml
-auto_mode: false
-economy_mode: false
-context: business
-question_mode: false
-refactor_mode: false
-micro_mode: false
-extract_mode: false
-application_mode: false    # Multi-module application analysis
-```
-
-### Flag Parsing Rules
-
-| Flag | Long Form | Effect | Argument |
-|------|-----------|--------|----------|
-| `-a` | `--auto` | Enable auto mode | none |
-| `-e` | `--economy` | Enable economy mode | none |
-| `-A` | `--no-auto` | Disable auto mode | none |
-| `-E` | `--no-economy` | Disable economy mode | none |
-| `-q` | `--question` | Question mode | next arg = FEAT-ID, remaining = question text |
-| `-r` | `--refactor` | Refactoring mode | next arg = FEAT-ID, remaining = change description |
-| `-m` | `--micro` | Micro feature mode | none |
-| `-x` | `--extract` | Extract mode: import from interactive HTML export | next arg = JSON file path |
-| `-app` | `--application` | Application mode: multi-module analysis | none |
-
-**Remaining arguments after flag removal = feature_description**
-
-### Set Use Case
-```
-IF question_mode = true:
-  use_case = "question"
-ELSE IF refactor_mode = true:
-  use_case = "refactoring"
-ELSE IF extract_mode = true:
-  use_case = "extract"
-ELSE IF micro_mode = true:
-  use_case = "micro"
-ELSE:
-  use_case = "new"
-```
-
-## Step 2: Use Case Routing
-
-Route execution based on the detected use case.
-
-### Question Mode (-q)
-```
-1. Parse: question_mode = true, feat_id = first remaining arg, question_text = rest
-2. Call ba-reader agent:
-   - ba-reader.findFeatureByID(feat_id)
-   - Retrieve existing feature.json
-3. Call ba-reader.answerQuestion(feat_id, question_text)
-   - Answer question from context
-4. Display answer in user session
-5. EXIT - no further steps
-```
-
-**Example:**
-```
-ba -q FEAT-001 "What are the main actors in this feature?"
-```
-
-### Refactoring Mode (-r)
-```
-1. Parse: refactor_mode = true, feat_id = first remaining arg, change_description = rest
-2. Call ba-reader agent:
-   - ba-reader.findFeatureByID(feat_id)
-   - Load existing feature.json
-3. Call ba-writer agent:
-   - ba-writer.createVersion(feat_id, change_description)
-   - Increment version (e.g., 1.0 -> 1.1)
-   - Mark changeReason
-4. Set use_case = "refactoring"
-5. Set version = new version number
-6. Set feature_id from loaded feature
-7. Continue to Step 5 (context validation)
-8. Continue to Step 9 (create output structure at new version)
-9. Load step-01-analyse in delta mode (compare old vs new)
-```
-
-**Example:**
-```
-ba -r FEAT-001 "Add support for multi-language feature names"
-```
-
-### Micro Feature Mode (-m)
-```
-1. Set use_case = "micro"
-2. Set feature_type = "micro"
-3. Continue to standard init flow (Steps 5-9)
-4. Load step-01-analyse in micro mode (simplified analysis)
-```
-
-**Example:**
-```
-ba -m "Add email notification on approval"
-```
-
-### Extract Mode (-x)
-```
-1. Parse: extract_mode = true, json_path = first remaining arg
-2. Validate JSON file exists at {json_path}
-3. Read JSON file content
-4. Load step-06-extract.md with {json_data} = parsed content
-5. EXIT after extraction — step-06 handles everything
-```
-
-**Example:**
-```
-ba -x ./docs/business/MyApp/ba-export.json
-```
-
-> **Note:** The JSON file is the export from the interactive HTML document (`ba-interactive.html`).
-> The extract step maps ALL client data to feature.json format with zero information loss.
-
-### Default Mode (New Feature)
-```
-1. Set use_case = "new"
-2. Continue to standard init flow (Steps 5-9)
-3. Load step-01-analyse in full mode
-```
-
-**Example:**
-```
-ba "Create order management system"
-```
-
-## Step 2B: Application Mode Detection
-
-**IF `-app` flag is set:**
-- Set `{workflow_mode}` = "application"
-- Set `{use_case}` = "application"
-
-**ELSE IF no explicit mode flag:**
-- Analyze `{feature_description}` for multi-module signals:
-  - Keywords: "application", "system", "platform", "suite", "complet", "ensemble"
-  - Multiple module mentions (3+ distinct functional areas)
-  - Scope description spanning multiple domains
-- IF multi-module signals detected:
-  ```
-  AskUserQuestion:
-    question: "Votre description semble couvrir plusieurs modules. Voulez-vous une analyse multi-module (application complète) ?"
-    header: "Mode"
-    options:
-      - label: "Oui, analyse application"
-        description: "Identifier les modules, les analyser un par un avec validation client"
-      - label: "Non, module unique"
-        description: "Traiter comme un seul module"
-  ```
-- IF user confirms multi-module: Set `{workflow_mode}` = "application"
-- ELSE: Set `{workflow_mode}` = "module"
-
-## Step 3: MCP Prerequisite Check (BLOCKING)
+1. MCP health check (blocking)
+2. Scan existing applications in `docs/business/`
+3. Auto-detect: new application or update
+4. Determine application name
+5. Select language
+6. Generate feature ID
+7. Create output directory structure
+8. Deploy JSON schemas
+9. Create master feature.json
+10. Update config
+11. Display summary
+12. Load next step
+
+## Step 1: MCP Prerequisite Check (BLOCKING)
 
 Verify MCP availability. **This check is BLOCKING** - the skill cannot proceed without MCP.
 
@@ -199,14 +41,9 @@ mcp__smartstack__validate_conventions({ checks: ["tables"] })
 
 | Result | Action |
 |--------|--------|
-| Success response | Set `mcp_available = true`, continue to Step 4 |
+| Success response | Set `mcp_available = true`, continue to Step 2 |
 | Connection error / tool not found | **STOP EXECUTION** - display error below |
 
-**On success:**
-- Set `mcp_available = true`
-- Update `.claude/mcp-status.json` cache
-- Continue workflow
-
 **On failure (STOP):**
 
 ```
@@ -228,77 +65,105 @@ mcp__smartstack__validate_conventions({ checks: ["tables"] })
 ═══════════════════════════════════════════════════════════════
 ```
 
-**DO NOT** offer fallback modes, economy mode workarounds, or degraded execution.
-**DO NOT** continue to Step 4 or any subsequent step.
+**DO NOT** continue to any subsequent step.
 **STOP the skill immediately.**
 
-## Step 4: Validate Business Context
-
-Verify that the business context is properly configured.
+## Step 2: Scan Existing Applications
 
-**Check:**
-1. Does `.business-analyse/config.json` exist?
-2. Does it contain `businessContext` section?
-3. Are required fields present?
+Scan `docs/business/` for existing business analysis features.
 
-**If missing:**
-1. Create fresh config with defaults
-2. Prompt for business context (only in interactive mode)
-3. Save to `.business-analyse/config.json`
+```
+1. Glob: docs/business/*/business-analyse/*/feature.json
+2. For each feature.json found:
+   - Read metadata.application, metadata.featureDescription
+   - Store: { app: string, featureId: string, description: string, version: string }
+3. Build list of existing applications
+```
 
-**Required config structure:**
-```json
-{
-  "businessContext": {
-    "organization": "string",
-    "domain": "string",
-    "language": "string"
-  }
-}
+**Store:**
+```yaml
+existing_apps: array of { app, featureId, description, version }
 ```
 
-## Step 5: Determine Application and Module
+## Step 3: Auto-Detect New vs Update
+
+Compare the user's `{feature_description}` with existing applications.
 
-Scan for existing applications and modules.
+```
+IF existing_apps is empty:
+  workflow_type = "new"
+  → Go to Step 4
 
-**Scan location:** `docs/business/` (modern structure only)
+IF existing_apps has entries:
+  Analyze {feature_description} for similarity with existing apps:
+    - Same application domain?
+    - References an existing module name?
+    - Mentions adding/changing/modifying something existing?
 
+  Ask via AskUserQuestion:
+    question: "J'ai trouvé des analyses existantes. Que souhaitez-vous faire ?"
+    header: "Mode"
+    options:
+      - label: "Nouvelle application"
+        description: "Créer une nouvelle analyse complète"
+      - label: "Mise à jour de {appName} (FEAT-NNN)"
+        description: "Enrichir ou modifier l'application existante (crée v{next})"
+    (repeat for each existing app, max 3 options + "Nouvelle application")
+
+  IF user selects "Nouvelle application":
+    workflow_type = "new"
+  ELSE:
+    workflow_type = "update"
+    existing_feature_id = selected app's featureId
+    Call ba-writer.createVersion(existing_feature_id, {feature_description})
+    version = new version number
 ```
-1. List subdirectories in `docs/business/` = applications
-2. For each app, list subdirectories = modules
-3. IF no applications found:
-     Will create new under docs/business/
+
+**Store:**
+```yaml
+workflow_type: "new" | "update"
+existing_feature_id: string | null
+version: "1.0" (new) | "1.1"+ (update)
 ```
 
-**Legacy structure (`.business-analyse/business/`) is NO LONGER SUPPORTED.**
+## Step 4: Determine Application Name
 
-**Logic:**
 ```
-IF auto_mode = true:
-  application_name = first found app OR "default"
-  module_name = first found module OR "default"
+IF workflow_type = "update":
+  application_name = existing app name (from step 3)
 ELSE:
-  Prompt: "Select application: [list]"
-  Prompt: "Select module: [list]"
-  OR: "Create new application: {name}"
-  OR: "Create new module: {name}"
+  Analyze {feature_description} to extract application name
+  Ask via AskUserQuestion:
+    question: "Quel nom pour cette application ?"
+    header: "Application"
+    options:
+      - label: "{detected_name}"
+        description: "Nom détecté depuis votre description"
+      - label: "Autre"
+        description: "Saisir un nom personnalisé"
+```
+
+**Validate business context:**
+```
+validate_business_context("business")
+→ BA restricted to 'business' context only
 ```
 
 **Store:**
 ```yaml
 application_name: string
-module_name: string
+context: "business"
 ```
 
-## Step 6: Select Language
+## Step 5: Select Language
 
 Determine the language for analysis and code generation.
 
 **Check config:**
-- Retrieve `businessContext.language` from config
+- Retrieve `language` from `.business-analyse/config.json`
 - Default: "fr" (Francais)
 
-**If not in config OR auto_mode = false:**
+**If not in config:**
 ```
 Ask via AskUserQuestion:
   question: "Quelle langue pour l'analyse ?"
@@ -315,18 +180,17 @@ Ask via AskUserQuestion:
 language: string (code, e.g., "en", "fr")
 ```
 
-## Step 7: Generate Feature ID
+## Step 6: Generate Feature ID
 
 Create a unique feature identifier.
 
-**Logic:**
 ```
-IF use_case = "question" OR "refactoring":
-  feature_id = use provided feat_id (already parsed)
+IF workflow_type = "update":
+  feature_id = existing_feature_id (from step 3)
 ELSE:
-  feature_id = generate using pattern: FEAT-{timestamp-based}-{random}
-  OR: FEAT-{app-short}-{seq-number}
-  Example: FEAT-001, FEAT-002, ...
+  feature_id = generate_feature_id()
+  → Read .business-analyse/config.json → lastFeatureId
+  → Increment and format as FEAT-NNN
 ```
 
 **Store:**
@@ -334,32 +198,21 @@ ELSE:
 feature_id: string
 ```
 
-## Step 8: Create Output Directory Structure
-
-Create the directory hierarchy for feature documentation.
+## Step 7: Create Output Directory Structure
 
-**For new features / micro / refactoring:**
 ```
-docs/business/{application_name}/{module_name}/business-analyse/v{version}/
-```
-
-**Where version:**
-- New feature: "1.0"
-- Refactoring: from ba-writer (e.g., "1.1", "1.2")
-- Micro: "1.0"
-
-**Create directories:**
-```bash
-mkdir -p docs/business/{app}/{module}/business-analyse/v{version}
+IF workflow_type = "new":
+  mkdir -p docs/business/{application_name}/business-analyse/v1.0
+ELSE:
+  Directory already exists from ba-writer.createVersion()
 ```
 
 **Store:**
 ```yaml
-docs_dir: "docs/business/{app}/{module}/business-analyse/v{version}"
-output_dir: same as docs_dir
+docs_dir: "docs/business/{app}/business-analyse/v{version}"
 ```
 
-## Step 8-bis: Deploy JSON Schemas to Project (MANDATORY)
+## Step 8: Deploy JSON Schemas to Project (MANDATORY)
 
 > **The JSON Schemas MUST be present in the project alongside the generated feature.json files.**
 > Without schemas, feature.json files cannot be validated and have no structural reference.
@@ -376,11 +229,11 @@ Cache file location: `docs/business/{app}/business-analyse/.schema-cache.json`
 IF EXISTS docs/business/{app}/business-analyse/.schema-cache.json:
   Read cache file
   IF cache.version == "{CLI_VERSION}" (from package.json):
-    Display: "✓ Schemas already deployed ({CLI_VERSION}) - skipping"
+    Display: "Schemas already deployed ({CLI_VERSION}) - skipping"
     SKIP deployment (trust cache)
-    → Go to Step 10
+    → Go to Step 9
   ELSE:
-    Display: "⚠ Schema version mismatch (cache: {cache.version}, current: {CLI_VERSION})"
+    Display: "Schema version mismatch (cache: {cache.version}, current: {CLI_VERSION})"
     Proceed to deployment
 ELSE:
   Display: "Deploying schemas (first time)..."
@@ -396,27 +249,21 @@ Destination: `docs/business/{app}/business-analyse/schemas/`
 Read and Write each file (preserving directory structure):
 
 docs/business/{app}/business-analyse/schemas/
-├── feature-schema.json              ← from schemas/feature-schema.json
-├── application-schema.json          ← from schemas/application-schema.json
+├── feature-schema.json
+├── application-schema.json
 ├── sections/
-│   ├── metadata-schema.json         ← from schemas/sections/metadata-schema.json
-│   ├── discovery-schema.json        ← from schemas/sections/discovery-schema.json
-│   ├── analysis-schema.json         ← from schemas/sections/analysis-schema.json
-│   ├── specification-schema.json    ← from schemas/sections/specification-schema.json
-│   ├── validation-schema.json       ← from schemas/sections/validation-schema.json
-│   └── handoff-schema.json          ← from schemas/sections/handoff-schema.json
+│   ├── metadata-schema.json
+│   ├── discovery-schema.json
+│   ├── analysis-schema.json
+│   ├── specification-schema.json
+│   ├── validation-schema.json
+│   └── handoff-schema.json
 └── shared/
-    └── common-defs.json             ← from schemas/shared/common-defs.json
+    └── common-defs.json
 ```
 
 **Total: 9 files to deploy.**
 
-**Implementation:**
-1. Use Glob to find all `.json` files in `schemas/` directory (skill-relative)
-2. For each file, Read from skill directory and Write to project directory
-3. Preserve the subdirectory structure (sections/, shared/)
-4. Display progress: "Deploying schema {i}/{total}: {filename}"
-
 **Step 3: Write cache file (after successful deployment)**
 
 ```json
@@ -437,30 +284,14 @@ docs/business/{app}/business-analyse/schemas/
 }
 ```
 
-Write to: `docs/business/{app}/business-analyse/.schema-cache.json`
-
-Display: "✓ Schemas deployed successfully (9 files)"
-
-**Store:**
-```yaml
-schemas_dir: "docs/business/{app}/business-analyse/schemas"
-```
-
-**Performance gain:**
-- First deployment: ~12 seconds (unchanged)
-- Subsequent deployments: **~0 seconds (skipped via cache)** ✨
-- Cache invalidation: automatic on skill version upgrade
-
 ## Step 9: Create Master feature.json
 
 Create the master feature document using ba-writer agent.
 
-**Use ba-writer agent:**
-
 ```
 ba-writer.createApplicationFeature({
   id: {feature_id},
-  version: "1.0",
+  version: {version},
   scope: "application",
   status: "draft",
   metadata: {
@@ -468,11 +299,10 @@ ba-writer.createApplicationFeature({
     context: "business",
     language: {language},
     featureDescription: {feature_description},
-    useCase: {use_case},
-    mcpAvailable: {mcp_available},
-    economyMode: {economy_mode},
+    workflowType: {workflow_type},
+    mcpAvailable: true,
     workflow: {
-      mode: {workflow_mode},
+      mode: "application",
       moduleOrder: [],
       currentModuleIndex: 0,
       completedModules: [],
@@ -483,109 +313,29 @@ ba-writer.createApplicationFeature({
 ```
 
 **Output path:**
-- Application mode: `docs/business/{app}/business-analyse/v1.0/feature.json`
-- Module mode: `docs/business/{app}/business-analyse/v1.0/feature.json` (same - always create master first)
+`docs/business/{app}/business-analyse/v{version}/feature.json`
 
-> **Note:** Even in single-module mode, we create the master feature.json. The decomposition step will trivially identify one module.
-
-**Result structure:**
-```json
-{
-  "$schema": "../schemas/application-schema.json",
-  "id": "{feature_id}",
-  "version": "1.0",
-  "status": "draft",
-  "metadata": {
-    "createdAt": "{ISO timestamp}",
-    "updatedAt": "{ISO timestamp}",
-    "application": "{application_name}",
-    "module": "{module_name}",
-    "context": "business",
-    "language": "{language}",
-    "featureDescription": "{feature_description}",
-    "featureType": null,
-    "useCase": "{use_case}",
-    "permissionBase": "business.{app}.{module}",
-    "previousVersion": null,
-    "changeReason": null,
-    "mcpAvailable": {mcp_available},
-    "economyMode": {economy_mode},
-    "steps": {
-      "init": {
-        "status": "completed",
-        "startedAt": "{ISO timestamp}",
-        "completedAt": "{ISO timestamp}"
-      },
-      "analyse": {
-        "status": "pending",
-        "startedAt": null,
-        "completedAt": null
-      },
-      "specify": {
-        "status": "pending",
-        "startedAt": null,
-        "completedAt": null
-      },
-      "validate": {
-        "status": "pending",
-        "startedAt": null,
-        "completedAt": null
-      },
-      "handoff": {
-        "status": "pending",
-        "startedAt": null,
-        "completedAt": null
-      }
-    }
-  },
-  "discovery": {},
-  "analysis": {},
-  "specification": {},
-  "validation": {},
-  "handoff": {},
-  "suggestions": [],
-  "changelog": [
-    {
-      "version": "1.0",
-      "timestamp": "{ISO timestamp}",
-      "author": "BA Skill",
-      "changes": ["Initial feature.json created"]
-    }
-  ]
-}
-```
-
-**Write to:**
-```
-{docs_dir}/feature.json
-```
+> **Note:** Always create the master feature.json first. Step-02 (decomposition) determines if it's single or multi-module.
 
 ## Step 10: Update Config
 
 Update `.business-analyse/config.json` with new feature information.
 
-**Update fields:**
 ```json
 {
   "currentFeature": {
     "id": "{feature_id}",
-    "version": "1.0",
+    "version": "{version}",
     "docsDir": "{docs_dir}",
-    "useCase": "{use_case}",
-    "application": "{application_name}",
-    "module": "{module_name}"
+    "workflowType": "{workflow_type}",
+    "application": "{application_name}"
   },
-  "lastInitialized": "{ISO timestamp}",
-  "autoMode": {auto_mode},
-  "economyMode": {economy_mode}
+  "lastInitialized": "{ISO timestamp}"
 }
 ```
 
 ## Step 11: Display Summary
 
-Show initialization results in a clear table format.
-
-**Output:**
 ```
 ═══════════════════════════════════════════════════════════════
   BUSINESS ANALYSIS INITIALIZATION COMPLETE
@@ -593,67 +343,49 @@ Show initialization results in a clear table format.
 
 | Field              | Value                                        |
 |--------------------|----------------------------------------------|
-| Step               | INIT (00)                                    |
 | Feature ID         | {feature_id}                                 |
-| Use Case           | {use_case}                                   |
+| Workflow           | {workflow_type}                               |
 | Application        | business/{application_name}                  |
-| Module             | {module_name}                                |
 | Output Path        | {docs_dir}/feature.json                      |
 | Language           | {language}                                   |
-| Auto Mode          | {auto_mode}                                  |
-| Economy Mode       | {economy_mode}                               |
-| MCP Available      | {mcp_available}                              |
-| Timestamp          | {ISO timestamp}                              |
+| Version            | {version}                                    |
+| MCP Available      | true                                         |
 
-NEXT STEP: step-01-analyse ({use_case} mode)
+NEXT STEP: step-01-cadrage
 ═══════════════════════════════════════════════════════════════
 ```
 
 ## Step 12: Load Next Step
 
-**All modes except question (-q), micro (-m), and extract (-x):**
 After showing initialization summary, proceed to `./step-01-cadrage.md`
 
-**Question mode (-q):** EXIT after ba-reader answers the question.
-**Micro mode (-m):** Load `./step-05a-handoff.md` directly.
-**Extract mode (-x):** Load `./step-06-extract.md` with `{json_data}` from parsed JSON file.
-
 **Pass context variables:**
 ```yaml
 feature_id: string
 feature_description: string
-use_case: "new" | "question" | "refactoring" | "micro" | "extract" | "application"
+workflow_type: "new" | "update"
 application_name: string
-module_name: string
 language: string
 docs_dir: string
-auto_mode: boolean
-economy_mode: boolean
 mcp_available: boolean
-workflow_mode: string
+workflow_mode: "application"
+version: string
 ```
 
 ## Error Handling
 
-Handle common initialization failures gracefully.
-
 | Error | Action |
 |-------|--------|
 | Config missing | Create fresh with defaults, continue |
 | Directory creation fails | Check permissions, display error, EXIT |
 | feature.json creation fails | Validate ba-writer, retry or fallback |
-| Legacy structure detected | Offer migration to new docs/business/ structure |
 | Feature ID not unique | Generate new ID, retry |
-| Invalid language | Default to "en", warn user |
 
 ### Resume After Interruption
 
 If initialization was interrupted:
 
 1. Check `.business-analyse/config.json` for currentFeature
-2. If feature ID exists, search for feature.json:
-   - Primary: `docs/business/{app}/{module}/business-analyse/v{version}/`
-   - Fallback: `.business-analyse/{app}/{module}/`
+2. If feature ID exists, search for feature.json in `docs/business/`
 3. If found, offer to resume from last completed step
 4. If not found, create fresh feature.json
-