moflo 4.8.11 → 4.8.12

package/.claude/skills/browser/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: browser
+description: Web browser automation with AI-optimized snapshots for claude-flow agents
+version: 1.0.0
+triggers:
+  - /browser
+  - browse
+  - web automation
+  - scrape
+  - navigate
+  - screenshot
+tools:
+  - browser/open
+  - browser/snapshot
+  - browser/click
+  - browser/fill
+  - browser/screenshot
+  - browser/close
+---
+
+# Browser Automation Skill
+
+Web browser automation using agent-browser with AI-optimized snapshots. Reduces context by 93% using element refs (@e1, @e2) instead of full DOM.
+
+## Core Workflow
+
+```bash
+# 1. Navigate to page
+agent-browser open <url>
+
+# 2. Get accessibility tree with element refs
+agent-browser snapshot -i    # -i = interactive elements only
+
+# 3. Interact using refs from snapshot
+agent-browser click @e2
+agent-browser fill @e3 "text"
+
+# 4. Re-snapshot after page changes
+agent-browser snapshot -i
+```
+
+## Quick Reference
+
+### Navigation
+| Command | Description |
+|---------|-------------|
+| `open <url>` | Navigate to URL |
+| `back` | Go back |
+| `forward` | Go forward |
+| `reload` | Reload page |
+| `close` | Close browser |
+
+### Snapshots (AI-Optimized)
+| Command | Description |
+|---------|-------------|
+| `snapshot` | Full accessibility tree |
+| `snapshot -i` | Interactive elements only (buttons, links, inputs) |
+| `snapshot -c` | Compact (remove empty elements) |
+| `snapshot -d 3` | Limit depth to 3 levels |
+| `screenshot [path]` | Capture screenshot (base64 if no path) |
+
+### Interaction
+| Command | Description |
+|---------|-------------|
+| `click <sel>` | Click element |
+| `fill <sel> <text>` | Clear and fill input |
+| `type <sel> <text>` | Type with key events |
+| `press <key>` | Press key (Enter, Tab, etc.) |
+| `hover <sel>` | Hover element |
+| `select <sel> <val>` | Select dropdown option |
+| `check/uncheck <sel>` | Toggle checkbox |
+| `scroll <dir> [px]` | Scroll page |
+
+### Get Info
+| Command | Description |
+|---------|-------------|
+| `get text <sel>` | Get text content |
+| `get html <sel>` | Get innerHTML |
+| `get value <sel>` | Get input value |
+| `get attr <sel> <attr>` | Get attribute |
+| `get title` | Get page title |
+| `get url` | Get current URL |
+
+### Wait
+| Command | Description |
+|---------|-------------|
+| `wait <selector>` | Wait for element |
+| `wait <ms>` | Wait milliseconds |
+| `wait --text "text"` | Wait for text |
+| `wait --url "pattern"` | Wait for URL |
+| `wait --load networkidle` | Wait for load state |
+
+### Sessions
+| Command | Description |
+|---------|-------------|
+| `--session <name>` | Use isolated session |
+| `session list` | List active sessions |
+
+## Selectors
+
+### Element Refs (Recommended)
+```bash
+# Get refs from snapshot
+agent-browser snapshot -i
+# Output: button "Submit" [ref=e2]
+
+# Use ref to interact
+agent-browser click @e2
+```
+
+### CSS Selectors
+```bash
+agent-browser click "#submit"
+agent-browser fill ".email-input" "test@test.com"
+```
+
+### Semantic Locators
+```bash
+agent-browser find role button click --name "Submit"
+agent-browser find label "Email" fill "test@test.com"
+agent-browser find testid "login-btn" click
+```
+
+## Examples
+
+### Login Flow
+```bash
+agent-browser open https://example.com/login
+agent-browser snapshot -i
+agent-browser fill @e2 "user@example.com"
+agent-browser fill @e3 "password123"
+agent-browser click @e4
+agent-browser wait --url "**/dashboard"
+```
+
+### Form Submission
+```bash
+agent-browser open https://example.com/contact
+agent-browser snapshot -i
+agent-browser fill @e1 "John Doe"
+agent-browser fill @e2 "john@example.com"
+agent-browser fill @e3 "Hello, this is my message"
+agent-browser click @e4
+agent-browser wait --text "Thank you"
+```
+
+### Data Extraction
+```bash
+agent-browser open https://example.com/products
+agent-browser snapshot -i
+# Iterate through product refs
+agent-browser get text @e1  # Product name
+agent-browser get text @e2  # Price
+agent-browser get attr @e3 href  # Link
+```
+
+### Multi-Session (Swarm)
+```bash
+# Session 1: Navigator
+agent-browser --session nav open https://example.com
+agent-browser --session nav state save auth.json
+
+# Session 2: Scraper (uses same auth)
+agent-browser --session scrape state load auth.json
+agent-browser --session scrape open https://example.com/data
+agent-browser --session scrape snapshot -i
+```
+
+## Integration with Claude Flow
+
+### MCP Tools
+All browser operations are available as MCP tools with `browser/` prefix:
+- `browser/open`
+- `browser/snapshot`
+- `browser/click`
+- `browser/fill`
+- `browser/screenshot`
+- etc.
+
+### Memory Integration
+```bash
+# Store successful patterns
+npx @claude-flow/cli memory store --namespace browser-patterns --key "login-flow" --value "snapshot->fill->click->wait"
+
+# Retrieve before similar task
+npx @claude-flow/cli memory search --query "login automation"
+```
+
+### Hooks
+```bash
+# Pre-browse hook (get context)
+npx @claude-flow/cli hooks pre-edit --file "browser-task.ts"
+
+# Post-browse hook (record success)
+npx @claude-flow/cli hooks post-task --task-id "browse-1" --success true
+```
+
+## Tips
+
+1. **Always use snapshots** - They're optimized for AI with refs
+2. **Prefer `-i` flag** - Gets only interactive elements, smaller output
+3. **Use refs, not selectors** - More reliable, deterministic
+4. **Re-snapshot after navigation** - Page state changes
+5. **Use sessions for parallel work** - Each session is isolated

package/.claude/workflow-state.json

@@ -0,0 +1,9 @@
+{
+  "tasksCreated": true,
+  "taskCount": 2,
+  "memorySearched": false,
+  "sessionStart": "2026-03-22T21:38:40.085Z",
+  "memoryRequired": true,
+  "interactionCount": 9,
+  "lastBlockedAt": "2026-03-22T21:51:54.015Z"
+}

package/bin/index-guidance.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * Index guidance files into claude-flow memory with full RAG linked segments
  *

package/bin/index-tests.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * Index test files into claude-flow memory under the `tests` namespace
  *

package/bin/semantic-search.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * Semantic search using 384-dim embeddings (Xenova/all-MiniLM-L6-v2 or hash fallback)
  *

package/bin/setup-project.mjs

@@ -1,4 +1,4 @@
-#!/usr/bin/env node
+#!/usr/bin/env node
 /**
  * MoFlo Project Setup
  *
@@ -29,67 +29,57 @@ const args = process.argv.slice(2);
 const updateOnly = args.includes('--update');
 const checkOnly = args.includes('--check');
 
-// Markers for idempotent CLAUDE.md updates
-const MARKER_START = '<!-- MOFLO:SUBAGENT-PROTOCOL:START -->';
-const MARKER_END = '<!-- MOFLO:SUBAGENT-PROTOCOL:END -->';
+// Markers for idempotent CLAUDE.md updates — keep in sync with claudemd-generator.ts
+const MARKER_START = '<!-- MOFLO:INJECTED:START -->';
+const MARKER_END = '<!-- MOFLO:INJECTED:END -->';
+// Legacy markers to detect and replace
+const LEGACY_STARTS = ['<!-- MOFLO:SUBAGENT-PROTOCOL:START -->', '<!-- MOFLO:START -->'];
+const LEGACY_ENDS = ['<!-- MOFLO:SUBAGENT-PROTOCOL:END -->', '<!-- MOFLO:END -->'];
 
+// Minimal injection — just enough for Claude to work with moflo.
+// All detailed docs live in .claude/guidance/shipped/moflo.md.
 const CLAUDE_MD_SECTION = `${MARKER_START}
-## FIRST ACTION ON EVERY PROMPT: Search Memory
+## MoFlo — AI Agent Orchestration
 
-Your first tool call for every new user prompt MUST be a memory search. Do this BEFORE Glob, Grep, Read, or any file exploration. No exceptions.
+This project uses [MoFlo](https://github.com/eric-cielo/moflo) for AI-assisted development workflows.
 
-WHY: Memory contains curated solutions, patterns, and architectural context from previous work. Without it, you will miss existing solutions, repeat mistakes that were already solved, and waste time re-discovering what is already known. Memory search is faster than file scanning.
+### FIRST ACTION ON EVERY PROMPT: Search Memory
 
-HOW: Use ToolSearch to load \`mcp__moflo__memory_search\`, then call it with a query describing your task. If MCP is unavailable, use:
-\`node bin/semantic-search.mjs "[task description]" --namespace guidance\`
+Your first tool call for every new user prompt MUST be a memory search. Do this BEFORE Glob, Grep, Read, or any file exploration.
 
-### Namespaces to search:
+\`\`\`
+mcp__moflo__memory_search — query: "<task description>", namespace: "guidance" or "patterns" or "code-map"
+\`\`\`
 
-| Namespace | When to search | What it returns |
-|-----------|---------------|-----------------|
-| \`guidance\` | Always — understanding patterns, rules, conventions | Guidance docs, coding rules, domain context |
-| \`patterns\` | Always — prior solutions and implementation patterns | Learned patterns from previous task execution |
-| \`code-map\` | Finding where code lives (files, types, services) | Type-to-file mappings, directory contents, project overviews |
+Search \`guidance\` and \`patterns\` namespaces on every prompt. Search \`code-map\` when navigating the codebase.
+When the user asks you to remember something: \`mcp__moflo__memory_store\` with namespace \`knowledge\`.
 
-**Always search both \`guidance\` and \`patterns\` namespaces.** The \`patterns\` namespace contains solutions to problems already solved — skipping it means repeating past mistakes.
+### Workflow Gates (enforced automatically)
 
-For **codebase navigation** (finding where a type/service/component lives), also search the \`code-map\` namespace.
+- **Memory-first**: Must search memory before Glob/Grep/Read
+- **TaskCreate-first**: Must call TaskCreate before spawning Agent tool
 
-## Memory System Access (MoFlo)
+### MCP Tools (preferred over CLI)
 
-### Primary: MCP Tools (preferred)
-\`\`\`
-mcp__moflo__memory_search   — query, namespace
-mcp__moflo__memory_store    — key, value, namespace
-mcp__moflo__memory_retrieve — key, namespace
-mcp__moflo__memory_list     — namespace, limit
-\`\`\`
-Load via ToolSearch first: \`+claude-flow memory\`
+| Tool | Purpose |
+|------|---------|
+| \`mcp__moflo__memory_search\` | Semantic search across indexed knowledge |
+| \`mcp__moflo__memory_store\` | Store patterns and decisions |
+| \`mcp__moflo__hooks_route\` | Route task to optimal agent type |
+| \`mcp__moflo__hooks_pre-task\` | Record task start |
+| \`mcp__moflo__hooks_post-task\` | Record task completion for learning |
+
+### CLI Fallback
 
-### Fallback: CLI Scripts
 \`\`\`bash
 npx flo-search "[query]" --namespace guidance   # Semantic search
-npx flo-embeddings                               # Rebuild embeddings
-npx flo-index                                    # Re-index guidance docs
-npx flo-codemap --force                          # Regenerate code-map
+npx flo doctor --fix                             # Health check
 \`\`\`
 
-### Where Content Goes
-
-| Content Type | Destination | How to Write |
-|-------------|-------------|--------------|
-| Debugging lessons (bug found, root cause, fix) | Memory DB — \`patterns\` namespace | \`mcp__moflo__memory_store\` |
-| Architectural decisions (chose X over Y, why) | Memory DB — \`decisions\` namespace | \`mcp__moflo__memory_store\` |
-| Learned patterns (task succeeded/failed, what worked) | Memory DB — \`patterns\` namespace | \`mcp__moflo__memory_store\` |
-| Coding rules (always/never do X in code) | \`.claude/guidance/\` files | Edit directly |
-| Process/workflow rules (CI, PR, gates) | \`CLAUDE.md\` | Edit directly |
-
-## Subagent Protocol (MoFlo)
+### Full Reference
 
-All subagents MUST read \`.claude/guidance/moflo-bootstrap.md\` before starting any work.
-It contains the memory-first protocol, discovery storage rules, and universal conventions.
-
-If \`.claude/guidance/agent-bootstrap.md\` also exists, read it next for project-specific rules.
+For CLI commands, hooks, agents, swarm config, memory commands, and moflo.yaml options, see:
+\`.claude/guidance/shipped/moflo.md\`
 ${MARKER_END}`;
 
 function log(msg) {
@@ -180,28 +170,35 @@ function updateClaudeMd(projectRoot) {
 
   const content = readFileSync(claudeMdPath, 'utf-8');
 
-  // Check if markers already exist
-  if (content.includes(MARKER_START)) {
-    // Extract existing section and compare
-    const startIdx = content.indexOf(MARKER_START);
-    const endIdx = content.indexOf(MARKER_END);
+  // Check for current or legacy markers and replace
+  const allStarts = [MARKER_START, ...LEGACY_STARTS];
+  const allEnds = [MARKER_END, ...LEGACY_ENDS];
+
+  for (let i = 0; i < allStarts.length; i++) {
+    if (content.includes(allStarts[i])) {
+      const startIdx = content.indexOf(allStarts[i]);
+      const endIdx = content.indexOf(allEnds[i]);
+
+      if (endIdx > startIdx) {
+        // If current markers and content matches, we're up to date
+        if (i === 0) {
+          const existingSection = content.substring(startIdx, endIdx + allEnds[i].length);
+          if (existingSection === CLAUDE_MD_SECTION) {
+            log('✅ CLAUDE.md moflo section is current');
+            return true;
+          }
+        }
 
-    if (endIdx > startIdx) {
-      const existingSection = content.substring(startIdx, endIdx + MARKER_END.length);
-      if (existingSection === CLAUDE_MD_SECTION) {
-        log('✅ CLAUDE.md subagent section is current');
+        // Replace (current or legacy) with new section
+        if (!checkOnly) {
+          const updated = content.substring(0, startIdx) + CLAUDE_MD_SECTION + content.substring(endIdx + allEnds[i].length);
+          writeFileSync(claudeMdPath, updated, 'utf-8');
+          log(i === 0 ? '📝 Updated CLAUDE.md moflo section' : '📝 Replaced legacy CLAUDE.md section with minimal moflo injection');
+        } else {
+          log('⚠️  CLAUDE.md moflo section needs update');
+        }
         return true;
       }
-
-      // Update existing section
-      if (!checkOnly) {
-        const updated = content.substring(0, startIdx) + CLAUDE_MD_SECTION + content.substring(endIdx + MARKER_END.length);
-        writeFileSync(claudeMdPath, updated, 'utf-8');
-        log('📝 Updated CLAUDE.md subagent protocol section');
-      } else {
-        log('⚠️  CLAUDE.md subagent section needs update');
-      }
-      return true;
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moflo",
-  "version": "4.8.11",
+  "version": "4.8.12",
   "description": "MoFlo — AI agent orchestration for Claude Code. Forked from ruflo/claude-flow with patches applied to source, plus feature-level orchestration.",
   "main": "dist/index.js",
   "type": "module",
@@ -85,7 +85,7 @@
     "@types/bcrypt": "^5.0.2",
     "@types/node": "^20.19.37",
     "eslint": "^8.0.0",
-    "moflo": "^4.8.9",
+    "moflo": "^4.8.11",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vitest": "^4.0.0"

package/src/@claude-flow/cli/dist/src/init/claudemd-generator.d.ts

@@ -1,25 +1,30 @@
-/**
- * CLAUDE.md Generator
- * Generates enforceable, analyzer-optimized Claude Code configuration
- * with template variants for different usage patterns.
- *
- * Templates: minimal | standard | full | security | performance | solo
- * All templates use bullet-format rules with imperative keywords for enforceability.
- */
-import type { InitOptions, ClaudeMdTemplate } from './types.js';
-/**
- * Generate CLAUDE.md content based on init options and template.
- * Template is determined by: options.runtime.claudeMdTemplate > explicit param > 'standard'
- */
-export declare function generateClaudeMd(options: InitOptions, template?: ClaudeMdTemplate): string;
-/**
- * Generate minimal CLAUDE.md content (backward-compatible alias).
- */
-export declare function generateMinimalClaudeMd(options: InitOptions): string;
-/** Available template names for CLI wizard */
-export declare const CLAUDE_MD_TEMPLATES: Array<{
-    name: ClaudeMdTemplate;
-    description: string;
-}>;
-export default generateClaudeMd;
+/**
+ * CLAUDE.md Generator
+ *
+ * Generates ONLY the MoFlo section to inject into a project's CLAUDE.md.
+ * This must be minimal — just enough for Claude to work with moflo.
+ * All detailed docs live in .claude/guidance/shipped/moflo.md (copied at install).
+ *
+ * Principle: we are guests in the user's CLAUDE.md. Keep it small.
+ */
+import type { InitOptions, ClaudeMdTemplate } from './types.js';
+declare const MARKER_START = "<!-- MOFLO:INJECTED:START -->";
+declare const MARKER_END = "<!-- MOFLO:INJECTED:END -->";
+export { MARKER_START, MARKER_END };
+/**
+ * Generate the MoFlo section to inject into CLAUDE.md.
+ * Template parameter is accepted for backward compatibility but ignored —
+ * all templates now produce the same minimal injection.
+ */
+export declare function generateClaudeMd(_options: InitOptions, _template?: ClaudeMdTemplate): string;
+/**
+ * Generate minimal CLAUDE.md content (backward-compatible alias).
+ */
+export declare function generateMinimalClaudeMd(options: InitOptions): string;
+/** Available template names for CLI wizard (kept for backward compat, all produce same output) */
+export declare const CLAUDE_MD_TEMPLATES: Array<{
+    name: ClaudeMdTemplate;
+    description: string;
+}>;
+export default generateClaudeMd;
 //# sourceMappingURL=claudemd-generator.d.ts.map