@fro.bot/systematic 1.0.0

package/dist/index.js

@@ -0,0 +1,297 @@
+import {
+  extractAgentFrontmatter,
+  extractCommandFrontmatter,
+  findAgentsInDir,
+  findCommandsInDir,
+  findSkillsInDir,
+  stripFrontmatter
+} from "./index-v8dhd5s2.js";
+
+// src/index.ts
+import fs3 from "node:fs";
+import os2 from "node:os";
+import path2 from "node:path";
+import { fileURLToPath } from "node:url";
+import { tool } from "@opencode-ai/plugin/tool";
+
+// src/lib/config-handler.ts
+import fs2 from "node:fs";
+
+// src/lib/config.ts
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { parse as parseJsonc } from "jsonc-parser";
+var DEFAULT_CONFIG = {
+  disabled_skills: [],
+  disabled_agents: [],
+  disabled_commands: [],
+  bootstrap: {
+    enabled: true
+  }
+};
+function loadJsoncFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath))
+      return null;
+    const content = fs.readFileSync(filePath, "utf-8");
+    return parseJsonc(content);
+  } catch {
+    return null;
+  }
+}
+function mergeArraysUnique(arr1, arr2) {
+  const set = new Set;
+  if (arr1)
+    arr1.forEach((item) => set.add(item));
+  if (arr2)
+    arr2.forEach((item) => set.add(item));
+  return Array.from(set);
+}
+function loadConfig(projectDir) {
+  const homeDir = os.homedir();
+  const userConfigPath = path.join(homeDir, ".config/opencode/systematic.json");
+  const projectConfigPath = path.join(projectDir, ".opencode/systematic.json");
+  const userConfig = loadJsoncFile(userConfigPath);
+  const projectConfig = loadJsoncFile(projectConfigPath);
+  const result = {
+    disabled_skills: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_skills, userConfig?.disabled_skills), projectConfig?.disabled_skills),
+    disabled_agents: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_agents, userConfig?.disabled_agents), projectConfig?.disabled_agents),
+    disabled_commands: mergeArraysUnique(mergeArraysUnique(DEFAULT_CONFIG.disabled_commands, userConfig?.disabled_commands), projectConfig?.disabled_commands),
+    bootstrap: {
+      ...DEFAULT_CONFIG.bootstrap,
+      ...userConfig?.bootstrap,
+      ...projectConfig?.bootstrap
+    }
+  };
+  return result;
+}
+
+// src/lib/config-handler.ts
+function loadAgentAsConfig(agentInfo) {
+  try {
+    const content = fs2.readFileSync(agentInfo.file, "utf8");
+    const { name, description, prompt } = extractAgentFrontmatter(content);
+    return {
+      description: description || `${name || agentInfo.name} agent`,
+      prompt: prompt || stripFrontmatter(content)
+    };
+  } catch {
+    return null;
+  }
+}
+function loadCommandAsConfig(commandInfo) {
+  try {
+    const content = fs2.readFileSync(commandInfo.file, "utf8");
+    const { name, description } = extractCommandFrontmatter(content);
+    const cleanName = commandInfo.name.replace(/^\//, "");
+    return {
+      template: stripFrontmatter(content),
+      description: description || `${name || cleanName} command`
+    };
+  } catch {
+    return null;
+  }
+}
+function loadSkillAsCommand(skillInfo) {
+  try {
+    const content = fs2.readFileSync(skillInfo.skillFile, "utf8");
+    return {
+      template: stripFrontmatter(content),
+      description: skillInfo.description || `${skillInfo.name} skill`
+    };
+  } catch {
+    return null;
+  }
+}
+function collectAgents(dir, sourceType, disabledAgents) {
+  const agents = {};
+  const agentList = findAgentsInDir(dir, sourceType);
+  for (const agentInfo of agentList) {
+    if (disabledAgents.includes(agentInfo.name))
+      continue;
+    const config = loadAgentAsConfig(agentInfo);
+    if (config) {
+      agents[agentInfo.name] = config;
+    }
+  }
+  return agents;
+}
+function collectCommands(dir, sourceType, disabledCommands) {
+  const commands = {};
+  const commandList = findCommandsInDir(dir, sourceType);
+  for (const commandInfo of commandList) {
+    const cleanName = commandInfo.name.replace(/^\//, "");
+    if (disabledCommands.includes(cleanName))
+      continue;
+    const config = loadCommandAsConfig(commandInfo);
+    if (config) {
+      commands[cleanName] = config;
+    }
+  }
+  return commands;
+}
+function collectSkillsAsCommands(dir, sourceType, disabledSkills) {
+  const commands = {};
+  const skillList = findSkillsInDir(dir, sourceType, 3);
+  for (const skillInfo of skillList) {
+    if (disabledSkills.includes(skillInfo.name))
+      continue;
+    const config = loadSkillAsCommand(skillInfo);
+    if (config) {
+      commands[skillInfo.name] = config;
+    }
+  }
+  return commands;
+}
+function createConfigHandler(deps) {
+  const { directory, bundledSkillsDir, bundledAgentsDir, bundledCommandsDir } = deps;
+  return async (config) => {
+    const systematicConfig = loadConfig(directory);
+    const bundledAgents = collectAgents(bundledAgentsDir, "bundled", systematicConfig.disabled_agents);
+    const bundledCommands = collectCommands(bundledCommandsDir, "bundled", systematicConfig.disabled_commands);
+    const bundledSkills = collectSkillsAsCommands(bundledSkillsDir, "bundled", systematicConfig.disabled_skills);
+    const existingAgents = config.agent ?? {};
+    config.agent = {
+      ...bundledAgents,
+      ...existingAgents
+    };
+    const existingCommands = config.command ?? {};
+    config.command = {
+      ...bundledCommands,
+      ...bundledSkills,
+      ...existingCommands
+    };
+  };
+}
+
+// src/index.ts
+var __dirname2 = path2.dirname(fileURLToPath(import.meta.url));
+var packageRoot = path2.resolve(__dirname2, "..");
+var bundledSkillsDir = path2.join(packageRoot, "skills");
+var bundledAgentsDir = path2.join(packageRoot, "agents");
+var bundledCommandsDir = path2.join(packageRoot, "commands");
+function formatItemList(items, emptyMessage, header) {
+  if (items.length === 0)
+    return emptyMessage;
+  let output = header;
+  for (const item of items) {
+    output += `- ${item.name} (${item.sourceType})
+`;
+  }
+  return output;
+}
+var getBootstrapContent = (config) => {
+  if (!config.bootstrap.enabled)
+    return null;
+  if (config.bootstrap.file) {
+    const customPath = config.bootstrap.file.startsWith("~/") ? path2.join(os2.homedir(), config.bootstrap.file.slice(2)) : config.bootstrap.file;
+    if (fs3.existsSync(customPath)) {
+      return fs3.readFileSync(customPath, "utf8");
+    }
+  }
+  const usingSystematicPath = path2.join(bundledSkillsDir, "using-systematic/SKILL.md");
+  if (!fs3.existsSync(usingSystematicPath))
+    return null;
+  const fullContent = fs3.readFileSync(usingSystematicPath, "utf8");
+  const content = stripFrontmatter(fullContent);
+  const toolMapping = `**Tool Mapping for OpenCode:**
+When skills reference tools you don't have, substitute OpenCode equivalents:
+- \`TodoWrite\` → \`update_plan\`
+- \`Task\` tool with subagents → Use OpenCode's subagent system (@mention)
+- \`Skill\` tool → OpenCode's native \`skill\` tool
+- \`Read\`, \`Write\`, \`Edit\`, \`Bash\` → Your native tools
+
+**Skills naming:**
+- Bundled skills use the \`systematic:\` prefix (e.g., \`systematic:brainstorming\`)
+- Skills can also be invoked without prefix if unambiguous
+
+**Skills location:**
+Bundled skills are in \`${bundledSkillsDir}/\`
+Use \`systematic_find_skills\` to list all available skills.`;
+  return `<SYSTEMATIC_WORKFLOWS>
+You have access to structured engineering workflows via the systematic plugin.
+
+**IMPORTANT: The using-systematic skill content is included below. It is ALREADY LOADED - you are currently following it. Do NOT use the skill tool to load "using-systematic" again - that would be redundant.**
+
+${content}
+
+${toolMapping}
+</SYSTEMATIC_WORKFLOWS>`;
+};
+var SystematicPlugin = async ({ client, directory }) => {
+  const config = loadConfig(directory);
+  const configHandler = createConfigHandler({
+    directory,
+    bundledSkillsDir,
+    bundledAgentsDir,
+    bundledCommandsDir
+  });
+  return {
+    config: configHandler,
+    tool: {
+      systematic_find_skills: tool({
+        description: "List all available skills in the bundled skill library.",
+        args: {},
+        execute: async () => {
+          const bundledSkills = findSkillsInDir(bundledSkillsDir, "bundled", 3);
+          const skills = bundledSkills.filter((s) => !config.disabled_skills.includes(s.name)).sort((a, b) => a.name.localeCompare(b.name));
+          if (skills.length === 0) {
+            return "No skills available. Skills are bundled with the systematic plugin.";
+          }
+          let output = `Available skills:
+
+`;
+          for (const skill of skills) {
+            output += `systematic:${skill.name}
+`;
+            if (skill.description) {
+              output += `  ${skill.description}
+`;
+            }
+            output += `  Directory: ${skill.path}
+
+`;
+          }
+          return output.trim();
+        }
+      }),
+      systematic_find_agents: tool({
+        description: "List all available review agents.",
+        args: {},
+        execute: async () => {
+          const bundledAgents = findAgentsInDir(bundledAgentsDir, "bundled");
+          const agents = bundledAgents.filter((a) => !config.disabled_agents.includes(a.name)).sort((a, b) => a.name.localeCompare(b.name));
+          return formatItemList(agents, "No agents available.", `Available agents:
+
+`);
+        }
+      }),
+      systematic_find_commands: tool({
+        description: "List all available commands.",
+        args: {},
+        execute: async () => {
+          const bundledCommands = findCommandsInDir(bundledCommandsDir, "bundled");
+          const commands = bundledCommands.filter((c) => !config.disabled_commands.includes(c.name.replace(/^\//, ""))).sort((a, b) => a.name.localeCompare(b.name));
+          return formatItemList(commands, "No commands available.", `Available commands:
+
+`);
+        }
+      })
+    },
+    "experimental.chat.system.transform": async (_input, output) => {
+      const content = getBootstrapContent(config);
+      if (content) {
+        if (!output.system) {
+          output.system = [];
+        }
+        output.system.push(content);
+      }
+    }
+  };
+};
+var src_default = SystematicPlugin;
+export {
+  src_default as default,
+  SystematicPlugin
+};

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@fro.bot/systematic",
+  "version": "1.0.0",
+  "description": "Structured engineering workflows for OpenCode",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "systematic": "./dist/cli.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "skills",
+    "agents",
+    "commands"
+  ],
+  "scripts": {
+    "build": "bun build src/index.ts src/cli.ts --outdir dist --target node --format esm --splitting --external @opencode-ai/plugin/tool --external jsonc-parser",
+    "dev": "bun --watch src/index.ts",
+    "test": "bun test tests/unit",
+    "test:integration": "bun test tests/integration",
+    "test:all": "bun test",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check .",
+    "prepublishOnly": "bun run build && bun run test"
+  },
+  "keywords": [
+    "opencode",
+    "plugin",
+    "ai",
+    "workflow",
+    "engineering"
+  ],
+  "author": "Marcus R. Brown",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/marcusrbrown/systematic.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": "^1.1.30"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.0",
+    "@opencode-ai/plugin": "^1.1.30",
+    "@types/bun": "latest",
+    "@types/node": "^22.0.0",
+    "conventional-changelog-conventionalcommits": "^9.0.0",
+    "markdownlint-cli": "^0.47.0",
+    "semantic-release": "^25.0.0",
+    "semantic-release-export-data": "^1.2.0",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "jsonc-parser": "^3.3.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  }
+}

package/skills/agent-browser/SKILL.md

@@ -0,0 +1,223 @@
+---
+name: agent-browser
+description: Browser automation using Vercel's agent-browser CLI. Use when you need to interact with web pages, fill forms, take screenshots, or scrape data. Alternative to Playwright MCP - uses Bash commands with ref-based element selection. Triggers on "browse website", "fill form", "click button", "take screenshot", "scrape page", "web automation".
+---
+
+# agent-browser: CLI Browser Automation
+
+Vercel's headless browser automation CLI designed for AI agents. Uses ref-based selection (@e1, @e2) from accessibility snapshots.
+
+## Setup Check
+
+```bash
+# Check installation
+command -v agent-browser >/dev/null 2>&1 && echo "Installed" || echo "NOT INSTALLED - run: npm install -g agent-browser && agent-browser install"
+```
+
+### Install if needed
+
+```bash
+npm install -g agent-browser
+agent-browser install  # Downloads Chromium
+```
+
+## Core Workflow
+
+**The snapshot + ref pattern is optimal for LLMs:**
+
+1. **Navigate** to URL
+2. **Snapshot** to get interactive elements with refs
+3. **Interact** using refs (@e1, @e2, etc.)
+4. **Re-snapshot** after navigation or DOM changes
+
+```bash
+# Step 1: Open URL
+agent-browser open https://example.com
+
+# Step 2: Get interactive elements with refs
+agent-browser snapshot -i --json
+
+# Step 3: Interact using refs
+agent-browser click @e1
+agent-browser fill @e2 "search query"
+
+# Step 4: Re-snapshot after changes
+agent-browser snapshot -i
+```
+
+## Key Commands
+
+### Navigation
+
+```bash
+agent-browser open <url>       # Navigate to URL
+agent-browser back             # Go back
+agent-browser forward          # Go forward
+agent-browser reload           # Reload page
+agent-browser close            # Close browser
+```
+
+### Snapshots (Essential for AI)
+
+```bash
+agent-browser snapshot              # Full accessibility tree
+agent-browser snapshot -i           # Interactive elements only (recommended)
+agent-browser snapshot -i --json    # JSON output for parsing
+agent-browser snapshot -c           # Compact (remove empty elements)
+agent-browser snapshot -d 3         # Limit depth
+```
+
+### Interactions
+
+```bash
+agent-browser click @e1                    # Click element
+agent-browser dblclick @e1                 # Double-click
+agent-browser fill @e1 "text"              # Clear and fill input
+agent-browser type @e1 "text"              # Type without clearing
+agent-browser press Enter                  # Press key
+agent-browser hover @e1                    # Hover element
+agent-browser check @e1                    # Check checkbox
+agent-browser uncheck @e1                  # Uncheck checkbox
+agent-browser select @e1 "option"          # Select dropdown option
+agent-browser scroll down 500              # Scroll (up/down/left/right)
+agent-browser scrollintoview @e1           # Scroll element into view
+```
+
+### Get Information
+
+```bash
+agent-browser get text @e1          # Get element text
+agent-browser get html @e1          # Get element HTML
+agent-browser get value @e1         # Get input value
+agent-browser get attr href @e1     # Get attribute
+agent-browser get title             # Get page title
+agent-browser get url               # Get current URL
+agent-browser get count "button"    # Count matching elements
+```
+
+### Screenshots & PDFs
+
+```bash
+agent-browser screenshot                      # Viewport screenshot
+agent-browser screenshot --full               # Full page
+agent-browser screenshot output.png           # Save to file
+agent-browser screenshot --full output.png    # Full page to file
+agent-browser pdf output.pdf                  # Save as PDF
+```
+
+### Wait
+
+```bash
+agent-browser wait @e1              # Wait for element
+agent-browser wait 2000             # Wait milliseconds
+agent-browser wait "text"           # Wait for text to appear
+```
+
+## Semantic Locators (Alternative to Refs)
+
+```bash
+agent-browser find role button click --name "Submit"
+agent-browser find text "Sign up" click
+agent-browser find label "Email" fill "user@example.com"
+agent-browser find placeholder "Search..." fill "query"
+```
+
+## Sessions (Parallel Browsers)
+
+```bash
+# Run multiple independent browser sessions
+agent-browser --session browser1 open https://site1.com
+agent-browser --session browser2 open https://site2.com
+
+# List active sessions
+agent-browser session list
+```
+
+## Examples
+
+### Login Flow
+
+```bash
+agent-browser open https://app.example.com/login
+agent-browser snapshot -i
+# Output shows: textbox "Email" [ref=e1], textbox "Password" [ref=e2], button "Sign in" [ref=e3]
+agent-browser fill @e1 "user@example.com"
+agent-browser fill @e2 "password123"
+agent-browser click @e3
+agent-browser wait 2000
+agent-browser snapshot -i  # Verify logged in
+```
+
+### Search and Extract
+
+```bash
+agent-browser open https://news.ycombinator.com
+agent-browser snapshot -i --json
+# Parse JSON to find story links
+agent-browser get text @e12  # Get headline text
+agent-browser click @e12     # Click to open story
+```
+
+### Form Filling
+
+```bash
+agent-browser open https://forms.example.com
+agent-browser snapshot -i
+agent-browser fill @e1 "John Doe"
+agent-browser fill @e2 "john@example.com"
+agent-browser select @e3 "United States"
+agent-browser check @e4  # Agree to terms
+agent-browser click @e5  # Submit button
+agent-browser screenshot confirmation.png
+```
+
+### Debug Mode
+
+```bash
+# Run with visible browser window
+agent-browser --headed open https://example.com
+agent-browser --headed snapshot -i
+agent-browser --headed click @e1
+```
+
+## JSON Output
+
+Add `--json` for structured output:
+
+```bash
+agent-browser snapshot -i --json
+```
+
+Returns:
+```json
+{
+  "success": true,
+  "data": {
+    "refs": {
+      "e1": {"name": "Submit", "role": "button"},
+      "e2": {"name": "Email", "role": "textbox"}
+    },
+    "snapshot": "- button \"Submit\" [ref=e1]\n- textbox \"Email\" [ref=e2]"
+  }
+}
+```
+
+## vs Playwright MCP
+
+| Feature | agent-browser (CLI) | Playwright MCP |
+|---------|---------------------|----------------|
+| Interface | Bash commands | MCP tools |
+| Selection | Refs (@e1) | Refs (e1) |
+| Output | Text/JSON | Tool responses |
+| Parallel | Sessions | Tabs |
+| Best for | Quick automation | Tool integration |
+
+Use agent-browser when:
+- You prefer Bash-based workflows
+- You want simpler CLI commands
+- You need quick one-off automation
+
+Use Playwright MCP when:
+- You need deep MCP tool integration
+- You want tool-based responses
+- You're building complex automation