agent-workflow-kit-cli 1.2.1 → 1.3.0

package/dist/core/awos/profiles.js

@@ -0,0 +1,272 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import { promises as fs } from "fs";
+import path from "path";
+import { parseImports } from "../parser.js";
+// Built-in Profiles database fallback
+const BUILTIN_PROFILES = {
+    "layered": {
+        name: "layered",
+        version: "1.0.0",
+        folderStructure: [
+            {
+                pathPattern: "**/controller/**",
+                allowedImports: ["**/service/**", "**/dto/**", "**/model/**"],
+                forbiddenImports: ["**/repository/**", "**/entity/**"],
+            },
+            {
+                pathPattern: "**/service/**",
+                allowedImports: ["**/repository/**", "**/dto/**", "**/model/**", "**/entity/**"],
+                forbiddenImports: ["**/controller/**"],
+            },
+        ],
+        reviewRules: {
+            maxFileLines: 500,
+            maxMethodLines: 50,
+            requireInterfaceForServices: false,
+        },
+        testingRequirements: {
+            mustHaveTestFile: false,
+            namingSuffix: "Test.java",
+        },
+    },
+    "clean-architecture": {
+        name: "clean-architecture",
+        version: "1.0.0",
+        extends: "layered",
+        folderStructure: [
+            {
+                pathPattern: "**/domain/**",
+                allowedImports: [],
+                forbiddenImports: ["**/infrastructure/**", "**/application/**", "**/presentation/**"],
+            },
+            {
+                pathPattern: "**/application/**",
+                allowedImports: ["**/domain/**"],
+                forbiddenImports: ["**/infrastructure/**", "**/presentation/**"],
+            },
+        ],
+        reviewRules: {
+            maxFileLines: 300,
+            maxMethodLines: 30,
+            requireInterfaceForServices: true,
+        },
+        testingRequirements: {
+            mustHaveTestFile: true,
+            namingSuffix: "Test.java",
+        },
+    },
+    "feature-first": {
+        name: "feature-first",
+        version: "1.0.0",
+        folderStructure: [
+            {
+                pathPattern: "**/features/*/**",
+                mustContainPatterns: ["components", "hooks", "index.ts"],
+            },
+        ],
+        reviewRules: {
+            maxFileLines: 400,
+            maxMethodLines: 40,
+            requireInterfaceForServices: false,
+        },
+        testingRequirements: {
+            mustHaveTestFile: true,
+            namingSuffix: ".test.ts",
+        },
+    },
+};
+/**
+ * Deep merges two architecture profiles for inheritance resolving.
+ */
+export function mergeProfiles(base, extension) {
+    return {
+        name: extension.name,
+        version: extension.version,
+        extends: extension.extends,
+        folderStructure: [...(base.folderStructure || []), ...(extension.folderStructure || [])],
+        reviewRules: {
+            ...base.reviewRules,
+            ...extension.reviewRules,
+        },
+        testingRequirements: {
+            ...base.testingRequirements,
+            ...extension.testingRequirements,
+        },
+    };
+}
+/**
+ * Loads a profile by name from disk or built-in registry.
+ */
+export async function loadProfile(profileName, profilesDir) {
+    const { loadAWOSPlugins } = await import("./registry.js");
+    const registry = await loadAWOSPlugins(process.cwd());
+    let profile = registry.profiles.get(profileName) || BUILTIN_PROFILES[profileName];
+    if (profilesDir) {
+        try {
+            const customPath = path.join(profilesDir, `${profileName}.json`);
+            const fileContent = await fs.readFile(customPath, "utf8");
+            profile = JSON.parse(fileContent);
+        }
+        catch {
+            // Fallback to built-in if file read fails
+        }
+    }
+    if (!profile) {
+        throw new Error(`Architecture Profile '${profileName}' not found.`);
+    }
+    if (profile.extends) {
+        const parentProfile = await loadProfile(profile.extends, profilesDir);
+        return mergeProfiles(parentProfile, profile);
+    }
+    return profile;
+}
+/**
+ * Matches glob-ish path patterns. Simple helper.
+ */
+function matchPathPattern(filePath, pattern) {
+    // Translate simple **/ pattern to regex
+    const regexString = pattern
+        .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape regex specials
+        .replace(/\*\*/g, ".*")
+        .replace(/\*/g, "[^/]*");
+    const regex = new RegExp(`^${regexString}$|^${regexString}`);
+    return regex.test(filePath.replace(/\\/g, "/"));
+}
+/**
+ * Validates a single file content and path against architectural rules.
+ */
+export async function validateFile(filePath, content, profile) {
+    const violations = [];
+    const relativePath = filePath.replace(/\\/g, "/");
+    // 1. Line limits check
+    const lines = content.split("\n");
+    if (lines.length > profile.reviewRules.maxFileLines) {
+        violations.push({
+            filePath,
+            ruleName: "maxFileLines",
+            message: `File has ${lines.length} lines, exceeding the limit of ${profile.reviewRules.maxFileLines}.`,
+            severity: "error",
+        });
+    }
+    // 2. Folder structures and imports validation
+    for (const rule of profile.folderStructure) {
+        if (matchPathPattern(relativePath, rule.pathPattern)) {
+            // Check imports
+            if (rule.forbiddenImports || rule.allowedImports) {
+                const parsedImports = await parseImports(filePath, content);
+                for (const importedRef of parsedImports) {
+                    // Forbidden check
+                    if (rule.forbiddenImports) {
+                        for (const forbidden of rule.forbiddenImports) {
+                            if (matchPathPattern(importedRef, forbidden)) {
+                                violations.push({
+                                    filePath,
+                                    ruleName: "forbiddenImports",
+                                    message: `Importing '${importedRef}' is forbidden in '${rule.pathPattern}'.`,
+                                    severity: "error",
+                                });
+                            }
+                        }
+                    }
+                    // Allowed check (if specified, anything not matched is forbidden)
+                    if (rule.allowedImports && rule.allowedImports.length > 0) {
+                        let isAllowed = false;
+                        // Also allow standard library / node modules
+                        if (!importedRef.startsWith(".") && !importedRef.startsWith("/") && !importedRef.includes("/")) {
+                            isAllowed = true;
+                        }
+                        else {
+                            for (const allowed of rule.allowedImports) {
+                                if (matchPathPattern(importedRef, allowed)) {
+                                    isAllowed = true;
+                                    break;
+                                }
+                            }
+                        }
+                        if (!isAllowed) {
+                            violations.push({
+                                filePath,
+                                ruleName: "allowedImports",
+                                message: `Importing '${importedRef}' is not explicitly allowed in '${rule.pathPattern}'.`,
+                                severity: "error",
+                            });
+                        }
+                    }
+                }
+            }
+            // Check required patterns
+            if (rule.mustContainPatterns) {
+                for (const pattern of rule.mustContainPatterns) {
+                    if (!content.includes(pattern)) {
+                        violations.push({
+                            filePath,
+                            ruleName: "mustContainPatterns",
+                            message: `File must contain pattern: '${pattern}'.`,
+                            severity: "warn",
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return violations;
+}
+/**
+ * Scans workspace and validates all source files against the ArchitectureProfile.
+ */
+export async function validateArchitecture(workspaceRoot, profile) {
+    const violations = [];
+    async function traverse(dir) {
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (entry.name.startsWith(".") ||
+                        entry.name === "node_modules" ||
+                        entry.name === "dist" ||
+                        entry.name === "build" ||
+                        entry.name === "target") {
+                        continue;
+                    }
+                    await traverse(fullPath);
+                }
+                else if (entry.isFile() && /\.(ts|tsx|java|py)$/.test(entry.name)) {
+                    // Avoid validating test files for structure limits
+                    const isTest = entry.name.endsWith(profile.testingRequirements.namingSuffix);
+                    const content = await fs.readFile(fullPath, "utf8");
+                    if (!isTest) {
+                        const fileViolations = await validateFile(fullPath, content, profile);
+                        violations.push(...fileViolations);
+                        // Verify test file existence if required
+                        if (profile.testingRequirements.mustHaveTestFile) {
+                            const ext = path.extname(entry.name);
+                            const baseName = path.basename(entry.name, ext);
+                            const testFileName = baseName + profile.testingRequirements.namingSuffix;
+                            const testPath = path.join(dir, testFileName);
+                            try {
+                                await fs.stat(testPath);
+                            }
+                            catch {
+                                violations.push({
+                                    filePath: fullPath,
+                                    ruleName: "mustHaveTestFile",
+                                    message: `Missing matching test file: '${testFileName}' expected in the same directory.`,
+                                    severity: "warn",
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    await traverse(workspaceRoot);
+    return violations;
+}

package/dist/core/awos/registry.js

@@ -0,0 +1,224 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import { promises as fs } from "fs";
+import path from "path";
+import { validateWorkflowGraph } from "./runtime.js";
+import { loadConfig } from "../config.js";
+/**
+ * Registry for discovery, validation, and loading of reusable workflow graph definitions.
+ */
+export class WorkflowRegistry {
+    /**
+     * Scans a directory recursively for workflow JSON files.
+     */
+    static async discover(dir) {
+        const workflows = [];
+        async function traverse(currentDir) {
+            try {
+                const entries = await fs.readdir(currentDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(currentDir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (entry.name.startsWith(".") ||
+                            entry.name === "node_modules" ||
+                            entry.name === "dist" ||
+                            entry.name === "build") {
+                            continue;
+                        }
+                        await traverse(fullPath);
+                    }
+                    else if (entry.isFile() && entry.name.endsWith(".json")) {
+                        try {
+                            const content = await fs.readFile(fullPath, "utf8");
+                            const parsed = JSON.parse(content);
+                            if (WorkflowRegistry.isValidSchema(parsed)) {
+                                // Perform graph cycles check
+                                validateWorkflowGraph(parsed.graph);
+                                workflows.push(parsed);
+                            }
+                        }
+                        catch {
+                            // Ignore invalid JSON files or validation failures during traversal
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore read errors
+            }
+        }
+        await traverse(dir);
+        return workflows;
+    }
+    /**
+     * Asserts schema validity for WorkflowDefinition.
+     */
+    static isValidSchema(obj) {
+        return (obj &&
+            typeof obj.id === "string" &&
+            typeof obj.name === "string" &&
+            typeof obj.description === "string" &&
+            typeof obj.version === "string" &&
+            Array.isArray(obj.supportedArchitectures) &&
+            Array.isArray(obj.requiredRoles) &&
+            obj.graph &&
+            Array.isArray(obj.graph.nodes) &&
+            Array.isArray(obj.graph.edges));
+    }
+    /**
+     * Validates a workflow definition schema and graph.
+     */
+    static validate(wf) {
+        if (!WorkflowRegistry.isValidSchema(wf)) {
+            throw new Error("Workflow schema is invalid. Missing required fields: 'id', 'name', 'version', 'supportedArchitectures', 'requiredRoles', or 'graph'.");
+        }
+        // Check graph validity
+        validateWorkflowGraph(wf.graph);
+    }
+    /**
+     * Loads a specific workflow by ID.
+     */
+    static async load(id, dir) {
+        const list = await WorkflowRegistry.discover(dir);
+        const matched = list.find((w) => w.id === id);
+        if (!matched) {
+            throw new Error(`Workflow Pack '${id}' not found under directory '${dir}'.`);
+        }
+        return matched;
+    }
+}
+/**
+ * Registry for discovery, validation, and loading of agent role profiles.
+ */
+export class RoleRegistry {
+    /**
+     * Scans a directory recursively for role JSON files.
+     */
+    static async discover(dir) {
+        const roles = [];
+        async function traverse(currentDir) {
+            try {
+                const entries = await fs.readdir(currentDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(currentDir, entry.name);
+                    if (entry.isDirectory()) {
+                        if (entry.name.startsWith(".") ||
+                            entry.name === "node_modules" ||
+                            entry.name === "dist" ||
+                            entry.name === "build") {
+                            continue;
+                        }
+                        await traverse(fullPath);
+                    }
+                    else if (entry.isFile() && entry.name.endsWith(".json")) {
+                        try {
+                            const content = await fs.readFile(fullPath, "utf8");
+                            const parsed = JSON.parse(content);
+                            if (RoleRegistry.isValidSchema(parsed)) {
+                                roles.push(parsed);
+                            }
+                        }
+                        catch {
+                            // Ignore invalid files
+                        }
+                    }
+                }
+            }
+            catch {
+                // Ignore read errors
+            }
+        }
+        await traverse(dir);
+        return roles;
+    }
+    /**
+     * Asserts schema validity for AgentRoleDefinition.
+     */
+    static isValidSchema(obj) {
+        return (obj &&
+            typeof obj.id === "string" &&
+            typeof obj.name === "string" &&
+            typeof obj.description === "string" &&
+            Array.isArray(obj.responsibilities) &&
+            Array.isArray(obj.requiredInputs) &&
+            Array.isArray(obj.expectedOutputs) &&
+            Array.isArray(obj.validationChecklist) &&
+            Array.isArray(obj.reviewChecklist));
+    }
+    /**
+     * Validates a role definition.
+     */
+    static validate(role) {
+        if (!RoleRegistry.isValidSchema(role)) {
+            throw new Error("Agent Role schema is invalid. Missing required fields: 'id', 'name', 'responsibilities', 'requiredInputs', 'expectedOutputs', 'validationChecklist', or 'reviewChecklist'.");
+        }
+    }
+    /**
+     * Loads a specific role by ID.
+     */
+    static async load(id, dir) {
+        const list = await RoleRegistry.discover(dir);
+        const matched = list.find((r) => r.id === id);
+        if (!matched) {
+            throw new Error(`Agent Role '${id}' not found under directory '${dir}'.`);
+        }
+        return matched;
+    }
+}
+export class PluginRegistryImpl {
+    analyzers = [];
+    profiles = new Map();
+    roles = new Map();
+    executors = new Map();
+    registerAnalyzer(analyzer) {
+        this.analyzers.push(analyzer);
+    }
+    registerArchitectureProfile(profile) {
+        this.profiles.set(profile.name, profile);
+    }
+    registerAgentRole(role) {
+        this.roles.set(role.id, role);
+    }
+    registerExecutor(name, executeFn) {
+        this.executors.set(name, executeFn);
+    }
+}
+export const pluginRegistry = new PluginRegistryImpl();
+let pluginsLoaded = false;
+export async function loadAWOSPlugins(workspaceRoot) {
+    if (pluginsLoaded) {
+        return pluginRegistry;
+    }
+    const config = await loadConfig(workspaceRoot);
+    if (config.plugins && config.plugins.length > 0) {
+        for (const pluginSpec of config.plugins) {
+            try {
+                let importPath = pluginSpec;
+                if (pluginSpec.startsWith(".") || pluginSpec.startsWith("/") || pluginSpec.includes("\\")) {
+                    importPath = path.resolve(workspaceRoot, pluginSpec);
+                }
+                const module = await import(importPath);
+                const PluginClass = module.default || module.Plugin || module;
+                const pluginInstance = typeof PluginClass === "function" ? new PluginClass() : PluginClass;
+                if (pluginInstance && typeof pluginInstance.register === "function") {
+                    pluginInstance.register(pluginRegistry);
+                    console.log(`[AWOS Registry] Registered plugin: ${pluginInstance.manifest?.id || pluginSpec}`);
+                }
+            }
+            catch (err) {
+                console.warn(`[AWOS Registry] Failed to load plugin '${pluginSpec}':`, err);
+            }
+        }
+    }
+    pluginsLoaded = true;
+    return pluginRegistry;
+}
+export function clearPluginsCache() {
+    pluginsLoaded = false;
+    pluginRegistry.analyzers = [];
+    pluginRegistry.profiles.clear();
+    pluginRegistry.roles.clear();
+    pluginRegistry.executors.clear();
+}