agent-method 1.5.12

package/lib/registry.js

@@ -0,0 +1,132 @@
+/**
+ * Registry loader and structured query interface.
+ *
+ * Loads feature-registry.yaml and provides typed access to features,
+ * workflows, patterns, activation maps, and protocol directives.
+ */
+
+import { readFileSync, statSync } from "node:fs";
+import { resolve, join, dirname } from "node:path";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import yaml from "js-yaml";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Locate feature-registry.yaml by walking upward from start.
+ *
+ * Search order:
+ *   1. docs/internal/feature-registry.yaml relative to package root
+ *   2. Walk parent directories looking for docs/internal/feature-registry.yaml
+ *   3. feature-registry.yaml in start or its parents
+ */
+export function findRegistry(start) {
+  if (!start) {
+    // Default: package root (one level up from lib/)
+    start = resolve(__dirname, "..");
+  }
+
+  // Direct relative paths from the start
+  const candidates = [
+    join(start, "registry", "feature-registry.yaml"),
+    join(start, "docs", "internal", "feature-registry.yaml"),
+    join(start, ".context", "feature-registry.yaml"),
+    join(start, "feature-registry.yaml"),
+  ];
+  for (const p of candidates) {
+    if (existsSync(p)) return p;
+  }
+
+  // Walk upward
+  let current = resolve(start);
+  for (let i = 0; i < 10; i++) {
+    const regCandidate = join(current, "registry", "feature-registry.yaml");
+    if (existsSync(regCandidate)) return regCandidate;
+    const candidate = join(current, "docs", "internal", "feature-registry.yaml");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(current);
+    if (parent === current) break;
+    current = parent;
+  }
+
+  throw new Error(
+    "Cannot find feature-registry.yaml. " +
+      "Provide --registry or run from the wwa repo."
+  );
+}
+
+/**
+ * Load and return the parsed registry.
+ * Handles {placeholder} patterns in YAML by quoting them before parsing.
+ */
+export function loadRegistry(path) {
+  if (!path) path = findRegistry();
+  // If path is a directory, find the registry file within it
+  if (existsSync(path) && statSync(path).isDirectory()) path = findRegistry(path);
+  let content = readFileSync(path, "utf-8");
+  // The registry uses {placeholder} in flow sequences — replace them.
+  content = content.replace(/\{([^}]+)\}/g, "_$1_");
+  const parsed = yaml.load(content);
+
+  // Split index: has 'layers' key but no 'features' — assemble from components
+  if (parsed?.layers && !parsed.features) {
+    const dir = dirname(path);
+    const assembled = { version: parsed.version };
+    for (const layer of parsed.layers) {
+      const componentPath = join(dir, layer.file);
+      if (existsSync(componentPath)) {
+        let cContent = readFileSync(componentPath, "utf-8");
+        cContent = cContent.replace(/\{([^}]+)\}/g, "_$1_");
+        const component = yaml.load(cContent);
+        if (component) Object.assign(assembled, component);
+      }
+    }
+    return assembled;
+  }
+
+  return parsed;
+}
+
+/** Return a map of feature ID to feature spec. */
+export function getFeatures(registry) {
+  const features = {};
+  for (const f of registry.features || []) {
+    features[f.id] = f;
+  }
+  return features;
+}
+
+/** Return the list of workflow specs. */
+export function getWorkflows(registry) {
+  return registry.workflows || [];
+}
+
+/** Return a single workflow by ID, or null. */
+export function getWorkflow(registry, workflowId) {
+  for (const wf of getWorkflows(registry)) {
+    if (wf.id === workflowId) return wf;
+  }
+  return null;
+}
+
+/** Return the list of query pattern specs. */
+export function getQueryPatterns(registry) {
+  return registry.query_patterns || [];
+}
+
+/** Return the activation map (stage -> feature list). */
+export function getActivation(registry) {
+  return registry.activation || {};
+}
+
+/** Return the list of protocol directives. */
+export function getDirectives(registry) {
+  return (registry.protocol || {}).core_directives || [];
+}
+
+/** Return the registry version string. */
+export function getVersion(registry) {
+  return String(registry.version || "unknown");
+}

package/lib/watcher.js

@@ -0,0 +1,165 @@
+/**
+ * Registry watcher — chokidar-based file monitoring with proactive validation.
+ *
+ * Watches:
+ *   - Entry points (CLAUDE.md, .cursorrules, AGENT.md)
+ *   - Feature registry (feature-registry.yaml)
+ *   - Markdown files for 300-line threshold violations
+ *
+ * On change: runs S7 validation and reports results.
+ */
+
+import { watch } from "chokidar";
+import { readFileSync, statSync } from "node:fs";
+import { resolve, basename, extname } from "node:path";
+
+import { loadRegistry } from "./registry.js";
+import { validateEntryPoint, detectProjectType } from "./pipeline.js";
+
+const SCALE_THRESHOLD = 300;
+
+const ENTRY_POINT_NAMES = new Set(["CLAUDE.md", ".cursorrules", "AGENT.md"]);
+const INTELLIGENCE_LAYER = new Set([
+  "STATE.md", "ROADMAP.md", "PLAN.md", "SUMMARY.md", "PROJECT.md",
+]);
+
+// ---------------------------------------------------------------------------
+// Validation handlers
+// ---------------------------------------------------------------------------
+
+function validateEntry(filePath, registryPath) {
+  const reg = loadRegistry(registryPath || undefined);
+  const dir = resolve(filePath, "..");
+  const detected = detectProjectType(dir);
+  const projectType = detected.project_type || "general";
+  const result = validateEntryPoint(filePath, projectType, reg);
+  return { type: "entry_point", file: filePath, projectType, result };
+}
+
+function checkScale(filePath) {
+  try {
+    const content = readFileSync(resolve(filePath), "utf-8");
+    const lineCount = content.split("\n").length;
+    const over = lineCount > SCALE_THRESHOLD;
+    return {
+      type: "scale_check",
+      file: filePath,
+      line_count: lineCount,
+      threshold: SCALE_THRESHOLD,
+      over_threshold: over,
+    };
+  } catch {
+    return { type: "scale_check", file: filePath, error: "Cannot read file" };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Watcher creation
+// ---------------------------------------------------------------------------
+
+export function createWatcher(directory, options = {}) {
+  const dir = resolve(directory);
+  const registryPath = options.registryPath || null;
+  const onResult = options.onResult || defaultReporter;
+
+  // Watch patterns: markdown files and yaml files
+  const patterns = [
+    `${dir}/**/*.md`,
+    `${dir}/**/feature-registry.yaml`,
+    `${dir}/.cursorrules`,
+  ];
+
+  const ignored = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/dist/**",
+    "**/build/**",
+  ];
+
+  const watcher = watch(patterns, {
+    ignored,
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      pollInterval: 100,
+    },
+  });
+
+  watcher.on("change", (filePath) => {
+    const name = basename(filePath);
+    const ext = extname(filePath);
+
+    // Entry point changed — run full validation
+    if (ENTRY_POINT_NAMES.has(name)) {
+      try {
+        const report = validateEntry(filePath, registryPath);
+        onResult(report);
+      } catch (err) {
+        onResult({ type: "error", file: filePath, message: err.message });
+      }
+      return;
+    }
+
+    // Registry changed — reload and validate all entry points
+    if (name === "feature-registry.yaml") {
+      onResult({ type: "registry_reload", file: filePath, message: "Registry changed — reload triggered" });
+      return;
+    }
+
+    // Markdown file changed — check scale threshold
+    if (ext === ".md") {
+      const report = checkScale(filePath);
+      // Only report if over threshold or if it's an intelligence layer file
+      if (report.over_threshold || INTELLIGENCE_LAYER.has(name)) {
+        onResult(report);
+      }
+    }
+  });
+
+  watcher.on("add", (filePath) => {
+    const name = basename(filePath);
+    if (ENTRY_POINT_NAMES.has(name)) {
+      onResult({ type: "entry_point_added", file: filePath, message: "New entry point detected" });
+    }
+  });
+
+  return watcher;
+}
+
+// ---------------------------------------------------------------------------
+// Default reporter — console output
+// ---------------------------------------------------------------------------
+
+function defaultReporter(report) {
+  const timestamp = new Date().toISOString().substring(11, 19);
+
+  switch (report.type) {
+    case "entry_point": {
+      const status = report.result.valid ? "PASS" : "FAIL";
+      console.log(`[${timestamp}] Entry point ${status}: ${report.file}`);
+      if (!report.result.valid && report.result.issues) {
+        for (const issue of report.result.issues) {
+          console.log(`  [${issue.severity}] ${issue.check}: ${issue.description}`);
+        }
+      }
+      break;
+    }
+    case "scale_check":
+      if (report.over_threshold) {
+        console.log(
+          `[${timestamp}] Scale warning: ${report.file} (${report.line_count} lines, threshold: ${report.threshold})`
+        );
+      }
+      break;
+    case "registry_reload":
+      console.log(`[${timestamp}] ${report.message}`);
+      break;
+    case "entry_point_added":
+      console.log(`[${timestamp}] ${report.message}: ${report.file}`);
+      break;
+    case "error":
+      console.error(`[${timestamp}] Error: ${report.file} — ${report.message}`);
+      break;
+  }
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "agent-method",
+  "version": "1.5.12",
+  "description": "CLI tools for the wwa methodology — registry-driven routing, validation, and project setup for AI-agent-assisted development",
+  "keywords": [
+    "ai-agents",
+    "prompt-engineering",
+    "context-engineering",
+    "methodology",
+    "developer-tools",
+    "cli",
+    "claude-code",
+    "cursor",
+    "gemini",
+    "codex",
+    "mcp",
+    "agent-framework"
+  ],
+  "type": "module",
+  "license": "MIT",
+  "author": "wwa contributors",
+  "bin": {
+    "wwa": "bin/wwa.js",
+    "agent-method": "bin/wwa.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "docs/internal/feature-registry.yaml",
+    "docs/internal/doc-tokens.yaml",
+    "docs/internal/cli-commands.yaml"
+  ],
+  "main": "lib/registry.js",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.27.1",
+    "chalk": "^5.6.2",
+    "chokidar": "^4.0.3",
+    "commander": "^12.0.0",
+    "inquirer": "^9.0.0",
+    "js-yaml": "^4.1.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/wwa"
+  },
+  "scripts": {
+    "test": "node --test tests/js/cli-smoke.test.cjs",
+    "test:setup": "node tests/js/test-setup-wrapper.cjs"
+  }
+}