akili-specs 2.1.0

package/docs/skills/ui-ux-pro-max.md

@@ -0,0 +1,25 @@
+# `ui-ux-pro-max`
+
+## Purpose
+
+Provides broad UI/UX design intelligence, including styles, palettes, font pairings, accessibility, animation, layout, typography, dashboards, landing pages, charts, and stack-specific guidance.
+
+## Use When
+
+- Designing or reviewing UI/UX work.
+- Creating a product experience baseline.
+- Choosing visual direction, palettes, typography, layout, or responsive behavior.
+- Auditing accessibility and interaction quality.
+- Implementing dashboards, admin panels, SaaS pages, portfolios, e-commerce, mobile apps, or charts.
+
+## Best Paired Commands
+
+- `/akili-constitution` for the UX/UI design baseline.
+- `/akili-specify` for UI requirements and design.
+- `/akili-execute` for implementation guidance.
+- `/akili-test` for UX checks.
+- `/akili-validate` for UI conformance.
+
+## Source
+
+- `../../.claude/skills/ui-ux-pro-max/SKILL.md`

package/docs/skills/vercel-react-best-practices.md

@@ -0,0 +1,22 @@
+# `vercel-react-best-practices`
+
+## Purpose
+
+Guides React and Next.js performance, rendering, bundle, async, server/client, and architecture best practices based on Vercel engineering guidance.
+
+## Use When
+
+- Writing, reviewing, or refactoring React or Next.js code.
+- Planning data fetching, server/client boundaries, Suspense, transitions, or bundle optimization.
+- Diagnosing rerenders, hydration issues, performance regressions, or async patterns.
+
+## Best Paired Commands
+
+- `/akili-specify` for React/Next.js design decisions.
+- `/akili-execute` for implementation.
+- `/akili-test` for performance-sensitive verification.
+- `/akili-validate` for conformance review.
+
+## Source
+
+- `../../.claude/skills/vercel-react-best-practices/SKILL.md`

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "akili-specs",
+  "version": "2.1.0",
+  "description": "Portable AKILI-SPECS methodology commands and skills for AI-assisted development.",
+  "homepage": "https://github.com/JuankCadavid/akili-specs#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JuankCadavid/akili-specs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/JuankCadavid/akili-specs/issues"
+  },
+  "bin": {
+    "akili": "bin/akili.js"
+  },
+  "files": [
+    ".claude/commands",
+    ".claude/skills",
+    ".claude/templates",
+    ".mcp.json.example",
+    "assets",
+    "bin",
+    "CHANGELOG.md",
+    "docs",
+    "LICENSE",
+    "README.md",
+    "scripts/gsc_verify.py",
+    "scripts/parse_tests.js"
+  ],
+  "scripts": {
+    "pack:dry-run": "npm pack --dry-run",
+    "release:major": "node scripts/release.js major",
+    "release:minor": "node scripts/release.js minor",
+    "release:patch": "node scripts/release.js patch",
+    "release:status": "node scripts/release-status.js",
+    "verify:cli": "node bin/akili.js list"
+  },
+  "keywords": [
+    "sdd",
+    "spec-driven-development",
+    "claude",
+    "opencode",
+    "ai-coding",
+    "methodology"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}

package/scripts/gsc_verify.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+"""
+Verify a Google service account as an owner on Google Search Console
+Domain properties via DNS TXT records.
+
+The `gsc` MCP (@mikusnuz/gsc-mcp) does NOT expose Site Verification
+endpoints — only Search Console. This helper covers the verification
+half: token generation + verify call.
+
+After verification succeeds, use the `gsc` MCP `sites_add` tool to add
+the property to Search Console for the service account.
+
+Setup:
+  pip install google-auth google-api-python-client
+
+Usage:
+  GSC_KEY_PATH=/abs/path/to/service-account.json \
+    python3 gsc_verify.py get <domain> [<domain> ...]
+
+  GSC_KEY_PATH=/abs/path/to/service-account.json \
+    python3 gsc_verify.py verify <domain> [<domain> ...]
+
+Or pass the key path explicitly:
+  python3 gsc_verify.py --key /abs/path/to/key.json get example.com
+
+Workflow:
+  1. Run with `get` to obtain a DNS TXT verification token per domain.
+  2. Add the TXT record to each domain's DNS (host: @, value: the token).
+  3. Wait for DNS propagation (a few minutes to an hour).
+  4. Run with `verify` to trigger the verification on Google's side.
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+try:
+    from google.oauth2 import service_account
+    from googleapiclient.discovery import build
+    from googleapiclient.errors import HttpError
+except ImportError:
+    print("ERROR: missing dependencies. Install with:", file=sys.stderr)
+    print("  pip install google-auth google-api-python-client", file=sys.stderr)
+    sys.exit(1)
+
+
+SCOPES = ["https://www.googleapis.com/auth/siteverification"]
+
+
+def make_client(key_path: str):
+    if not Path(key_path).exists():
+        print(f"ERROR: key file not found at: {key_path}", file=sys.stderr)
+        sys.exit(1)
+    creds = service_account.Credentials.from_service_account_file(
+        key_path, scopes=SCOPES
+    )
+    return build("siteVerification", "v1", credentials=creds, cache_discovery=False)
+
+
+def get_token(sv, domain: str) -> str:
+    body = {
+        "site": {"type": "INET_DOMAIN", "identifier": domain},
+        "verificationMethod": "DNS_TXT",
+    }
+    return sv.webResource().getToken(body=body).execute()["token"]
+
+
+def check_dns(domain: str, token: str):
+    """Best-effort check that the TXT record is visible via dig."""
+    try:
+        out = subprocess.check_output(
+            ["dig", "+short", "TXT", domain], stderr=subprocess.DEVNULL, text=True
+        )
+        return token in out
+    except Exception:
+        return None
+
+
+def verify_domain(sv, domain: str):
+    body = {"site": {"type": "INET_DOMAIN", "identifier": domain}}
+    return sv.webResource().insert(verificationMethod="DNS_TXT", body=body).execute()
+
+
+def cmd_get(sv, domains):
+    print("\n=== DNS TXT records to add ===\n")
+    print("For each domain, log into your DNS provider and add a TXT record")
+    print("at the root (host = '@' or blank) with the value shown.\n")
+    for d in domains:
+        try:
+            token = get_token(sv, d)
+            print(f"--- {d} ---")
+            print(f"  Type:  TXT")
+            print(f"  Host:  @  (root of {d})")
+            print(f"  Value: {token}\n")
+        except HttpError as e:
+            print(f"--- {d} ---")
+            print(f"  ERROR getting token: {e}\n")
+
+
+def cmd_verify(sv, domains):
+    print("\n=== Verifying domains ===\n")
+    successes, failures = [], []
+    for d in domains:
+        try:
+            token = get_token(sv, d)
+        except HttpError as e:
+            print(f"[{d}] ERROR fetching token: {e}")
+            failures.append(d)
+            continue
+
+        dns_ok = check_dns(d, token)
+        if dns_ok is False:
+            print(f"[{d}] WARNING: TXT record not visible yet via dig. Trying anyway...")
+        elif dns_ok is True:
+            print(f"[{d}] TXT record visible in DNS")
+
+        try:
+            verify_domain(sv, d)
+            print(f"[{d}] VERIFIED — service account is now an owner.")
+            successes.append(d)
+        except HttpError as e:
+            print(f"[{d}] FAILED to verify: {e}")
+            failures.append(d)
+        print()
+
+    print(f"\nDone. Success: {len(successes)} | Failed: {len(failures)}")
+    if failures:
+        print("Failed domains:", ", ".join(failures))
+        print("Tip: DNS can take a few minutes to propagate. Try again later.")
+    return 0 if not failures else 1
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Verify a service account as owner on GSC domain properties."
+    )
+    parser.add_argument(
+        "--key",
+        default=os.environ.get("GSC_KEY_PATH"),
+        help="Path to the Google service account JSON key. "
+        "Defaults to $GSC_KEY_PATH.",
+    )
+    parser.add_argument("action", choices=["get", "verify"])
+    parser.add_argument("domains", nargs="+", help="One or more apex domains.")
+    args = parser.parse_args()
+
+    if not args.key:
+        parser.error(
+            "missing service account key: pass --key /abs/path.json or set $GSC_KEY_PATH"
+        )
+
+    sv = make_client(args.key)
+    if args.action == "get":
+        cmd_get(sv, args.domains)
+        return 0
+    return cmd_verify(sv, args.domains)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/scripts/parse_tests.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const path = require("path");
+
+function printHelp() {
+  console.log(`AKILI Test Report Parser
+
+Usage:
+  node parse_tests.js <input-results.json> [output-report.md]
+
+Arguments:
+  input-results.json  JSON output file generated by Jest/Vitest (using --json option)
+  output-report.md    Optional path to write/append the markdown report (defaults to stdout)
+`);
+}
+
+function parseTestJson(inputPath) {
+  if (!fs.existsSync(inputPath)) {
+    console.error(`ERROR: Input file not found: ${inputPath}`);
+    process.exit(1);
+  }
+
+  let data;
+  try {
+    const raw = fs.readFileSync(inputPath, "utf8");
+    data = JSON.parse(raw);
+  } catch (e) {
+    console.error(`ERROR: Failed to parse JSON: ${e.message}`);
+    process.exit(1);
+  }
+
+  // extract overall metrics
+  const total = data.numTotalTests || 0;
+  const passed = data.numPassedTests || 0;
+  const failed = data.numFailedTests || 0;
+  const pending = data.numPendingTests || 0;
+  const suites = data.numTotalTestSuites || 0;
+
+  let markdown = `## Test Summary
+
+- **Total Test Suites:** ${suites}
+- **Total Test Cases:** ${total}
+- **Passed:** ${passed}
+- **Failed:** ${failed}
+- **Skipped/Pending:** ${pending}
+
+### Detailed Traceability Matrix
+
+| Test Suite / File | Test Case | Status | Duration | Notes / Failure Messages |
+| :--- | :--- | :--- | :--- | :--- |
+`;
+
+  const results = data.testResults || [];
+  for (const suite of results) {
+    const relativeSuitePath = path.relative(process.cwd(), suite.name || "unknown");
+    const assertions = suite.assertionResults || [];
+
+    if (assertions.length === 0 && suite.message) {
+      // Suite-level failure or initialization failure
+      markdown += `| \`${relativeSuitePath}\` | *Suite Failure* | 🔴 **FAILED** | - | \`${suite.message.replace(/\r?\n/g, " ").substring(0, 100)}...\` |\n`;
+      continue;
+    }
+
+    for (const test of assertions) {
+      const fullTitle = [...(test.ancestorTitles || []), test.title].join(" > ");
+      let statusIndicator = "⚪ **PENDING**";
+      if (test.status === "passed") {
+        statusIndicator = "🟢 **PASSED**";
+      } else if (test.status === "failed") {
+        statusIndicator = "🔴 **FAILED**";
+      }
+
+      const duration = test.duration ? `${test.duration}ms` : "-";
+      let failureNotes = "-";
+      if (test.failureMessages && test.failureMessages.length > 0) {
+        // Strip ANSI escape codes and clean up message
+        failureNotes = test.failureMessages[0]
+          .replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, "")
+          .replace(/\r?\n/g, " ")
+          .substring(0, 120);
+        failureNotes = `\`${failureNotes}...\``;
+      }
+
+      markdown += `| \`${relativeSuitePath}\` | ${fullTitle} | ${statusIndicator} | ${duration} | ${failureNotes} |\n`;
+    }
+  }
+
+  return markdown;
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+    printHelp();
+    process.exit(0);
+  }
+
+  const inputPath = args[0];
+  const outputPath = args[1];
+
+  const parsedMarkdown = parseTestJson(inputPath);
+
+  if (outputPath) {
+    fs.writeFileSync(outputPath, parsedMarkdown, "utf8");
+    console.log(`Successfully generated markdown report at: ${outputPath}`);
+  } else {
+    console.log(parsedMarkdown);
+  }
+}
+
+main();