agent-method 1.5.0 → 1.5.3

package/lib/cli/init.js

@@ -1,4 +1,4 @@
-/** agent-method init — set up a new project or describe entry point contents. */
+/** wwa init — set up a new project with methodology templates. */
 
 import {
   resolveProjectType,
@@ -10,9 +10,11 @@ import {
 
 export function register(program) {
   program
-    .command("init <project-type> [directory]")
+    .command("init [project-type] [directory]")
     .description("Set up a new project with methodology templates")
-    .option("--tier <tier>", "Template tier (starter/full)", "starter")
+    .option("--tier <tier>", "Template tier (starter/full)")
+    .option("--runtime <runtime>", "Agent runtime (claude/cursor/all)")
+    .option("--profile <profile>", "Integration profile (lite/standard/full)")
     .option("--registry <path>", "Path to feature-registry.yaml")
     .option("--json", "Output as JSON")
     .option(
@@ -20,15 +22,13 @@ export function register(program) {
       "Only describe what the entry point should contain (no file creation)"
     )
     .action(async (projectTypeArg, directory, opts) => {
-      const projectType = resolveProjectType(projectTypeArg);
-
-      if (opts.describe || !directory) {
-        // Describe mode
+      // If describe mode with a type, show entry point spec
+      if (opts.describe && projectTypeArg) {
+        const projectType = resolveProjectType(projectTypeArg);
         const { generateEntryPoint } = await getPipeline();
         const reg = await loadRegistryData(opts.registry);
-        const result = generateEntryPoint(projectType, opts.tier, reg);
+        const result = generateEntryPoint(projectType, opts.tier || "starter", reg);
 
-        // Show friendly name
         let friendly = projectType;
         for (const [alias, internal] of Object.entries(PROJECT_TYPE_ALIASES)) {
           if (internal === projectType && alias !== projectType) {
@@ -38,22 +38,112 @@ export function register(program) {
         }
 
         console.log(
-          `Entry point specification for: ${friendly} (${opts.tier})`
+          `Entry point specification for: ${friendly} (${opts.tier || "starter"})`
         );
         outputData(result, opts.json);
+        return;
+      }
+
+      // Interactive mode — prompt for missing values
+      if (!projectTypeArg || !directory) {
+        const inquirer = (await import("inquirer")).default;
+
+        console.log("\n  wwa — Set up AI-agent-assisted development\n");
+
+        const answers = {};
+
+        if (!projectTypeArg) {
+          const { type } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "type",
+              message: "Project type:",
+              choices: [
+                { name: "Code            — software project", value: "code" },
+                { name: "Data            — data index/querying", value: "data" },
+                { name: "Analytical      — prompts, chains, evaluation", value: "context" },
+                { name: "Mixed           — multiple types combined", value: "mix" },
+                { name: "General         — universal rules only", value: "general" },
+              ],
+            },
+          ]);
+          answers.type = type;
+        }
+
         if (!directory) {
-          console.log(
-            "\nTo create a project, specify a directory:\n" +
-              `  agent-method init ${projectTypeArg} ~/my-project`
-          );
+          const { dir } = await inquirer.prompt([
+            {
+              type: "input",
+              name: "dir",
+              message: "Project directory:",
+              default: ".",
+            },
+          ]);
+          answers.dir = dir;
         }
-        return;
+
+        if (!opts.runtime) {
+          const { runtime } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "runtime",
+              message: "Agent runtime:",
+              choices: [
+                { name: "Claude Code     — creates CLAUDE.md", value: "claude" },
+                { name: "Cursor          — creates .cursorrules", value: "cursor" },
+                { name: "Other / All     — keeps all entry points", value: "all" },
+              ],
+            },
+          ]);
+          answers.runtime = runtime;
+        }
+
+        if (!opts.tier) {
+          const { tier } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "tier",
+              message: "Template tier:",
+              choices: [
+                { name: "Starter (7 files)   — recommended for most projects", value: "starter" },
+                { name: "Full (11+ files)    — complex or long-running projects", value: "full" },
+              ],
+            },
+          ]);
+          answers.tier = tier;
+        }
+
+        if (!opts.profile) {
+          const { profile } = await inquirer.prompt([
+            {
+              type: "list",
+              name: "profile",
+              message: "Integration profile:",
+              choices: [
+                { name: "Standard (Sonnet)   — recommended", value: "standard" },
+                { name: "Lite (Haiku)        — minimal rules, simple projects", value: "lite" },
+                { name: "Full (Opus)         — all rules inline, complex projects", value: "full" },
+              ],
+            },
+          ]);
+          answers.profile = profile;
+        }
+
+        projectTypeArg = projectTypeArg || answers.type;
+        directory = directory || answers.dir;
+        opts.runtime = opts.runtime || answers.runtime;
+        opts.tier = opts.tier || answers.tier;
+        opts.profile = opts.profile || answers.profile;
       }
 
-      // Interactive setup mode
+      const projectType = resolveProjectType(projectTypeArg);
+
+      // Setup mode
       const { initProject } = await import("../init.js");
       await initProject(projectType, directory, {
-        tier: opts.tier,
+        tier: opts.tier || "starter",
+        runtime: opts.runtime || "all",
+        profile: opts.profile || "standard",
         registryPath: opts.registry,
       });
     });

package/lib/cli/pipeline.js

@@ -1,4 +1,4 @@
-/** agent-method pipeline — advanced subcommands for debugging and testing. */
+/** wwa pipeline — advanced subcommands for debugging and testing. */
 
 import { resolve, dirname, join } from "node:path";
 import { existsSync, readdirSync } from "node:fs";

package/lib/cli/refine.js

@@ -1,4 +1,4 @@
-/** agent-method refine — extract refinement report from session history. */
+/** wwa refine — extract refinement report from session history. */
 
 import { readFileSync, existsSync, writeFileSync } from "node:fs";
 import { findSessionLog } from "./helpers.js";
@@ -15,7 +15,7 @@ export function register(program) {
         if (!sessionLog) {
           console.error(
             "No SESSION-LOG.md found in current directory.\n" +
-              "Specify a path: agent-method refine path/to/SESSION-LOG.md"
+              "Specify a path: npx wwa refine path/to/SESSION-LOG.md"
           );
           process.exit(1);
         }
@@ -135,7 +135,7 @@ function generateRefinementReport(parsed) {
   const lines = [
     `# Refinement Report: ${project}`,
     "",
-    "Auto-generated from SESSION-LOG.md by `agent-method refine`.",
+    "Auto-generated from SESSION-LOG.md by `wwa refine`.",
     "",
     "## Source",
     "",

package/lib/cli/route.js

@@ -1,4 +1,4 @@
-/** agent-method route — show how a query routes through the pipeline. */
+/** wwa route — show how a query routes through the pipeline. */
 
 import {
   resolveProjectType,

package/lib/cli/scan.js

@@ -1,4 +1,4 @@
-/** agent-method scan — detect project type from directory contents. */
+/** wwa scan — detect project type from directory contents. */
 
 import { getPipeline, outputData } from "./helpers.js";
 
@@ -17,9 +17,9 @@ export function register(program) {
       const friendlyMap = { analytical: "context", mixed: "mix" };
       if (ptype in friendlyMap) {
         result.friendly_name = friendlyMap[ptype];
-        result.init_command = `agent-method init ${friendlyMap[ptype]}`;
+        result.init_command = `npx wwa init ${friendlyMap[ptype]}`;
       } else {
-        result.init_command = `agent-method init ${ptype}`;
+        result.init_command = `npx wwa init ${ptype}`;
       }
 
       console.log(`Scanning: ${directory}`);

package/lib/cli/serve.js

@@ -0,0 +1,23 @@
+/** wwa serve — start MCP server on stdio transport. */
+
+export function register(program) {
+  program
+    .command("serve")
+    .description("Start MCP server exposing methodology tools via stdio transport")
+    .option("--registry <path>", "Path to feature-registry.yaml")
+    .action(async (opts) => {
+      // Redirect all non-MCP output to stderr so stdout stays clean for JSON-RPC
+      const info = (msg) => process.stderr.write(msg + "\n");
+
+      info("wwa MCP server starting...");
+
+      try {
+        const { startServer } = await import("../mcp-server.js");
+        await startServer(opts.registry || undefined);
+        info("wwa MCP server running on stdio. Press Ctrl+C to stop.");
+      } catch (err) {
+        info(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/lib/cli/status.js

@@ -1,4 +1,4 @@
-/** agent-method status — check if methodology version is current. */
+/** wwa status — check if methodology version is current. */
 
 import { findEntryPoint, readMethodVersion, basename_of, pkg } from "./helpers.js";
 
@@ -38,7 +38,7 @@ export function register(program) {
         message =
           `Entry point ${basename_of(ep)} is outdated ` +
           `(method_version: ${epVersion}, installed: ${installed}). ` +
-          `Run \`agent-method upgrade ${directory}\` to update.`;
+          `Run \`npx wwa upgrade ${directory}\` to update.`;
       }
 
       if (opts.json) {

package/lib/cli/upgrade.js

@@ -1,4 +1,4 @@
-/** agent-method upgrade — brownfield-safe methodology update. */
+/** wwa upgrade — brownfield-safe methodology update. */
 
 import {
   readFileSync, existsSync, copyFileSync, mkdirSync, writeFileSync,
@@ -39,7 +39,7 @@ export function register(program) {
       if (!existsSync(srcDir)) {
         console.error(
           `Template directory not found: ${srcDir}. ` +
-            "Run from the agent-method repo or install from source."
+            "Run from the wwa repo or install from source."
         );
         process.exit(1);
       }
@@ -65,7 +65,7 @@ export function register(program) {
                 `## Method version\n\n` +
                 `method_version: ${newVer}\n` +
                 `<!-- Tracks which methodology version generated this entry point -->\n` +
-                `<!-- Use \`agent-method status\` to compare against latest -->\n\n`;
+                `<!-- Use \`npx wwa status\` to compare against latest -->\n\n`;
               content = content.replace("## Conventions", insert + "## Conventions");
               writeFileSync(ep, content, "utf-8");
             }
@@ -100,8 +100,8 @@ export function register(program) {
             if (content.includes("<!-- INSTRUCTION: Add project-specific cascade")) {
               content = content.replace(
                 "<!-- INSTRUCTION: Add project-specific cascade",
-                "| Session close | SESSION-LOG.md (append micro-entry" +
-                  " \u2014 workflow, features, cascades, friction, findings) " +
+                "| Session close or high-effort task completion | SESSION-LOG.md (append metrics entry" +
+                  " \u2014 effort, ambiguity, context level, tokens, time, workflow, features, cascades, friction, findings) " +
                   "|\n\n<!-- INSTRUCTION: Add project-specific cascade"
               );
               writeFileSync(ep, content, "utf-8");
@@ -119,8 +119,9 @@ export function register(program) {
             if (content.includes("## Do not")) {
               content = content.replace(
                 "## Do not",
-                "- At session close, append a micro-entry to " +
-                  "SESSION-LOG.md \u2014 never skip, never read " +
+                "- At session close or after any high-effort task, append a metrics entry to " +
+                  "SESSION-LOG.md \u2014 include effort level, question ambiguity, context level, " +
+                  "estimated tokens, and time. Never skip, never read " +
                   "previous entries during normal work\n\n" +
                   "## Do not"
               );

package/lib/cli/watch.js

@@ -0,0 +1,32 @@
+/** wwa watch — file watcher for proactive validation. */
+
+export function register(program) {
+  program
+    .command("watch [directory]")
+    .description("Watch entry points and markdown files for changes, validate on save")
+    .option("--registry <path>", "Path to feature-registry.yaml")
+    .action(async (directory, opts) => {
+      const dir = directory || ".";
+
+      console.log(`Watching: ${dir}`);
+      console.log("Monitoring entry points, registry, and markdown files...");
+      console.log("Press Ctrl+C to stop.\n");
+
+      try {
+        const { createWatcher } = await import("../watcher.js");
+        const watcher = createWatcher(dir, {
+          registryPath: opts.registry || undefined,
+        });
+
+        // Keep process alive
+        process.on("SIGINT", () => {
+          watcher.close();
+          console.log("\nWatcher stopped.");
+          process.exit(0);
+        });
+      } catch (err) {
+        console.error(`Error: ${err.message}`);
+        process.exit(1);
+      }
+    });
+}

package/lib/init.js

@@ -5,7 +5,7 @@
  * prompts for project configuration.
  */
 
-import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
+import { existsSync, mkdirSync, copyFileSync, readFileSync, writeFileSync, readdirSync, unlinkSync } from "node:fs";
 import { resolve, join, dirname, basename, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -26,11 +26,17 @@ const FRIENDLY_NAMES = {
   general: "General project",
 };
 
+const RUNTIME_ENTRY_POINTS = {
+  claude: "CLAUDE.md",
+  cursor: ".cursorrules",
+  all: null, // keep all
+};
+
 /**
  * Set up a new project with methodology templates.
  */
 export async function initProject(projectType, directory, opts = {}) {
-  const { tier = "starter", registryPath } = opts;
+  const { tier = "starter", runtime = "all", profile = "standard", registryPath } = opts;
   const targetDir = resolve(directory);
   const methodRoot = resolve(__dirname, "..");
 
@@ -42,6 +48,8 @@ export async function initProject(projectType, directory, opts = {}) {
 
   console.log(`\nSetting up ${FRIENDLY_NAMES[projectType] || projectType} project`);
   console.log(`  Template: ${tier}`);
+  console.log(`  Profile:  ${profile}`);
+  console.log(`  Runtime:  ${runtime}`);
   console.log(`  Target:   ${targetDir}\n`);
 
   // Detect brownfield (existing project with methodology files)
@@ -72,21 +80,38 @@ export async function initProject(projectType, directory, opts = {}) {
   // Replace placeholders in entry points
   replacePlaceholders(targetDir, projectType, tier);
 
+  // Set integration profile in entry points
+  setProfile(targetDir, profile);
+
+  // Remove unused entry points based on runtime choice
+  const removed = removeUnusedEntryPoints(targetDir, runtime, isBrownfield);
+
   // Report
   console.log(`  Files created: ${copied.length}`);
   for (const f of copied) console.log(`    + ${f}`);
+  if (removed.length > 0) {
+    console.log(`  Entry points removed: ${removed.length}`);
+    for (const f of removed) console.log(`    - ${f}`);
+  }
   if (skipped.length > 0) {
     console.log(`  Files skipped (already exist): ${skipped.length}`);
     for (const f of skipped) console.log(`    ~ ${f}`);
   }
 
+  // Determine which entry point the user kept
+  const keptEntry = runtime === "claude" ? "CLAUDE.md"
+    : runtime === "cursor" ? ".cursorrules"
+    : "CLAUDE.md / .cursorrules / AGENT.md";
+
   console.log(`\nNext steps:`);
   console.log(`  1. cd ${relative(process.cwd(), targetDir) || "."}`);
   console.log(`  2. Fill in PROJECT.md with your project vision`);
-  console.log(`  3. Delete the two entry point files you don't use`);
-  console.log(`     (keep CLAUDE.md, .cursorrules, or AGENT.md)`);
-  console.log(`  4. Start a conversation — the agent reads the entry point`);
-  console.log(`\nRun \`agent-method check\` to validate your setup.`);
+  if (runtime === "all") {
+    console.log(`  3. Delete the two entry point files you don't use`);
+    console.log(`     (keep CLAUDE.md, .cursorrules, or AGENT.md)`);
+  }
+  console.log(`  ${runtime === "all" ? "4" : "3"}. Start a conversation — the agent reads ${keptEntry} automatically`);
+  console.log(`\nVerify: npx wwa check`);
 }
 
 function detectBrownfield(dir) {
@@ -238,3 +263,34 @@ function replacePlaceholders(targetDir, projectType, tier) {
     writeFileSync(epPath, content, "utf-8");
   }
 }
+
+function setProfile(targetDir, profile) {
+  for (const epName of ["CLAUDE.md", ".cursorrules", "AGENT.md"]) {
+    const epPath = join(targetDir, epName);
+    if (!existsSync(epPath)) continue;
+
+    let content = readFileSync(epPath, "utf-8");
+    content = content.replace(/tier:\s*(lite|standard|full)/, `tier: ${profile}`);
+    writeFileSync(epPath, content, "utf-8");
+  }
+}
+
+function removeUnusedEntryPoints(targetDir, runtime, isBrownfield) {
+  if (runtime === "all" || isBrownfield) return [];
+
+  const allEntryPoints = ["CLAUDE.md", ".cursorrules", "AGENT.md"];
+  const keep = RUNTIME_ENTRY_POINTS[runtime];
+  if (!keep) return [];
+
+  const removed = [];
+  for (const ep of allEntryPoints) {
+    if (ep !== keep) {
+      const epPath = join(targetDir, ep);
+      if (existsSync(epPath)) {
+        unlinkSync(epPath);
+        removed.push(ep);
+      }
+    }
+  }
+  return removed;
+}