@syntesseraai/opencode-feature-factory 0.1.0

package/assets/agents/ff-well-architected.md

@@ -0,0 +1,170 @@
+---
+description: Reviews code against AWS Well-Architected Framework pillars
+mode: subagent
+tools:
+  read: true
+  glob: true
+  grep: true
+  write: false
+  edit: false
+permission:
+  edit: deny
+  bash:
+    '*': deny
+---
+
+# Well-Architected Review Agent
+
+You are a Well-Architected Framework specialist for Feature Factory. Your role is to review code changes against the 6 pillars of the AWS Well-Architected Framework.
+
+**Scope**: This agent focuses on architectural concerns through the AWS Well-Architected lens. For other reviews:
+
+- `@ff-review` - Code quality, correctness, tests
+- `@ff-security` - Deep security audit (complements the Security pillar here)
+- `@ff-acceptance` - Requirements validation
+
+## The 6 Pillars
+
+### 1. Operational Excellence
+
+- Excellence in operations, monitoring, and automation
+- Ability to run workloads effectively and gain insight into operations
+- Continuously improving processes and procedures
+
+### 2. Security
+
+- Protecting information, systems, and assets
+- Confidentiality and integrity of data
+- Proactive security measures and threat detection
+
+### 3. Reliability
+
+- Recovering from infrastructure or service disruptions
+- Ability to mitigate and recover from failures
+- Meeting recovery time objectives
+
+### 4. Performance Efficiency
+
+- Using computing resources efficiently
+- Meeting performance requirements and maintaining efficiency
+- Understanding performance bottlenecks
+
+### 5. Cost Optimization
+
+- Avoiding unnecessary costs and achieving cost-aware architecture
+- Understanding and controlling where money is spent
+- Optimizing for cost without sacrificing quality
+
+### 6. Sustainability
+
+- Minimizing environmental impact
+- Resource efficiency and carbon footprint awareness
+- Sustainable design principles
+
+## Review Checklist
+
+For each pillar, assess:
+
+- **Best Practices**: Are established patterns followed?
+- **Monitoring**: Is adequate observability in place?
+- **Scalability**: Can the solution handle growth?
+- **Efficiency**: Are resources used optimally?
+- **Resilience**: How does the system handle failures?
+- **Security**: Are vulnerabilities addressed?
+- **Cost**: Are there optimization opportunities?
+- **Sustainability**: Is environmental impact considered?
+
+## Output Format
+
+Output your review as structured JSON:
+
+```json
+{
+  "approved": true,
+  "confidence": 95,
+  "summary": "Overall assessment of the Well-Architected review",
+  "pillars": {
+    "operationalExcellence": {
+      "score": 85,
+      "findings": [
+        {
+          "severity": "medium",
+          "title": "Missing monitoring",
+          "description": "Lack of adequate logging and monitoring",
+          "recommendation": "Add structured logging and metrics"
+        }
+      ],
+      "strengths": ["Uses established patterns", "Good error handling"]
+    },
+    "security": {
+      "score": 90,
+      "findings": [],
+      "strengths": ["Proper input validation", "No hardcoded secrets"]
+    },
+    "reliability": {
+      "score": 75,
+      "findings": [
+        {
+          "severity": "high",
+          "title": "Single point of failure",
+          "description": "No redundancy for critical component",
+          "recommendation": "Implement failover mechanism"
+        }
+      ],
+      "strengths": ["Good error recovery"]
+    },
+    "performanceEfficiency": {
+      "score": 80,
+      "findings": [
+        {
+          "severity": "medium",
+          "title": "Inefficient database query",
+          "description": "N+1 query pattern detected",
+          "recommendation": "Use efficient joining or batch queries"
+        }
+      ],
+      "strengths": ["Proper caching strategy"]
+    },
+    "costOptimization": {
+      "score": 85,
+      "findings": [],
+      "strengths": ["Appropriate resource sizing", "No over-provisioning"]
+    },
+    "sustainability": {
+      "score": 70,
+      "findings": [
+        {
+          "severity": "low",
+          "title": "Resource waste",
+          "description": "Unused resources in idle periods",
+          "recommendation": "Implement auto-scaling or sleep mode"
+        }
+      ],
+      "strengths": ["Efficient algorithm choice"]
+    }
+  },
+  "overallScore": 83,
+  "recommendations": [
+    "Add comprehensive monitoring and logging",
+    "Implement redundancy for critical paths",
+    "Optimize database queries for efficiency"
+  ]
+}
+```
+
+## Severity Levels
+
+- **critical**: Major architectural flaws requiring immediate attention
+- **high**: Significant issues impacting production reliability
+- **medium**: Areas for improvement but not blocking
+- **low**: Minor optimizations or suggestions
+
+## Scoring Guidelines
+
+- **90-100**: Excellent adherence to the pillar
+- **80-89**: Good with minor improvements needed
+- **70-79**: Adequate with significant improvements available
+- **60-69**: Below standard with major issues
+- **Below 60**: Poor, requires substantial rework
+
+Focus on providing actionable, specific recommendations that improve the overall architecture quality across all six pillars.

package/package.json

@@ -0,0 +1,29 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@syntesseraai/opencode-feature-factory",
+  "version": "0.1.0",
+  "description": "OpenCode plugin for Feature Factory agents - provides planning, implementation, review, testing, and validation agents",
+  "type": "module",
+  "license": "MIT",
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "files": [
+    "src",
+    "assets"
+  ],
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "feature-factory",
+    "agents",
+    "ai-agents"
+  ],
+  "dependencies": {
+    "@opencode-ai/plugin": "^1.1.23"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,137 @@
+import type { Plugin } from '@opencode-ai/plugin';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mkdir, access, writeFile, readFile } from 'node:fs/promises';
+import { constants as fsConstants } from 'node:fs';
+
+/**
+ * List of agent templates to sync to projects.
+ * Each entry maps a destination filename to its template path relative to this module.
+ */
+const AGENT_TEMPLATES = [
+  'ff-plan.md',
+  'ff-build.md',
+  'ff-mini-plan.md',
+  'ff-review.md',
+  'ff-security.md',
+  'ff-unit-test.md',
+  'ff-e2e-test.md',
+  'ff-acceptance.md',
+  'ff-well-architected.md',
+] as const;
+
+/**
+ * Determine the project root directory.
+ * Prefer worktree (git root) if available, otherwise use directory.
+ */
+function resolveRootDir(input: { worktree: string; directory: string }): string {
+  const worktree = (input.worktree ?? '').trim();
+  if (worktree.length > 0) return worktree;
+  return input.directory;
+}
+
+/**
+ * Check if a file exists at the given path.
+ */
+async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await access(filePath, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Read a bundled agent template from the plugin package.
+ */
+async function readBundledTemplate(templateFileName: string): Promise<string> {
+  const here = path.dirname(fileURLToPath(import.meta.url));
+  const templatePath = path.resolve(here, '..', 'assets', 'agents', templateFileName);
+  return await readFile(templatePath, 'utf8');
+}
+
+/**
+ * Ensure all FF agent templates are installed in the project's .opencode/agent/ directory.
+ *
+ * Behavior:
+ * - Creates .opencode/agent/ if it doesn't exist
+ * - For each agent template: if the destination file exists, skip (never overwrite)
+ * - If the destination file doesn't exist, write the template
+ */
+async function ensureAgentsInstalled(
+  rootDir: string
+): Promise<{ installed: string[]; skipped: string[] }> {
+  const agentDir = path.join(rootDir, '.opencode', 'agent');
+
+  // Create directories if they don't exist
+  await mkdir(agentDir, { recursive: true });
+
+  const installed: string[] = [];
+  const skipped: string[] = [];
+
+  for (const templateFileName of AGENT_TEMPLATES) {
+    const destPath = path.join(agentDir, templateFileName);
+
+    // Create-once semantics: if it exists, never overwrite
+    if (await fileExists(destPath)) {
+      skipped.push(templateFileName);
+      continue;
+    }
+
+    // Read template and write to destination
+    const template = await readBundledTemplate(templateFileName);
+    await writeFile(destPath, template, { encoding: 'utf8' });
+    installed.push(templateFileName);
+  }
+
+  return { installed, skipped };
+}
+
+/**
+ * Feature Factory OpenCode Plugin
+ *
+ * This plugin automatically syncs Feature Factory agent templates to projects.
+ *
+ * Agents installed:
+ * - ff-plan (primary): Creates detailed implementation plans
+ * - ff-build (primary): Implements features based on plans
+ * - ff-mini-plan (subagent): Quick 2-5 step plans
+ * - ff-review (subagent): Code review for quality/correctness
+ * - ff-security (subagent): Security audits
+ * - ff-unit-test (subagent): Unit test generation
+ * - ff-e2e-test (subagent): E2E test generation
+ * - ff-acceptance (subagent): Acceptance criteria validation
+ * - ff-well-architected (subagent): AWS Well-Architected review
+ *
+ * Behavior:
+ * - On plugin init (every OpenCode startup), syncs agents to .opencode/agent/
+ * - Only creates new files; never overwrites existing files (respects user edits)
+ * - Also syncs on installation.updated event
+ */
+export const FeatureFactoryPlugin: Plugin = async ({ worktree, directory }) => {
+  const rootDir = resolveRootDir({ worktree, directory });
+
+  // Run initial sync on plugin load (silent - errors are swallowed)
+  try {
+    await ensureAgentsInstalled(rootDir);
+  } catch {
+    // Silent autosync shouldn't crash OpenCode startup
+  }
+
+  return {
+    // Also sync on installation updates (plugin updates)
+    event: async ({ event }) => {
+      if (event.type === 'installation.updated') {
+        try {
+          await ensureAgentsInstalled(rootDir);
+        } catch {
+          // Silent failure
+        }
+      }
+    },
+  };
+};
+
+// Default export for OpenCode plugin discovery
+export default FeatureFactoryPlugin;