@torka/claude-workflows 0.1.0 → 0.3.0

package/skills/designer-founder/tools/wireframe.md

@@ -0,0 +1,181 @@
+# Wireframe Tool Execution
+
+## Overview
+
+Text-based wireframing for structure-first design. Always available, no external tools required.
+
+**Output:** ASCII wireframe or Excalidraw file
+**Output Location:** Inline or `_bmad-output/planning-artifacts/ux-design/`
+
+---
+
+## Execution Flow
+
+### 1. Gather Structure Requirements
+
+Ask clarifying questions:
+```
+WIREFRAME MODE
+
+Before I sketch the layout, let me understand the structure:
+
+1. What are the main sections/areas needed?
+2. What's the primary action users should take?
+3. Any specific layout preferences? (sidebar, full-width, centered, etc.)
+```
+
+### 2. Generate ASCII Wireframe
+
+Create wireframe based on requirements:
+
+```
+{feature_name} - WIREFRAME
+
+┌─────────────────────────────────────────────────────────────┐
+│  [Logo]                    [Nav] [Nav] [Nav]    [Avatar ▼]  │
+├─────────────────────────────────────────────────────────────┤
+│                                                             │
+│    ┌─────────────────────────────────────────────────┐      │
+│    │                                                 │      │
+│    │              [Main Content Area]                │      │
+│    │                                                 │      │
+│    │    ┌───────────┐  ┌───────────┐  ┌───────────┐  │      │
+│    │    │  Card 1   │  │  Card 2   │  │  Card 3   │  │      │
+│    │    │           │  │           │  │           │  │      │
+│    │    └───────────┘  └───────────┘  └───────────┘  │      │
+│    │                                                 │      │
+│    │              [Primary CTA Button]               │      │
+│    │                                                 │      │
+│    └─────────────────────────────────────────────────┘      │
+│                                                             │
+├─────────────────────────────────────────────────────────────┤
+│  [Footer Link]  [Footer Link]  [Footer Link]    © 2024      │
+└─────────────────────────────────────────────────────────────┘
+```
+
+### 3. Add Component Labels
+
+Below the wireframe, add component identification:
+
+```
+COMPONENT MAPPING
+
+┌─ Header ─────────────────────────────────────────────────────┐
+│  Logo: Image/SVG                                             │
+│  Navigation: Horizontal nav links (3-4 items)                │
+│  User Menu: Dropdown with avatar trigger                     │
+└──────────────────────────────────────────────────────────────┘
+
+┌─ Main Content ───────────────────────────────────────────────┐
+│  Section Title: h1 or h2                                     │
+│  Card Grid: 3-column on desktop, stack on mobile             │
+│  Card: Icon + Title + Description + Optional action          │
+│  CTA: Primary button, centered                               │
+└──────────────────────────────────────────────────────────────┘
+
+┌─ Footer ─────────────────────────────────────────────────────┐
+│  Links: Horizontal list                                      │
+│  Copyright: Text, right-aligned                              │
+└──────────────────────────────────────────────────────────────┘
+```
+
+### 4. Present Options
+
+```
+WIREFRAME COMPLETE
+
+Options:
+[E] Edit - Modify the structure
+[M] Mobile - Show mobile layout variant
+[X] Excalidraw - Generate as Excalidraw file
+[C] Continue - Structure is approved
+```
+
+**If E (Edit):**
+- Ask what changes are needed
+- Regenerate wireframe
+- Return to step 4
+
+**If M (Mobile):**
+Generate mobile variant:
+```
+{feature_name} - MOBILE WIREFRAME
+
+┌─────────────────────┐
+│ [≡]  [Logo]  [👤]   │
+├─────────────────────┤
+│                     │
+│  [Main Content]     │
+│                     │
+│  ┌───────────────┐  │
+│  │    Card 1     │  │
+│  └───────────────┘  │
+│                     │
+│  ┌───────────────┐  │
+│  │    Card 2     │  │
+│  └───────────────┘  │
+│                     │
+│  ┌───────────────┐  │
+│  │    Card 3     │  │
+│  └───────────────┘  │
+│                     │
+│  [Primary CTA]      │
+│                     │
+├─────────────────────┤
+│  [Links] [©]        │
+└─────────────────────┘
+
+Changes from Desktop:
+- Nav collapsed to hamburger menu
+- Cards stack vertically
+- Full-width buttons
+```
+
+**If X (Excalidraw):**
+- Invoke create-excalidraw-wireframe workflow
+- Or generate Excalidraw JSON directly
+- Save to `_bmad-output/planning-artifacts/ux-design/{feature}-wireframe.excalidraw`
+
+**If C (Continue):**
+- Return control to parent step
+
+---
+
+## Output State
+
+After completion, set:
+
+```yaml
+design:
+  tool_used: wireframe
+  output_location: "inline"  # or excalidraw file path
+  output_format: ascii
+  needs_conversion: true
+  wireframe_content: "{the ascii wireframe}"
+  component_mapping: "{the component labels}"
+```
+
+---
+
+## Wireframe Symbols Reference
+
+```
+┌───┐  Box/Container
+│   │
+└───┘
+
+[Text]     Button or clickable element
+(Text)     Rounded/pill element
+<Text>     Input field
+{Text}     Dynamic content placeholder
+
+──────     Horizontal line/divider
+│          Vertical line/divider
+
+[≡]        Hamburger menu
+[👤]       User avatar
+[▼]        Dropdown indicator
+[×]        Close button
+[+]        Add button
+[←]        Back navigation
+```

package/skills/designer-founder/workflow.md

@@ -0,0 +1,85 @@
+---
+name: designer-founder
+description: Transform ideas into dev-ready frontend artifacts. Works for greenfield projects and mid-project feature design.
+web_bundle: true
+---
+
+# Designer-Founder Workflow
+
+**Goal:** Transform design ideas and concepts into production-ready artifacts for frontend development, optimized for solo developers who prioritize speed and library reuse.
+
+---
+
+## PERSONA
+
+You are an expert UI/UX designer and visual design specialist who:
+
+- **Advocates strongly** for shadcn/ui + Tailwind CSS
+- **Thinks in components**, not pixels - always map to existing libraries first
+- **Balances speed with maintainability** - just enough design, no over-specification
+- **Draws inspiration** from Apple, Stripe, Airbnb, Linear, Vercel
+- **Focuses on decisions**, not documentation - capture choices, not specs
+
+---
+
+## PHILOSOPHY
+
+1. **Library-first** - Start from "what existing component can I use?" not "let me design from scratch"
+2. **Decision-focused** - Capture choices, not specifications (the library handles details)
+3. **Just enough** - Wireframe the layout, pick components, move on
+4. **Speed over perfection** - A working prototype beats a perfect mockup
+
+---
+
+## WORKFLOW ARCHITECTURE
+
+This uses **micro-file architecture** with 4 core steps:
+
+| Step | Name | Purpose |
+|------|------|---------|
+| 1 | Context & Mode | Detect project state, select mode (Quick/Production) |
+| 2 | Scope & Inspiration | Define what to design, gather references |
+| 3 | Design | Execute design using selected tool |
+| 4 | Convert & Artifacts | Transform to dev-ready output |
+
+**Quick Prototype Mode:** Steps 1 → 3 (skip detailed artifacts)
+**Production Mode:** Steps 1 → 2 → 3 → 4 (full flow)
+
+---
+
+## INITIALIZATION
+
+### Configuration Loading
+
+Load config from `{project-root}/_bmad/bmm/config.yaml` and resolve:
+
+- `project_name`, `output_folder`, `planning_artifacts`, `user_name`
+- `communication_language`, `document_output_language`
+- `date` as system-generated current datetime
+
+### Paths
+
+- `installed_path` = `{project-root}/_bmad/bmm/workflows/2-plan-workflows/designer-founder`
+- `output_folder` = `{planning_artifacts}/ux-design`
+- `superdesign_folder` = `{project-root}/.superdesign/design_iterations`
+
+### Tool Detection
+
+On workflow start, detect available tools:
+
+```
+MagicPatterns MCP: [check if mcp__magicpatterns tools available]
+shadcn MCP: [check if mcp__shadcn tools available]
+Playwright MCP: [check if mcp__playwright tools available]
+SuperDesign: [check if .superdesign/ folder and instructions exist]
+```
+
+Adjust tool menus based on availability. Tools marked as unavailable should show "(not configured)" in menus.
+
+---
+
+## EXECUTION
+
+- YOU MUST ALWAYS communicate in `{communication_language}` with a collaborative, peer-to-peer tone
+- You are a design expert working WITH the user, not FOR them
+- Load and execute `steps/step-01-context.md` to begin the workflow

package/uninstall.js

@@ -51,10 +51,58 @@ const INSTALLED_FILES = {
     'NON-STORY-AGENT-TEMPLATE.md',
     'COMMUNITY-REPOS.md',
   ],
-  scripts: [
-    'auto_approve_safe.py',
-    'auto_approve_safe.rules.json',
-    'context-monitor.py',
+  'skills/designer-founder': [
+    'workflow.md',
+  ],
+  'skills/designer-founder/steps': [
+    'step-01-context.md',
+    'step-01b-continue.md',
+    'step-02-scope.md',
+    'step-03-design.md',
+    'step-04-artifacts.md',
+  ],
+  'skills/designer-founder/templates': [
+    'component-strategy.md',
+    'design-brief.md',
+    'layouts.md',
+    'user-journeys.md',
+  ],
+  'skills/designer-founder/tools': [
+    'conversion.md',
+    'direct-mapping.md',
+    'magicpatterns.md',
+    'superdesign.md',
+    'wireframe.md',
+  ],
+  'skills/designer-founder/tools/superdesign-assets': [
+    'generate-theme.ts',
+    'superdesign-agent-instructions.md',
+  ],
+};
+
+/**
+ * BMAD workflow files installed to _bmad/ (relative to project root)
+ * These use ../ from .claude/ to reach project root
+ */
+const BMAD_INSTALLED_FILES = {
+  '../_bmad/bmm/workflows/4-implementation/implement-epic-with-subagents': [
+    'workflow.md',
+    'workflow.yaml',
+    'workflow-plan-implement-epic-with-subagents.md',
+    'completion-summary-implement-epic-with-subagents.md',
+  ],
+  '../_bmad/bmm/workflows/4-implementation/implement-epic-with-subagents/steps': [
+    'step-01-init.md',
+    'step-01b-continue.md',
+    'step-01c-new.md',
+    'step-02-orchestrate.md',
+    'step-03-complete.md',
+  ],
+  '../_bmad/bmm/workflows/4-implementation/implement-epic-with-subagents/templates': [
+    'epic-completion-report.md',
+  ],
+  '../_bmad/bmm/workflows/4-implementation/implement-epic-with-subagents/validation': [
+    'checklist.md',
   ],
 };
 
@@ -159,10 +207,51 @@ function uninstall() {
     }
   }
 
-  // Try to remove agent-creator skill directory if empty
-  const skillDir = path.join(targetBase, 'skills', 'agent-creator');
-  if (removeEmptyDir(skillDir)) {
-    log(`  ○ Removed empty directory: skills/agent-creator/`, 'yellow');
+  // Remove BMAD workflow files (installed to _bmad/ relative to project root)
+  log('\n' + colors.bold + 'BMAD Workflows' + colors.reset);
+  for (const [dir, files] of Object.entries(BMAD_INSTALLED_FILES)) {
+    const displayDir = dir.replace('../', '');
+    log(`\n${colors.bold}${displayDir}/${colors.reset}`);
+    for (const file of files) {
+      const filePath = path.join(targetBase, dir, file);
+      removeFile(filePath, stats);
+    }
+
+    // Try to remove empty directories
+    const dirPath = path.join(targetBase, dir);
+    if (removeEmptyDir(dirPath)) {
+      log(`  ○ Removed empty directory: ${displayDir}/`, 'yellow');
+    }
+  }
+
+  // Clean up empty BMAD directories (from deepest to shallowest)
+  const bmadDirs = [
+    '../_bmad/bmm/workflows/4-implementation/implement-epic-with-subagents/validation',
+    '../_bmad/bmm/workflows/4-implementation/implement-epic-with-subagents/templates',
+    '../_bmad/bmm/workflows/4-implementation/implement-epic-with-subagents/steps',
+    '../_bmad/bmm/workflows/4-implementation/implement-epic-with-subagents',
+  ];
+  for (const bmadSubDir of bmadDirs) {
+    const dirPath = path.join(targetBase, bmadSubDir);
+    if (removeEmptyDir(dirPath)) {
+      log(`  ○ Removed empty directory: ${bmadSubDir.replace('../', '')}/`, 'yellow');
+    }
+  }
+
+  // Try to remove skill directories if empty
+  const skillDirs = [
+    'skills/designer-founder/tools/superdesign-assets',
+    'skills/designer-founder/tools',
+    'skills/designer-founder/templates',
+    'skills/designer-founder/steps',
+    'skills/designer-founder',
+    'skills/agent-creator',
+  ];
+  for (const skillSubDir of skillDirs) {
+    const dirPath = path.join(targetBase, skillSubDir);
+    if (removeEmptyDir(dirPath)) {
+      log(`  ○ Removed empty directory: ${skillSubDir}/`, 'yellow');
+    }
   }
 
   // Summary

package/hooks/auto_approve_safe.py

@@ -1,261 +0,0 @@
-#!/usr/bin/env python3
-"""
-Claude Code Hook: Auto-approve safe tool usage for solo dev workflows.
-
-Handles PreToolUse events to:
-- Auto-allow known-safe commands (read-only, tests, linting)
-- Deny obviously dangerous commands
-- Defer everything else to normal permission system ("ask")
-
-Install:
-  1. mkdir -p ~/.claude/hooks && chmod 700 ~/.claude/hooks
-  2. Save this file to ~/.claude/hooks/auto_approve_safe.py
-  3. chmod +x ~/.claude/hooks/auto_approve_safe.py
-  4. Add hook config to ~/.claude/settings.json
-"""
-
-import json
-import os
-import re
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-# Max-autonomy default:
-# - Allow reads/searches
-# - Allow edits/writes except for sensitive paths
-# - Allow bash commands only if they match allowlist (supports simple compound commands)
-#
-# Debugging:
-# Set this to True temporarily to log every decision to a local jsonl file.
-ENABLE_DECISION_LOG = True
-
-
-def load_rules() -> dict:
-    """Load rules from global and project-specific config files."""
-    rules = {"allow_patterns": [], "deny_patterns": [], "sensitive_paths": []}
-
-    # # Load global rules
-    # global_rules_path = Path.home() / ".claude" / "hooks" / "auto_approve_safe.rules.json"
-    # if global_rules_path.exists():
-    #     try:
-    #         with open(global_rules_path) as f:
-    #             global_rules = json.load(f)
-    #             for key in rules:
-    #                 rules[key].extend(global_rules.get(key, []))
-    #     except (json.JSONDecodeError, IOError) as e:
-    #         print(f"Warning: Could not load global rules: {e}", file=sys.stderr)
-
-    # Load project-specific rules (merge with global)
-    project_rules_path = Path.cwd() / ".claude" / "scripts" / "auto_approve_safe.rules.json"
-    if project_rules_path.exists():
-        try:
-            with open(project_rules_path) as f:
-                project_rules = json.load(f)
-                for key in rules:
-                    rules[key].extend(project_rules.get(key, []))
-        except (json.JSONDecodeError, IOError) as e:
-            print(f"Warning: Could not load project rules: {e}", file=sys.stderr)
-
-    return rules
-
-
-def matches_any_pattern(text: str, patterns: list[str]) -> bool:
-    """Check if text matches any of the given regex patterns."""
-    for pattern in patterns:
-        try:
-            if re.search(pattern, text, re.IGNORECASE):
-                return True
-        except re.error:
-            continue
-    return False
-
-
-def check_sensitive_path(file_path: str, sensitive_patterns: list[str]) -> bool:
-    """Check if file path matches sensitive path patterns."""
-    if not file_path:
-        return False
-    return matches_any_pattern(file_path, sensitive_patterns)
-
-
-def split_compound_shell_command(command: str) -> list[str]:
-    """Split a shell command on simple compound operators (heuristic, not a full parser)."""
-    command = (command or "").strip()
-    if not command:
-        return []
-    # Common patterns produced by agents: `cd x && pnpm test`, `cmd1; cmd2`
-    return [p.strip() for p in re.split(r"\s*(?:&&|;)\s*", command) if p.strip()]
-
-
-def is_shell_file_read_command(command: str) -> bool:
-    """Detect common shell file-read commands that could exfiltrate secrets."""
-    return bool(re.search(r"^\s*(cat|head|tail|less)\b", command or "", re.IGNORECASE))
-
-
-def summarize_tool_input(tool_name: str, tool_input: dict) -> dict:
-    """Small, reviewable summary for decision logs."""
-    if tool_name == "Bash":
-        return {"command": tool_input.get("command", "")}
-    if tool_name in ("Read", "Write", "Edit", "MultiEdit"):
-        return {"file_path": tool_input.get("file_path", "")}
-    return {"tool_input_keys": list((tool_input or {}).keys())}
-
-
-def log_decision(tool_name: str, tool_input: dict, decision: str, reason: str) -> None:
-    """Append a decision record to a jsonl file when debugging is enabled."""
-    if not ENABLE_DECISION_LOG:
-        return
-
-    log_path = Path.cwd() / ".claude" / "auto_approve_safe.decisions.jsonl"
-    record = {
-        "ts": datetime.now(timezone.utc).isoformat(),
-        "cwd": str(Path.cwd()),
-        "tool_name": tool_name,
-        "decision": decision,
-        "reason": reason,
-        "input": summarize_tool_input(tool_name, tool_input or {}),
-    }
-
-    try:
-        log_path.parent.mkdir(parents=True, exist_ok=True)
-        with open(log_path, "a", encoding="utf-8") as f:
-            f.write(json.dumps(record, ensure_ascii=False) + "\n")
-    except Exception as e:
-        # Never break tool execution because logging failed.
-        print(f"Warning: Could not write decision log: {e}", file=sys.stderr)
-
-
-def make_decision(tool_name: str, tool_input: dict, rules: dict) -> tuple[str, str]:
-    """
-    Determine permission decision for a tool call.
-
-    Returns:
-        tuple: (decision, reason)
-            decision: "allow", "deny", or "ask"
-            reason: Human-readable explanation
-
-    Notes on integration with Claude Code:
-      - "allow" short-circuits Claude Code prompts
-      - "deny" blocks the tool
-      - "ask" defers to Claude Code's built-in permission system
-
-    This file is tuned for maximum autonomy by default, while:
-      - denying obvious dangerous commands
-      - blocking edits to sensitive paths
-      - prompting for reads of sensitive paths
-    """
-    tool_input = tool_input or {}
-
-    # Handle Bash commands
-    if tool_name == "Bash":
-        command = (tool_input.get("command", "") or "").strip()
-        if not command:
-            return "ask", "Empty command"
-
-        segments = split_compound_shell_command(command)
-        if not segments:
-            return "ask", "Empty command"
-
-        # Deny wins if any segment matches a deny pattern.
-        for seg in segments:
-            if matches_any_pattern(seg, rules["deny_patterns"]):
-                return "deny", "Command matches dangerous pattern"
-
-        # If a segment looks like it could read a file, apply sensitive path checks.
-        # (Prevents silently allowing: `cat .env`, `head ~/.ssh/id_rsa`, etc.)
-        for seg in segments:
-            if is_shell_file_read_command(seg) and matches_any_pattern(seg, rules["sensitive_paths"]):
-                return "ask", "Bash command may read sensitive data"
-
-        # Max autonomy, but still require an allowlist match per segment.
-        # Add common "glue" patterns that agents use.
-        glue_allow_patterns = [
-            r"^cd\s+\S+(\s+.*)?$",
-            r"^pushd\s+\S+(\s+.*)?$",
-            r"^popd$",
-            r"^export\s+[A-Za-z_][A-Za-z0-9_]*=.*$",
-            r"^(true|false)$",
-        ]
-
-        for seg in segments:
-            if matches_any_pattern(seg, rules["allow_patterns"]):
-                continue
-            if matches_any_pattern(seg, glue_allow_patterns):
-                continue
-            return "ask", f"Command not in allowlist: {seg}"
-
-        return "allow", "Matches safe allowlist"
-
-    # Handle Read tool - check for sensitive files
-    if tool_name == "Read":
-        file_path = tool_input.get("file_path", "")
-        if check_sensitive_path(file_path, rules["sensitive_paths"]):
-            return "ask", "File may contain sensitive data"
-        return "allow", "Read operations are generally safe"
-
-    # Handle Grep/Glob - generally safe read-only operations
-    if tool_name in ("Grep", "Glob"):
-        return "allow", "Search operations are read-only"
-
-    # Handle Write/Edit - max autonomy by default; still protect sensitive paths.
-    if tool_name in ("Write", "Edit", "MultiEdit"):
-        file_path = tool_input.get("file_path", "")
-        if check_sensitive_path(file_path, rules["sensitive_paths"]):
-            return "deny", "Cannot modify sensitive files"
-        return "allow", "Write operations are generally safe"
-
-    # Default: defer to normal permission system
-    return "ask", "Unknown tool, deferring to permission system"
-
-
-def output_decision(decision: str, reason: str) -> None:
-    """Output the hook decision in Claude Code's expected format."""
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "permissionDecision": decision,
-            "permissionDecisionReason": reason
-        }
-    }
-    print(json.dumps(output))
-
-
-def main():
-    """Main entry point for the hook."""
-    try:
-        # Read input from stdin
-        input_data = sys.stdin.read()
-        if not input_data.strip():
-            output_decision("ask", "No input received")
-            return
-
-        data = json.loads(input_data)
-
-        # Extract tool information
-        tool_name = data.get("tool_name", "")
-        tool_input = data.get("tool_input", {})
-
-        # Load rules
-        rules = load_rules()
-
-        # Make decision
-        decision, reason = make_decision(tool_name, tool_input, rules)
-
-        # Optional debug log
-        log_decision(tool_name, tool_input, decision, reason)
-
-        # Output result
-        output_decision(decision, reason)
-
-    except json.JSONDecodeError as e:
-        print(f"Error parsing input JSON: {e}", file=sys.stderr)
-        output_decision("ask", "Failed to parse input")
-    except Exception as e:
-        print(f"Hook error: {e}", file=sys.stderr)
-        output_decision("ask", f"Hook error: {e}")
-
-
-if __name__ == "__main__":
-    main()
-
-