@williambeto/ai-workflow 2.4.9 → 2.6.3

package/src/core/package-assets.js

@@ -1,141 +0,0 @@
-/**
- * Package asset resolution for @williambeto/ai-workflow.
- *
- * Resolves the installed package root and reads real skill/agent/command
- * files so `init` copies them to the target project instead of generating stubs.
- */
-import { fileURLToPath } from "node:url";
-import { dirname, resolve } from "node:path";
-import { readFileSync, readdirSync, statSync } from "node:fs";
-
-let cachedRoot = null;
-
-/**
- * Return the absolute path to the installed package root
- * (the directory containing `.agents/skills/`).
- *
- * It dynamically searches for the package.json belonging to @williambeto/ai-workflow
- * by climbing up from the current module location.
- */
-export function getPackageRoot() {
-  if (cachedRoot) return cachedRoot;
-  let currentDir = dirname(fileURLToPath(import.meta.url));
-
-  while (true) {
-    const pkgPath = resolve(currentDir, "package.json");
-    try {
-      const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-      if (pkg.name === "@williambeto/ai-workflow") {
-        cachedRoot = currentDir;
-        return cachedRoot;
-      }
-    } catch {
-      // package.json doesn't exist or is invalid, keep climbing
-    }
-
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) {
-      break; // Reached filesystem root
-    }
-    currentDir = parentDir;
-  }
-
-  throw new Error("Failed to resolve @williambeto/ai-workflow package root physically.");
-}
-
-/**
- * Read a file relative to the package root.
- * Returns null if the file does not exist.
- */
-export function readPackageFile(relativePath) {
-  try {
-    const fullPath = resolve(getPackageRoot(), relativePath);
-    return readFileSync(fullPath, "utf8");
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Resolve the current kit version from package metadata.
- * Returns null if package.json cannot be read/parsed.
- */
-export function getPackageVersion() {
-  try {
-    const raw = readPackageFile("package.json");
-    if (!raw) return null;
-    const parsed = JSON.parse(raw);
-    return typeof parsed.version === "string" ? parsed.version : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Discover ALL files under a package-relative directory.
- * Returns a flat map of { relativePath: content }.
- * Skips non-existent directories silently.
- */
-export function discoverPackageFiles(baseRelativePath) {
-  const files = {};
-  const basePath = resolve(getPackageRoot(), baseRelativePath);
-
-  try {
-    if (!statSync(basePath).isDirectory()) {
-      return files;
-    }
-  } catch {
-    return files;
-  }
-
-  function walk(dir, relativePrefix) {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = resolve(dir, entry.name);
-      const relativePath = relativePrefix
-        ? `${relativePrefix}/${entry.name}`
-        : entry.name;
-
-      if (entry.isDirectory()) {
-        walk(fullPath, relativePath);
-      } else if (entry.isFile()) {
-        try {
-          files[relativePath] = readFileSync(fullPath, "utf8");
-        } catch {
-          // skip unreadable files
-        }
-      }
-    }
-  }
-
-  walk(basePath, baseRelativePath);
-  return files;
-}
-
-/**
- * Read the SKILL.md for a given skill name, plus any reference files
- * found under a directory.
- * Returns a map of { relativePath: content }.
- */
-export function getFullSkillFiles(skillName) {
-  const skillRelPath = `dist-assets/skills/${skillName}`;
-  const files = discoverPackageFiles(skillRelPath);
-  return files;
-}
-
-/**
- * Read the agent .md file for a given agent name.
- * Returns the content string or null.
- */
-export function getFullAgentContent(agentName) {
-  return readPackageFile(`dist-assets/agents/${agentName}.md`);
-}
-
-/**
- * Read the command .md file for a given command name.
- * Returns the content string or null.
- */
-export function getFullCommandContent(commandName) {
-  return readPackageFile(`dist-assets/commands/${commandName}.md`);
-}
-

package/src/core/request-classifier.js

@@ -1,73 +0,0 @@
-import { resolveWorkflowProfile, getWorkflowProfile } from "./workflow-profiles.js";
-import { RequestRouter } from "./request-router.js";
-
-/**
- * RequestClassifier - Classifies natural requests into structured, testable contracts.
- */
-export class RequestClassifier {
-  /**
-   * Classifies a natural request.
-   * @param {string} request - The natural language request string.
-   * @returns {Object} Structured classification contract.
-   */
-  classify(request = "", options = {}) {
-    const text = String(request).trim();
-    if (!text) {
-      throw new Error("Cannot classify an empty request.");
-    }
-
-    const cwd = options.cwd || process.cwd();
-
-    // 1. Resolve Profile
-    const profile = resolveWorkflowProfile({ request: text });
-    const profileDef = getWorkflowProfile(profile);
-
-    // 2. Classify Intent
-    const readOnlyPatterns = /\b(analyze|check|inspect|review|find|search|show|list|read|view|verify)\b/i;
-    const isReadOnly = readOnlyPatterns.test(text);
-    const intent = isReadOnly ? "read-only" : "write";
-
-    // 3. Classify Mode
-    let mode = "standard";
-    if (/\b(deep|architectural|migration|major|full|\[deep\])\b/i.test(text)) {
-      mode = "full";
-    } else if (/\b(tiny|small|quick|simple|only\s+update|typo|comment|\[tiny\])\b/i.test(text)) {
-      const isPureDocsOrTypo = profile === "documentation" || /\b(typo|comment|readme|docs|documentation)\b/i.test(text);
-      if (intent === "write" && !isPureDocsOrTypo) {
-        mode = "standard";
-      } else {
-        mode = "quick";
-      }
-    }
-
-    // 4. Classify Risk
-    let risk = "medium";
-    if (mode === "full" || profile === "security-review") {
-      risk = "high";
-    } else if (mode === "quick" || intent === "read-only") {
-      risk = "low";
-    }
-
-    const specNeeded = mode === "full" && intent === "write";
-    const validationNeeded = intent === "write";
-
-    // Integrate central RequestRouter
-    const router = new RequestRouter({ cwd });
-    const requestUnderstanding = router.understand(text);
-    const routingDecision = router.route(requestUnderstanding);
-
-    return {
-      request: text,
-      profile,
-      owner: routingDecision.selectedActor || profileDef.owner,
-      intent: requestUnderstanding.mutationIntent === "readonly" ? "read-only" : "write",
-      mode,
-      risk: requestUnderstanding.riskLevel,
-      specNeeded,
-      validationNeeded,
-      skills: [...profileDef.skills],
-      requestUnderstanding,
-      routingDecision
-    };
-  }
-}

package/src/core/request-router.js

@@ -1,289 +0,0 @@
-import path from "node:path";
-import fs from "node:fs";
-
-export class RequestRouter {
-  constructor({ cwd = process.cwd() } = {}) {
-    this.cwd = cwd;
-    this.validActors = ["Atlas", "Nexus", "Orion", "Astra", "Sage", "Phoenix"];
-  }
-
-  /**
-   * Understands and classifies a natural language request.
-   * @param {string} request 
-   * @returns {Object} RequestUnderstanding
-   */
-  understand(request) {
-    const text = String(request).trim();
-    if (!text) {
-      throw new Error("Cannot classify an empty request.");
-    }
-
-    // 1. Extract requested actor
-    let requestedActor = undefined;
-    let invalidActor = undefined;
-
-    // Direct addressing/reference pattern e.g., "Nexus, discover...", "ask Sage to..."
-    const askMatch = text.match(/\b(?:ask|use|tell|run|agent|actor)\s+([a-zA-Z]+)\b/i);
-    const addressMatch = text.match(/\b([a-zA-Z]+)\s*(?:,)/);
-
-    let candidate = null;
-    if (askMatch) {
-      candidate = askMatch[1];
-    } else if (addressMatch) {
-      candidate = addressMatch[1];
-    } else {
-      // General match for known actors
-      const knownMatch = text.match(/\b(Atlas|Nexus|Orion|Astra|Sage|Phoenix)\b/i);
-      if (knownMatch) {
-        candidate = knownMatch[1];
-      }
-    }
-
-    if (candidate) {
-      const normalized = candidate.charAt(0).toUpperCase() + candidate.slice(1).toLowerCase();
-      if (this.validActors.includes(normalized)) {
-        requestedActor = normalized;
-      } else {
-        invalidActor = candidate;
-      }
-    }
-
-    // 2. Extract operationType and requestedCapability
-    let operationType = "explain"; // default
-    let requestedCapability = undefined;
-
-    const capabilityMappings = [
-      { op: "discover", pattern: /\b(discover|inspect|map|scan|structure|architecture|repo|search|find)\b/i },
-      { op: "validate", pattern: /\b(validate|audit|review|check|verify|test)\b/i },
-      { op: "implement", pattern: /\b(implement|build|create|add|develop|write|change|modify)\b/i },
-      { op: "fix", pattern: /\b(fix|repair|correct|heal|solve|remediate)\b/i },
-      { op: "release", pattern: /\b(release|tag|prepare release)\b/i },
-      { op: "deploy", pattern: /\b(deploy|publish|push)\b/i }
-    ];
-
-    for (const mapping of capabilityMappings) {
-      const match = text.match(mapping.pattern);
-      if (match) {
-        operationType = mapping.op;
-        requestedCapability = match[1];
-        break;
-      }
-    }
-
-    // 3. Determine mutationIntent
-    const writePatterns = /\b(implement|build|fix|write|change|modify|create|add|refactor|update)\b/i;
-    const readOnlyPatterns = /\b(analyze|check|inspect|review|find|search|show|list|read|view|verify|validate|discover|map)\b/i;
-    
-    let mutationIntent = "write"; // default
-    if (/\b(read-only|readonly)\b/i.test(text)) {
-      mutationIntent = "readonly";
-    } else if (writePatterns.test(text)) {
-      mutationIntent = "write";
-    } else if (readOnlyPatterns.test(text) || ["discover", "validate"].includes(operationType)) {
-      mutationIntent = "readonly";
-    }
-
-    if (/\b(publish|release|deploy|push to npm|push to remote)\b/i.test(text)) {
-      mutationIntent = "publish";
-    }
-
-    // Determine Mode (needed for riskLevel mapping)
-    let mode = "standard";
-    if (/\b(deep|architectural|migration|major|full|\[deep\])\b/i.test(text)) {
-      mode = "full";
-    } else if (/\b(tiny|small|quick|simple|only\s+update|typo|comment|\[tiny\])\b/i.test(text)) {
-      mode = "quick";
-    }
-
-    // 4. Determine riskLevel
-    let riskLevel = "medium";
-    if (mode === "full" || mutationIntent === "publish" || /\b(bypass|force|direct)\b/i.test(text)) {
-      riskLevel = "high";
-    } else if (mode === "quick" || mutationIntent === "readonly") {
-      riskLevel = "low";
-    }
-
-    // 5. safetyConstraints and requiredEvidence
-    const safetyConstraints = [];
-    const requiredEvidence = [];
-
-    if (mutationIntent === "publish") {
-      safetyConstraints.push("Require release gate", "Awaiting user authorization");
-      requiredEvidence.push("release-decision", "tarball-hash");
-    } else if (mutationIntent === "write") {
-      safetyConstraints.push("Require branch gate", "No direct commits to main");
-      requiredEvidence.push("tests", "commit-hash");
-    } else {
-      safetyConstraints.push("No workspace mutations allowed");
-    }
-
-    if (/\b(bypass|force|direct)\b/i.test(text)) {
-      safetyConstraints.push("Block bypass attempts");
-    }
-
-    return {
-      rawRequest: text,
-      taskGoal: `Perform ${operationType} operation under ${mutationIntent} intent`,
-      requestedActor,
-      invalidActor,
-      requestedCapability,
-      operationType,
-      mutationIntent,
-      riskLevel,
-      requiredEvidence,
-      safetyConstraints
-    };
-  }
-
-  /**
-   * Decides the routing decision.
-   * @param {Object} understanding - RequestUnderstanding
-   * @returns {Object} RoutingDecision
-   */
-  route(understanding) {
-    const { requestedActor, invalidActor, operationType, mutationIntent, rawRequest } = understanding;
-
-    // 1. Check for bypass safety attempts
-    if (/\b(bypass safety|bypass validation|force push|directly to main|push to remote without gate)\b/i.test(rawRequest)) {
-      return {
-        requestedActor,
-        selectedActor: "Atlas",
-        operationType,
-        mutationIntent,
-        permissionDecision: "blocked",
-        reason: "Security block: Attempt to bypass safety or push directly is forbidden.",
-        workflowPath: ["Atlas"]
-      };
-    }
-
-    // 2. Check for invalid/ambiguous actor names in critical actions
-    if (invalidActor) {
-      if (["release", "deploy", "fix", "implement"].includes(operationType) || mutationIntent === "publish") {
-        return {
-          requestedActor: undefined,
-          selectedActor: "Atlas",
-          operationType,
-          mutationIntent,
-          permissionDecision: "blocked",
-          reason: `Security block: Request mentions invalid/unrecognized actor '${invalidActor}' for a critical operation.`,
-          workflowPath: ["Atlas"]
-        };
-      }
-    }
-
-    // 3. Permission matrix check
-    const PERMISSION_MATRIX = {
-      Atlas: {
-        allowedOperations: ["explain"],
-        allowedMutations: ["readonly"]
-      },
-      Nexus: {
-        allowedOperations: ["discover", "explain", "plan"],
-        allowedMutations: ["readonly", "write"]
-      },
-      Orion: {
-        allowedOperations: ["plan", "release", "deploy"],
-        allowedMutations: ["readonly", "write", "publish"]
-      },
-      Astra: {
-        allowedOperations: ["implement", "fix", "explain"],
-        allowedMutations: ["readonly", "write"]
-      },
-      Sage: {
-        allowedOperations: ["validate", "explain"],
-        allowedMutations: ["readonly"]
-      },
-      Phoenix: {
-        allowedOperations: ["fix"],
-        allowedMutations: ["readonly", "write"]
-      }
-    };
-
-    let selectedActor = undefined;
-    let permissionDecision = "allowed";
-    let reason = "Routed successfully.";
-    let workflowPath = ["Atlas"];
-
-    if (requestedActor) {
-      const perms = PERMISSION_MATRIX[requestedActor];
-      const isOpAllowed = perms.allowedOperations.includes(operationType);
-      const isMutationAllowed = perms.allowedMutations.includes(mutationIntent);
-
-      if (isOpAllowed && isMutationAllowed) {
-        selectedActor = requestedActor;
-      } else {
-        // Valid actor but unauthorized operation or mutation
-        if (mutationIntent === "publish") {
-          selectedActor = "Orion";
-          permissionDecision = "rerouted";
-          reason = `Rerouted: Requested actor '${requestedActor}' is not authorized to publish. Redirecting to Orion.`;
-        } else {
-          selectedActor = requestedActor;
-          permissionDecision = "blocked";
-          reason = `Blocked: Requested actor '${requestedActor}' does not have permission for operation '${operationType}' or mutation '${mutationIntent}'.`;
-        }
-      }
-    } else {
-      // Infer actor from operation, risk, capability
-      if (operationType === "discover") {
-        selectedActor = "Nexus";
-      } else if (operationType === "validate") {
-        selectedActor = "Sage";
-      } else if (operationType === "fix") {
-        selectedActor = "Phoenix";
-      } else if (operationType === "implement") {
-        selectedActor = "Astra";
-      } else if (operationType === "release" || operationType === "deploy") {
-        selectedActor = "Orion";
-      } else {
-        // Fallback for general explain/plan
-        selectedActor = mutationIntent === "write" ? "Astra" : "Atlas";
-      }
-    }
-
-    // Phoenix findings check: A fix request requires findings before Phoenix acts
-    if (selectedActor === "Phoenix") {
-      const requestPath = path.join(this.cwd, ".ai-workflow/remediation-request.json");
-      let hasFindings = false;
-      if (fs.existsSync(requestPath)) {
-        try {
-          const reqData = JSON.parse(fs.readFileSync(requestPath, "utf8"));
-          if (reqData.affectedChecks && reqData.affectedChecks.length > 0) {
-            hasFindings = true;
-          }
-        } catch {
-          // ignore
-        }
-      }
-      if (!hasFindings) {
-        permissionDecision = "blocked";
-        reason = "Blocked: Phoenix acts only with concrete findings and bounded remediation.";
-      }
-    }
-
-    if (selectedActor && !workflowPath.includes(selectedActor)) {
-      workflowPath.push(selectedActor);
-    }
-
-    // Atlas self-execution guard
-    if (selectedActor === "Atlas" && (requestedActor || ["discover", "validate", "fix", "release", "deploy"].includes(operationType))) {
-      permissionDecision = "blocked";
-      reason = "Atlas self-execution guard: Atlas cannot silently execute specialized actor or capability requests.";
-    }
-
-    // Sage and Phoenix revalidation loop path in full mode:
-    if (selectedActor === "Astra" && understanding.riskLevel === "high") {
-      workflowPath.push("Sage", "Phoenix", "Sage");
-    }
-
-    return {
-      requestedActor,
-      selectedActor,
-      operationType,
-      mutationIntent,
-      permissionDecision,
-      reason,
-      workflowPath
-    };
-  }
-}