agent-workflow-kit-cli 1.2.0 → 1.3.0

package/dist/core/awos/intelligence.js

@@ -0,0 +1,235 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import { promises as fs } from "fs";
+import path from "path";
+import crypto from "crypto";
+import { detectProjectModules } from "../detector.js";
+import { parseImports } from "../parser.js";
+import { loadAWOSPlugins } from "./registry.js";
+const CACHE_DIR = ".agents/cache";
+const CACHE_FILE = path.join(CACHE_DIR, "repo_context.json");
+/**
+ * Calculates a composite MD5/SHA256 hash of all configuration manifest files in the repository.
+ */
+export async function calculateManifestHash(workspaceRoot) {
+    const manifests = [
+        "package.json",
+        "package-lock.json",
+        "pom.xml",
+        "build.gradle",
+        "build.gradle.kts",
+        "pyproject.toml",
+        "requirements.txt",
+        "Pipfile",
+        "tsconfig.json",
+    ];
+    const hash = crypto.createHash("sha256");
+    let foundAny = false;
+    for (const file of manifests) {
+        const fullPath = path.join(workspaceRoot, file);
+        try {
+            const stat = await fs.stat(fullPath);
+            if (stat.isFile()) {
+                const content = await fs.readFile(fullPath);
+                hash.update(file);
+                hash.update(content);
+                foundAny = true;
+            }
+        }
+        catch {
+            // Ignore missing manifest files
+        }
+    }
+    // Also include directory structure hash of sub-modules
+    try {
+        const submodules = await detectProjectModules(workspaceRoot);
+        for (const sub of submodules) {
+            hash.update(sub.name);
+            hash.update(sub.stacks.join(","));
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return foundAny ? hash.digest("hex") : "no-manifests-hash";
+}
+/**
+ * Parses files in a directory to identify imports and build a dependency relationship between directories.
+ */
+async function analyzeImportGraph(workspaceRoot, modules) {
+    const dependencies = {};
+    for (const mod of modules) {
+        dependencies[mod] = new Set();
+    }
+    // Helper to find files recursively
+    async function scanDir(dir, currentModule) {
+        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 scanDir(fullPath, currentModule);
+                }
+                else if (entry.isFile() && /\.(ts|tsx|java|py)$/.test(entry.name)) {
+                    const content = await fs.readFile(fullPath, "utf8");
+                    const parsedImports = await parseImports(fullPath, content);
+                    for (const importedRef of parsedImports) {
+                        for (const mod of modules) {
+                            if (mod !== currentModule &&
+                                (importedRef.includes(`/${mod}`) || importedRef.includes(`.${mod}`))) {
+                                dependencies[currentModule].add(mod);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore read errors
+        }
+    }
+    for (const mod of modules) {
+        const modulePath = path.join(workspaceRoot, mod);
+        await scanDir(modulePath, mod);
+    }
+    // Convert Sets to arrays
+    const result = {};
+    for (const [key, val] of Object.entries(dependencies)) {
+        result[key] = Array.from(val);
+    }
+    return result;
+}
+/**
+ * Builds a complete RepositoryContext for the given directory.
+ */
+export async function buildRepositoryContext(workspaceRoot) {
+    const manifestHash = await calculateManifestHash(workspaceRoot);
+    // 1. Detect modules
+    const detectedModules = await detectProjectModules(workspaceRoot);
+    const moduleNames = detectedModules.map((m) => m.name === "." ? "root" : m.name);
+    // Analyze import boundaries
+    const importGraph = await analyzeImportGraph(workspaceRoot, detectedModules.map((m) => m.name));
+    const moduleBoundaries = detectedModules.map((m) => {
+        const name = m.name === "." ? "root" : m.name;
+        const dependencies = importGraph[m.name] || [];
+        return {
+            name,
+            path: m.dir,
+            dependencies,
+        };
+    });
+    // Determine main stack & architecture
+    let mainStack = "custom";
+    const stackCounts = {};
+    for (const m of detectedModules) {
+        for (const s of m.stacks) {
+            stackCounts[s] = (stackCounts[s] || 0) + 1;
+        }
+    }
+    const sortedStacks = Object.entries(stackCounts).sort((a, b) => b[1] - a[1]);
+    if (sortedStacks.length > 0) {
+        mainStack = sortedStacks[0][0];
+    }
+    // Determine default architecture style based on stack
+    let architecture = "layered";
+    if (mainStack === "spring-boot") {
+        architecture = "clean-architecture";
+    }
+    else if (mainStack === "react-ts") {
+        architecture = "feature-first";
+    }
+    else if (mainStack === "fastapi") {
+        architecture = "vertical-slice";
+    }
+    // Testing strategy defaults
+    const frameworks = [];
+    if (mainStack === "react-ts")
+        frameworks.push("vitest", "testing-library");
+    else if (mainStack === "spring-boot")
+        frameworks.push("junit", "mockito");
+    else if (mainStack === "fastapi")
+        frameworks.push("pytest");
+    const testing = {
+        frameworks,
+        coverageGoal: 80,
+    };
+    // Validation libraries defaults
+    const validationLibraries = [];
+    if (mainStack === "spring-boot") {
+        validationLibraries.push("jakarta.validation");
+    }
+    else if (mainStack === "react-ts") {
+        validationLibraries.push("zod");
+    }
+    else if (mainStack === "fastapi") {
+        validationLibraries.push("pydantic");
+    }
+    const registry = await loadAWOSPlugins(workspaceRoot);
+    let context = {
+        stack: mainStack,
+        architecture,
+        modules: moduleBoundaries,
+        testing,
+        validation: {
+            libraries: validationLibraries,
+        },
+        hash: manifestHash,
+    };
+    for (const analyzer of registry.analyzers) {
+        try {
+            const partial = await analyzer.detect(workspaceRoot);
+            context = {
+                ...context,
+                ...partial,
+                testing: {
+                    ...context.testing,
+                    ...(partial.testing || {}),
+                },
+                validation: {
+                    ...context.validation,
+                    ...(partial.validation || {}),
+                },
+            };
+        }
+        catch (err) {
+            console.warn(`[AWOS Intelligence] Custom analyzer failed:`, err);
+        }
+    }
+    return context;
+}
+/**
+ * Loads the RepositoryContext, using cached results if valid.
+ */
+export async function getRepositoryContext(workspaceRoot) {
+    const currentHash = await calculateManifestHash(workspaceRoot);
+    const fullCachePath = path.join(workspaceRoot, CACHE_FILE);
+    try {
+        const cacheContent = await fs.readFile(fullCachePath, "utf8");
+        const cachedCtx = JSON.parse(cacheContent);
+        if (cachedCtx.hash === currentHash) {
+            return cachedCtx;
+        }
+    }
+    catch {
+        // Cache miss or read failure
+    }
+    // Re-build and write to cache
+    const context = await buildRepositoryContext(workspaceRoot);
+    try {
+        await fs.mkdir(path.dirname(fullCachePath), { recursive: true });
+        await fs.writeFile(fullCachePath, JSON.stringify(context, null, 2), "utf8");
+    }
+    catch {
+        // Non-blocking cache write failure
+    }
+    return context;
+}

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;
+}