cfsa-antigravity 1.0.0

package/bin/cli.mjs

@@ -0,0 +1,324 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, cpSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { resolve, join, relative, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { argv, exit, cwd } from "node:process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TEMPLATE_DIR = resolve(__dirname, "..", "template");
+const PKG = JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf-8"));
+
+// --- Colors (when TTY) ---
+const isTTY = process.stdout.isTTY;
+const c = {
+    reset: isTTY ? "\x1b[0m" : "",
+    bold: isTTY ? "\x1b[1m" : "",
+    dim: isTTY ? "\x1b[2m" : "",
+    green: isTTY ? "\x1b[32m" : "",
+    yellow: isTTY ? "\x1b[33m" : "",
+    red: isTTY ? "\x1b[31m" : "",
+    cyan: isTTY ? "\x1b[36m" : "",
+    magenta: isTTY ? "\x1b[35m" : "",
+};
+
+// --- Logging ---
+let QUIET = false;
+const log = (msg) => { if (!QUIET) console.log(msg); };
+const info = (msg) => log(`${c.green}✓${c.reset} ${msg}`);
+const warn = (msg) => log(`${c.yellow}⚠${c.reset} ${msg}`);
+const error = (msg) => { console.error(`${c.red}✗${c.reset} ${msg}`); };
+
+// --- Usage ---
+function usage() {
+    log(`
+${c.bold}${c.magenta}CFSA Antigravity${c.reset} ${c.dim}v${PKG.version}${c.reset}
+${c.dim}Constraint-First Specification Architecture for AI agents${c.reset}
+
+${c.bold}Usage:${c.reset}
+  cfsa-antigravity ${c.cyan}<command>${c.reset} [options]
+
+${c.bold}Commands:${c.reset}
+  ${c.cyan}init${c.reset}      Install the CFSA pipeline into your project
+  ${c.cyan}status${c.reset}    Check installation status
+  ${c.cyan}version${c.reset}   Show version
+
+${c.bold}Init Options:${c.reset}
+  --force       Overwrite existing .agent/ folder
+  --path <dir>  Install into specific directory (default: current directory)
+  --dry-run     Preview what would be copied without making changes
+  --quiet       Suppress output (for CI/CD)
+
+${c.bold}Examples:${c.reset}
+  ${c.dim}# Install into current project${c.reset}
+  npx cfsa-antigravity init
+
+  ${c.dim}# Install into a specific directory${c.reset}
+  npx cfsa-antigravity init --path ./my-project
+
+  ${c.dim}# Preview what will be installed${c.reset}
+  npx cfsa-antigravity init --dry-run
+
+  ${c.dim}# Overwrite existing installation${c.reset}
+  npx cfsa-antigravity init --force
+`);
+}
+
+// --- Parse Arguments ---
+function parseArgs(args) {
+    const parsed = { command: null, force: false, dryRun: false, path: null, quiet: false };
+
+    let i = 0;
+    while (i < args.length) {
+        const arg = args[i];
+        switch (arg) {
+            case "init":
+            case "status":
+            case "version":
+            case "help":
+            case "--help":
+            case "-h":
+                parsed.command = arg === "--help" || arg === "-h" || arg === "help" ? "help" : arg;
+                break;
+            case "--force":
+            case "-f":
+                parsed.force = true;
+                break;
+            case "--dry-run":
+            case "-n":
+                parsed.dryRun = true;
+                break;
+            case "--quiet":
+            case "-q":
+                parsed.quiet = true;
+                break;
+            case "--path":
+            case "-p":
+                i++;
+                parsed.path = args[i];
+                if (!parsed.path) {
+                    error("--path requires a directory argument");
+                    exit(1);
+                }
+                break;
+            case "--version":
+            case "-v":
+                parsed.command = "version";
+                break;
+            default:
+                if (arg.startsWith("-")) {
+                    error(`Unknown option: ${arg}`);
+                    usage();
+                    exit(1);
+                }
+                // Treat first positional as command if not set
+                if (!parsed.command) {
+                    parsed.command = arg;
+                }
+                break;
+        }
+        i++;
+    }
+
+    return parsed;
+}
+
+// --- Count files recursively ---
+function countFiles(dir) {
+    let count = 0;
+    if (!existsSync(dir)) return 0;
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (entry.isDirectory()) {
+            count += countFiles(join(dir, entry.name));
+        } else {
+            count++;
+        }
+    }
+    return count;
+}
+
+// --- List top-level items to copy ---
+function getTemplateItems() {
+    if (!existsSync(TEMPLATE_DIR)) {
+        error("Template directory not found. Package may be corrupted.");
+        error(`Expected: ${TEMPLATE_DIR}`);
+        exit(1);
+    }
+    return readdirSync(TEMPLATE_DIR, { withFileTypes: true });
+}
+
+// --- Init Command ---
+function cmdInit(opts) {
+    const targetDir = resolve(opts.path || cwd());
+
+    log("");
+    log(`${c.bold}${c.magenta}CFSA Antigravity${c.reset} ${c.dim}v${PKG.version}${c.reset}`);
+    log(`${c.dim}Installing into: ${targetDir}${c.reset}`);
+    log("");
+
+    // Check if target directory exists
+    if (!existsSync(targetDir)) {
+        if (opts.dryRun) {
+            warn(`Directory does not exist: ${targetDir} (would create)`);
+        } else {
+            mkdirSync(targetDir, { recursive: true });
+            info(`Created directory: ${targetDir}`);
+        }
+    }
+
+    const items = getTemplateItems();
+    let copied = 0;
+    let skipped = 0;
+    const copiedPaths = [];
+    const skippedPaths = [];
+
+    for (const item of items) {
+        const src = join(TEMPLATE_DIR, item.name);
+        const dest = join(targetDir, item.name);
+
+        if (existsSync(dest) && !opts.force) {
+            const fileCount = item.isDirectory() ? countFiles(src) : 1;
+            skipped += fileCount;
+            skippedPaths.push(item.name);
+            warn(`Skipped ${c.bold}${item.name}${c.reset} (already exists — use --force to overwrite)`);
+            continue;
+        }
+
+        if (opts.dryRun) {
+            const fileCount = item.isDirectory() ? countFiles(src) : 1;
+            copied += fileCount;
+            copiedPaths.push(item.name);
+            info(`Would copy ${c.bold}${item.name}${c.reset} (${fileCount} files)`);
+            continue;
+        }
+
+        // Copy
+        if (item.isDirectory()) {
+            cpSync(src, dest, { recursive: true, force: opts.force });
+        } else {
+            const destDir = dirname(dest);
+            if (!existsSync(destDir)) mkdirSync(destDir, { recursive: true });
+            cpSync(src, dest, { force: opts.force });
+        }
+
+        const fileCount = item.isDirectory() ? countFiles(dest) : 1;
+        copied += fileCount;
+        copiedPaths.push(item.name);
+        info(`Copied ${c.bold}${item.name}${c.reset} (${fileCount} files)`);
+    }
+
+    // Summary
+    log("");
+    if (opts.dryRun) {
+        log(`${c.bold}Dry run complete:${c.reset} ${copied} files would be copied, ${skipped} skipped`);
+    } else if (copied > 0) {
+        log(`${c.bold}${c.green}Installation complete!${c.reset} ${copied} files copied, ${skipped} skipped`);
+        log("");
+        log(`${c.bold}Next steps:${c.reset}`);
+        log(`  1. Open your project in an AI editor (Antigravity, Cursor, etc.)`);
+        log(`  2. Run ${c.cyan}/ideate${c.reset} to start the pipeline`);
+        log("");
+        log(`${c.dim}Documentation: https://github.com/RepairYourTech/cfsa-antigravity${c.reset}`);
+    } else {
+        warn("Nothing was copied. All files already exist.");
+        log(`  Use ${c.cyan}--force${c.reset} to overwrite existing files.`);
+    }
+    log("");
+}
+
+// --- Status Command ---
+function cmdStatus() {
+    const targetDir = cwd();
+    const agentDir = join(targetDir, ".agent");
+
+    log("");
+    log(`${c.bold}${c.magenta}CFSA Antigravity${c.reset} ${c.dim}v${PKG.version}${c.reset}`);
+    log(`${c.dim}Checking: ${targetDir}${c.reset}`);
+    log("");
+
+    if (!existsSync(agentDir)) {
+        warn("Not installed — .agent/ directory not found");
+        log(`  Run ${c.cyan}cfsa-antigravity init${c.reset} to install`);
+        log("");
+        exit(1);
+    }
+
+    info(".agent/ directory found");
+
+    const checks = [
+        { path: ".agent/workflows", label: "Workflows" },
+        { path: ".agent/skills", label: "Skills" },
+        { path: ".agent/skill-library", label: "Skill Library" },
+        { path: ".agent/instructions", label: "Instructions" },
+        { path: ".agent/rules", label: "Rules" },
+        { path: "docs/plans", label: "Plans directory" },
+        { path: "GEMINI.md", label: "GEMINI.md" },
+        { path: "AGENTS.md", label: "AGENTS.md" },
+    ];
+
+    let installed = 0;
+    let missing = 0;
+
+    for (const check of checks) {
+        const fullPath = join(targetDir, check.path);
+        if (existsSync(fullPath)) {
+            const isDir = statSync(fullPath).isDirectory();
+            const detail = isDir ? `${countFiles(fullPath)} files` : "present";
+            info(`${check.label} ${c.dim}(${detail})${c.reset}`);
+            installed++;
+        } else {
+            warn(`${check.label} — missing`);
+            missing++;
+        }
+    }
+
+    log("");
+    log(`${c.bold}Status:${c.reset} ${installed} components found, ${missing} missing`);
+
+    // Check for unfilled placeholders in GEMINI.md
+    const geminiPath = join(targetDir, "GEMINI.md");
+    if (existsSync(geminiPath)) {
+        const content = readFileSync(geminiPath, "utf-8");
+        const placeholders = content.match(/\{\{[A-Z_]+\}\}/g);
+        if (placeholders) {
+            const unique = [...new Set(placeholders)];
+            log("");
+            warn(`${unique.length} unfilled placeholder(s) in GEMINI.md — run /create-prd to fill them`);
+            for (const p of unique.slice(0, 5)) {
+                log(`  ${c.dim}${p}${c.reset}`);
+            }
+            if (unique.length > 5) {
+                log(`  ${c.dim}... and ${unique.length - 5} more${c.reset}`);
+            }
+        } else {
+            info("GEMINI.md — all placeholders filled");
+        }
+    }
+
+    log("");
+}
+
+// --- Main ---
+const args = parseArgs(argv.slice(2));
+QUIET = args.quiet;
+
+switch (args.command) {
+    case "init":
+        cmdInit(args);
+        break;
+    case "status":
+        cmdStatus();
+        break;
+    case "version":
+        log(PKG.version);
+        break;
+    case "help":
+    case null:
+        usage();
+        break;
+    default:
+        error(`Unknown command: ${args.command}`);
+        usage();
+        exit(1);
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+    "name": "cfsa-antigravity",
+    "version": "1.0.0",
+    "description": "CFSA Pipeline — Constraint-First Specification Architecture for AI agents. Production-grade from line one.",
+    "bin": {
+        "cfsa-antigravity": "./bin/cli.mjs"
+    },
+    "files": [
+        "bin/",
+        "template/"
+    ],
+    "keywords": [
+        "ai",
+        "agent",
+        "cfsa",
+        "specification",
+        "pipeline",
+        "tdd",
+        "antigravity",
+        "production",
+        "workflows",
+        "skills"
+    ],
+    "author": "RepairYourTech",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/RepairYourTech/cfsa-antigravity"
+    },
+    "homepage": "https://github.com/RepairYourTech/cfsa-antigravity#readme",
+    "engines": {
+        "node": ">=18.0.0"
+    }
+}

package/template/.agent/instructions/commands.md

@@ -0,0 +1,48 @@
+# Development Commands
+
+<!-- 
+  THIS FILE IS A TEMPLATE.
+  The /bootstrap-agents workflow will fill in your project-specific commands.
+  Replace {{PLACEHOLDERS}} with your actual commands.
+-->
+
+## Package Manager: {{PACKAGE_MANAGER}}
+
+## Development
+
+```bash
+{{DEV_COMMAND}}                    # Start dev server
+```
+
+## Testing
+
+```bash
+{{TEST_COMMAND}}                   # Run all tests
+{{TEST_WATCH_COMMAND}}             # Watch mode
+{{TEST_COVERAGE_COMMAND}}          # With coverage report
+```
+
+## Linting & Formatting
+
+```bash
+{{LINT_COMMAND}}                   # Lint check
+{{LINT_FIX_COMMAND}}               # Lint with auto-fix
+{{FORMAT_COMMAND}}                 # Format check
+{{TYPE_CHECK_COMMAND}}             # TypeScript type validation
+```
+
+## Build & Preview
+
+```bash
+{{BUILD_COMMAND}}                  # Production build
+{{PREVIEW_COMMAND}}                # Preview production build locally
+```
+
+## Validation (run after every code change)
+
+// turbo
+```bash
+{{VALIDATION_COMMAND}}
+```
+
+All checks must pass before marking any task complete.

package/template/.agent/instructions/patterns.md

@@ -0,0 +1,61 @@
+# Code Patterns & Conventions
+
+<!-- 
+  THIS FILE IS A TEMPLATE. 
+  The /bootstrap-agents workflow will fill in your project-specific patterns.
+  Sections marked with {{PLACEHOLDER}} will be replaced.
+-->
+
+## TypeScript → skills: `clean-code`, `typescript-advanced-patterns`
+- **Strict mode** everywhere — `strict: true` in tsconfig
+- **Explicit types** — No `any`, no implicit returns
+- **Zod validation** — All API inputs validated with Zod schemas
+- **Self-documenting** — Clear naming over comments
+- **Zod inference** — Derive TypeScript types from Zod schemas with `z.infer<typeof schema>`
+
+## File Organization → skill: `clean-code`
+- **File size limits** — Per-type limits (enforced by extensibility rule): 200 lines for components (.tsx), 300 for utilities (.ts), 150 for schemas (.schema.ts), 400 for tests (.test.ts), 100 for config files
+- **Single responsibility** — One component/module per file
+- **Named exports** — No default exports for utilities
+- **Direct imports** — Import from specific files, avoid barrel files
+
+## Components
+<!-- {{FRAMEWORK_PATTERNS}} — Filled by /bootstrap-agents based on chosen frontend framework -->
+> ⚠️ **Framework component patterns not yet configured.** Run /bootstrap-agents with FRAMEWORK_PATTERNS to fill this section. Until then, follow the framework's official documentation for component conventions and apply the naming and file organisation rules above.
+
+## API & Data → skill: `rest-api-design`
+- **Input validation** — Zod schemas on every endpoint
+- **Error format** — Consistent: `{ success: boolean, data?: T, error?: { code, message } }`
+- **No magic strings** — Constants and enums for repeated values
+- **Rate limiting** — On all public-facing endpoints
+
+## Security → skill: `security-scanning-security-hardening`
+- **No secrets in client code** — Server-side only, environment variables
+- **CSP headers** — Content Security Policy on all responses
+- **Input sanitization** — Prevent XSS, injection attacks
+- **CORS configured** — Explicit allowed origins, no wildcards in production
+
+## Naming
+- **Files:** kebab-case (`user-profile.tsx`)
+- **Components:** PascalCase (`UserProfile`)
+- **Functions:** camelCase (`getUserById`)
+- **Constants:** SCREAMING_SNAKE (`MAX_RETRY_COUNT`)
+- **Types/Interfaces:** PascalCase (`UserSession`)
+
+## What NOT to Do
+- No `console.log` in committed code — Use a structured logging utility
+- No `// TODO` — Lazy placeholders are banned. If the information you need genuinely doesn't exist yet, use a `// BOUNDARY:` stub (see rule: `boundary-not-placeholder`)
+- No `any` type — Ever
+- No inline styles — Use CSS classes or scoped styles
+- No hardcoded URLs — Use environment config
+- No barrel files (`index.ts`) — Import directly from source files
+
+<!-- 
+  Add project-specific sections below as your stack evolves:
+  ## State & Data
+  ## Caching
+  ## Observability
+  ## Payments
+  ## Email
+  ## Images
+-->

package/template/.agent/instructions/structure.md

@@ -0,0 +1,29 @@
+# Project Structure
+
+<!-- 
+  THIS FILE IS A TEMPLATE.
+  The /bootstrap-agents workflow will fill in your project-specific structure.
+-->
+
+## Current Layout
+
+```
+{{PROJECT_STRUCTURE}}
+```
+
+## Architecture Separation
+
+| Concern | Location | Runtime |
+|---------|----------|---------|
+| {{ARCHITECTURE_TABLE}} |
+
+## Protected Files (Do Not Modify Without Approval)
+- `AGENTS.md` — Project agent config
+- `docs/plans/ENGINEERING-STANDARDS.md` — Quality bar
+- `.agent/instructions/*` — Agent rules
+- `package.json` — Dependencies (add carefully)
+- `tsconfig.json` — TypeScript config
+
+## Notes
+- All agent config lives in `.agent/` (canonical for all agents)
+- Frontend and API may be separately deployed depending on architecture

package/template/.agent/instructions/tech-stack.md

@@ -0,0 +1,43 @@
+# Tech Stack
+
+<!-- 
+  THIS FILE IS A TEMPLATE.
+  The /bootstrap-agents workflow will fill in your project-specific stack.
+  Sections marked with {{PLACEHOLDER}} will be replaced.
+-->
+
+## Stack Summary
+
+**{{TECH_STACK_SUMMARY}}**
+
+## Core Decisions
+
+| Axis | Decision |
+|------|----------|
+| **Frontend framework** | {{FRONTEND_FRAMEWORK}} |
+| **Backend runtime** | {{BACKEND_RUNTIME}} |
+| **Database** | {{DATABASE}} |
+| **Auth provider** | {{AUTH_PROVIDER}} |
+| **Hosting** | {{HOSTING}} |
+| **CDN / Assets** | {{CDN_ASSETS}} |
+| **CI/CD** | {{CICD}} |
+| **Monitoring** | {{MONITORING}} |
+
+## Development Tooling
+
+| Tool | Value |
+|------|-------|
+| Package manager | {{PACKAGE_MANAGER}} |
+| Test runner | {{TEST_RUNNER}} |
+| Linter | {{LINTER}} |
+| Type checker | {{TYPE_CHECKER}} |
+
+## Installed Skills
+
+<!-- Updated by /create-prd after skill discovery -->
+{{INSTALLED_SKILLS}}
+
+## Reference
+
+- [Architecture Design](../../{{ARCHITECTURE_DOC}}) — full system design with rationale
+- [Engineering Standards](../../docs/plans/ENGINEERING-STANDARDS.md) — Quality thresholds

package/template/.agent/instructions/workflow.md

@@ -0,0 +1,41 @@
+# Mandatory Execution Sequence
+
+Before taking any action on a task:
+
+## 1. Understand Context
+- Read the agent config file at project root (`AGENTS.md` for Antigravity, `GEMINI.md` for Gemini CLI, or equivalent for your agent)
+- Read relevant `.agent/instructions/` files for the task type
+- Check [Engineering Standards](../../docs/plans/ENGINEERING-STANDARDS.md) for quality bar — if this file doesn't exist yet, the pipeline hasn't reached /create-prd; run /ideate then /create-prd first
+
+## 2. Check Skills
+- Scan `.agent/skills/` for applicable skills
+- Load relevant skill SKILL.md before proceeding
+- Key skills: `brainstorming` (before creative work), `tdd-workflow` (before features), `clean-code` (during review)
+
+## 3. Execute
+
+> **Non-negotiable:** This project does not ship MVPs. Every line you write is
+> production code. There is no "rough draft" phase.
+
+- Follow the task requirements
+- Write production-grade code from the start — no exceptions, no "clean up later"
+- No placeholder implementations or `// TODO` comments — if the information you need genuinely doesn't exist yet, use a `// BOUNDARY:` stub with typed interface, tracking issue, and sentinel test (see rule: `boundary-not-placeholder`)
+- No deferred quality — if it's not ready for production, it's not ready to commit
+- **Cost-blind execution** — The cost of API calls, tokens, or compute to complete your work is NEVER your concern. Do not estimate, report, or factor operational AI costs into any decision. The only cost constraints that matter are user-defined project constraints (e.g., "keep hosting costs low," "prefer client-side compute"). If the user hasn't defined a cost constraint, cost is not a factor.
+- **Proactive effort mindset** — When you estimate a task will take significant effort, that is a signal to commit harder, not to defer. Small task? Get it done immediately. Large task? Buckle in, communicate progress, and work through it systematically. Time estimates drive commitment, never avoidance.
+
+## 4. Validate (MANDATORY)
+After **every** code change, run:
+```bash
+{{VALIDATION_COMMAND}}
+```
+
+Do NOT mark a task complete until all validations pass.
+
+## Principles
+
+- **Ask before assuming** — Clarify ambiguous requirements
+- **Small changes** — Commit frequently, keep diffs reviewable
+- **Test first** — Write failing tests before implementation — no exceptions
+- **Security always** — Validate inputs, sanitize outputs, never expose secrets
+- **Work is the job** — Never use the size, complexity, or duration of a task as a reason to reduce quality or scope. Large tasks get more effort, not less quality.

package/template/.agent/kit-sync.md

@@ -0,0 +1,15 @@
+<!-- This file is created and updated automatically by /sync-kit.
+     Commit it to your project repo — it records which kit version
+     the project is on and serves as the baseline for the next sync. -->
+
+> [!NOTE]
+> **`FIRST_SYNC_PENDING` values are placeholders.** They are populated automatically
+> when you run `/sync-kit` for the first time. Do not manually edit them — let the
+> sync command fill them in.
+
+# Kit Sync State
+
+upstream: https://github.com/RepairYourTech/Anti-MVP-Vibe-Pipeline
+last_synced_commit: FIRST_SYNC_PENDING
+last_synced_at: FIRST_SYNC_PENDING
+kit_version: main