agent-method 1.5.12

package/lib/cli/scan.js

@@ -0,0 +1,133 @@
+/** wwa scan — detect project type from directory contents; optional overview (doc structure, methodology files, dependency summary). */
+
+import { resolve, join } from "node:path";
+import { existsSync, statSync } from "node:fs";
+import { getPipeline, outputData } from "./helpers.js";
+import { loadDocGraph } from "../boundaries.js";
+import { buildDefaultNodes } from "../dependencies.js";
+import { printCliReport, writeLastRunSummary } from "./report-helpers.js";
+
+// Key methodology directories (structure summary)
+const OVERVIEW_DIRS = ["docs", ".context", "registry", "Management", "todos", "intro"];
+
+/**
+ * Build overview: doc structure, methodology file inventory, dependency summary (Phase 7r §5.5).
+ * @param {string} dir - Resolved project root
+ * @returns {Promise<{ doc_structure: { present: string[], missing: string[] }, methodology_files: { present: string[], missing: string[] }, dependency_summary: object | null, deps_hint?: string }>}
+ */
+async function buildScanOverview(dir) {
+  const d = resolve(dir);
+  const doc_structure = { present: [], missing: [] };
+  for (const name of OVERVIEW_DIRS) {
+    const p = join(d, name);
+    try {
+      if (existsSync(p) && statSync(p).isDirectory()) {
+        doc_structure.present.push(name + "/");
+      } else {
+        doc_structure.missing.push(name + "/");
+      }
+    } catch {
+      doc_structure.missing.push(name + "/");
+    }
+  }
+
+  const methodology_files = { present: [], missing: [] };
+  const allNodes = buildDefaultNodes("full");
+  const paths = [...new Set(allNodes.map((n) => n.path))];
+  for (const path of paths) {
+    const p = join(d, path);
+    if (existsSync(p)) {
+      methodology_files.present.push(path);
+    } else {
+      methodology_files.missing.push(path);
+    }
+  }
+
+  const docGraph = await loadDocGraph(d);
+  let dependency_summary = null;
+  let deps_hint;
+  if (docGraph && docGraph.nodes && docGraph.edges) {
+    const nodes = docGraph.nodes.length;
+    const edges = docGraph.edges.length;
+    const byType = {};
+    for (const e of docGraph.edges) {
+      byType[e.type] = (byType[e.type] || 0) + 1;
+    }
+    dependency_summary = {
+      nodes,
+      edges,
+      edge_types: byType,
+      last_scan: docGraph.last_scan || null,
+    };
+    deps_hint = "Run `wwa deps` for full dependency graph.";
+  } else {
+    deps_hint = "Run `wwa init` then `wwa deps` for dependency graph.";
+  }
+
+  return {
+    doc_structure,
+    methodology_files,
+    dependency_summary,
+    deps_hint,
+  };
+}
+
+export function register(program) {
+  program
+    .command("scan [directory]")
+    .description("Detect project type from directory contents; with overview: doc structure, methodology file inventory, key dependency summary (see wwa deps)")
+    .option("--registry <path>", "Path to feature-registry.yaml")
+    .option("--json", "Output as JSON")
+    .option("--no-overview", "Skip overview (doc structure, methodology files, dependency summary)")
+    .action(async (directory, opts) => {
+      directory = directory || ".";
+      const { detectProjectType } = await getPipeline();
+      const result = detectProjectType(directory);
+
+      const ptype = result.project_type || "general";
+      const friendlyMap = { analytical: "context", mixed: "mix" };
+      if (ptype in friendlyMap) {
+        result.friendly_name = friendlyMap[ptype];
+        result.init_command = `wwa init ${friendlyMap[ptype]}`;
+      } else {
+        result.init_command = `wwa init ${ptype}`;
+      }
+
+      if (opts.overview !== false) {
+        const overview = await buildScanOverview(directory);
+        result.overview = {
+          doc_structure: overview.doc_structure,
+          methodology_files: overview.methodology_files,
+          dependency_summary: overview.dependency_summary,
+        };
+        result.deps_hint = overview.deps_hint;
+      }
+
+      if (opts.json) {
+        console.log(`Scanning: ${directory}`);
+        outputData(result, true);
+      } else {
+        const ptype = result.project_type || "general";
+        const initCmd = result.init_command || `wwa init ${ptype}`;
+        const ov = result.overview;
+        const dirCount = ov?.doc_structure?.present?.length ?? 0;
+        const filePresent = ov?.methodology_files?.present?.length ?? 0;
+        const fileMissing = ov?.methodology_files?.missing?.length ?? 0;
+        const depLine = result.deps_hint || "";
+        const summary = [
+          `Project type: ${ptype}. Init: ${initCmd}.`,
+          ov
+            ? `${dirCount} methodology dirs present, ${filePresent} methodology files present, ${fileMissing} missing.`
+            : "Overview skipped (use without --no-overview for details).",
+          depLine,
+        ]
+          .filter(Boolean)
+          .join(" ");
+        const inputRef = `directory=${directory}`;
+        printCliReport({ command: "scan", inputRef, summary });
+        console.log(`  Detail — Scanning: ${directory}`);
+        outputData(result, false);
+        writeLastRunSummary(resolve(directory), { command: "scan", inputRef, summary });
+      }
+    });
+}

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

@@ -0,0 +1,65 @@
+/** wwa status — check if methodology version is current. */
+
+import { resolve } from "node:path";
+import { findEntryPoint, readMethodVersion, basename_of, pkg } from "./helpers.js";
+import { printCliReport, writeLastRunSummary } from "./report-helpers.js";
+
+export function register(program) {
+  program
+    .command("status [directory]")
+    .description("Check if your methodology version is current")
+    .option("--json", "Output as JSON")
+    .action(async (directory, opts) => {
+      directory = directory || ".";
+      const ep = findEntryPoint(directory);
+      if (!ep) {
+        console.error(
+          `No entry point found in ${directory} ` +
+            "(looked for CLAUDE.md, .cursorrules, AGENT.md)"
+        );
+        process.exit(1);
+      }
+
+      const epVersion = readMethodVersion(ep);
+      const installed = pkg.version;
+
+      let verStatus, message;
+      if (!epVersion) {
+        verStatus = "no_version";
+        message =
+          `Entry point ${basename_of(ep)} has no method_version setting. ` +
+          `Add 'method_version: ${installed.split(".").slice(0, 2).join(".")}' ` +
+          `to enable version tracking.`;
+      } else if (epVersion === installed.split(".").slice(0, 2).join(".")) {
+        verStatus = "current";
+        message =
+          `Entry point ${basename_of(ep)} is current ` +
+          `(method_version: ${epVersion}, installed: ${installed})`;
+      } else {
+        verStatus = "outdated";
+        message =
+          `Entry point ${basename_of(ep)} is outdated ` +
+          `(method_version: ${epVersion}, installed: ${installed}). ` +
+          `Run \`wwa upgrade ${directory}\` to update.`;
+      }
+
+      if (opts.json) {
+        console.log(
+          JSON.stringify(
+            {
+              entry_point: ep,
+              entry_point_version: epVersion,
+              installed_version: installed,
+              status: verStatus,
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        const inputRef = `directory=${directory}`;
+        printCliReport({ command: "status", inputRef, summary: message });
+        writeLastRunSummary(resolve(directory || "."), { command: "status", inputRef, summary: message });
+      }
+    });
+}