agent-workflow-kit-cli 1.2.0 → 1.3.0

package/dist/core/parser.js

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * SPDX-License-Identifier: MIT
+ */
+import ts from "typescript";
+import { execa } from "execa";
+function parseTsImports(content) {
+    const sourceFile = ts.createSourceFile("file.ts", content, ts.ScriptTarget.Latest, true);
+    const imports = [];
+    function visit(node) {
+        if (ts.isImportDeclaration(node)) {
+            if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                imports.push(node.moduleSpecifier.text);
+            }
+        }
+        else if (ts.isExportDeclaration(node)) {
+            if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+                imports.push(node.moduleSpecifier.text);
+            }
+        }
+        else if (ts.isCallExpression(node) &&
+            node.expression.kind === ts.SyntaxKind.ImportKeyword &&
+            node.arguments.length > 0) {
+            const arg = node.arguments[0];
+            if (ts.isStringLiteral(arg)) {
+                imports.push(arg.text);
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return imports;
+}
+function fallbackPyImports(content) {
+    const lines = content.split("\n");
+    const imports = [];
+    let inMultiline = false;
+    let multilineQuote = "";
+    for (let line of lines) {
+        line = line.trim();
+        if (!line)
+            continue;
+        if (!inMultiline) {
+            if (line.startsWith('"""')) {
+                inMultiline = true;
+                multilineQuote = '"""';
+                if (line.endsWith('"""') && line.length > 3) {
+                    inMultiline = false;
+                }
+                continue;
+            }
+            if (line.startsWith("'''")) {
+                inMultiline = true;
+                multilineQuote = "'''";
+                if (line.endsWith("'''") && line.length > 3) {
+                    inMultiline = false;
+                }
+                continue;
+            }
+            const hashIdx = line.indexOf("#");
+            if (hashIdx !== -1) {
+                line = line.substring(0, hashIdx).trim();
+            }
+            const importFromMatch = line.match(/^from\s+([a-zA-Z0-9._]+)\s+import/);
+            if (importFromMatch) {
+                imports.push(importFromMatch[1]);
+            }
+            else {
+                const importMatch = line.match(/^import\s+([a-zA-Z0-9._\s,]+)/);
+                if (importMatch) {
+                    const modules = importMatch[1].split(",").map(m => m.trim());
+                    imports.push(...modules);
+                }
+            }
+        }
+        else {
+            if (line.endsWith(multilineQuote)) {
+                inMultiline = false;
+            }
+        }
+    }
+    return imports;
+}
+async function parsePyImports(content) {
+    const pyScript = `
+import ast, sys, json
+try:
+    tree = ast.parse(sys.stdin.read())
+    imports = []
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for name in node.names:
+                imports.append(name.name)
+        elif isinstance(node, ast.ImportFrom):
+            if node.module:
+                imports.append(node.module)
+    print(json.dumps(imports))
+except Exception:
+    sys.exit(1)
+  `.trim();
+    try {
+        const { stdout } = await execa("python", ["-c", pyScript], {
+            input: content,
+            timeout: 2000,
+        });
+        return JSON.parse(stdout);
+    }
+    catch {
+        return fallbackPyImports(content);
+    }
+}
+function parseJavaImports(content) {
+    const cleaned = content.replace(/\/\*[\s\S]*?\*\//g, "");
+    const lines = cleaned.split("\n");
+    const imports = [];
+    for (let line of lines) {
+        line = line.trim();
+        const doubleSlashIdx = line.indexOf("//");
+        if (doubleSlashIdx !== -1) {
+            line = line.substring(0, doubleSlashIdx).trim();
+        }
+        if (line.startsWith("import ")) {
+            const match = line.match(/^import\s+(?:static\s+)?([a-zA-Z0-9._*]+)\s*;/);
+            if (match) {
+                imports.push(match[1]);
+            }
+        }
+    }
+    return imports;
+}
+export async function parseImports(filePath, content) {
+    const ext = filePath.split(".").pop()?.toLowerCase();
+    if (ext === "ts" || ext === "tsx") {
+        return parseTsImports(content);
+    }
+    if (ext === "py") {
+        return parsePyImports(content);
+    }
+    if (ext === "java") {
+        return parseJavaImports(content);
+    }
+    return [];
+}

package/dist/core/renderer.js

@@ -6,6 +6,7 @@ import handlebars from "handlebars";
 import { promises as fs } from "fs";
 import path from "path";
 import { fileURLToPath } from "url";
+import { loadConfig } from "./config.js";
 // Register custom Handlebars helpers
 handlebars.registerHelper("eq", function (a, b) {
     return a === b;
@@ -14,13 +15,30 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // The templates directory is located at '../../templates' relative to 'dist/core/renderer.js'
 const TEMPLATES_DIR = path.resolve(__dirname, "../../templates");
+/**
+ * Resolves the path of a template file, prioritizing the customTemplatesPath if configured.
+ */
+async function resolveTemplatePath(relativePath) {
+    const config = await loadConfig();
+    if (config.customTemplatesPath) {
+        const customFullPath = path.resolve(process.cwd(), config.customTemplatesPath, relativePath);
+        try {
+            await fs.access(customFullPath);
+            return customFullPath;
+        }
+        catch {
+            // Fallback to default
+        }
+    }
+    return path.join(TEMPLATES_DIR, relativePath);
+}
 /**
  * Loads a Handlebars template, compiles it, and renders it with the given context.
  * @param templatePath Relative path to the template inside the templates directory (e.g. 'common/AGENTS.md.hbs')
  * @param context Key-value context data for compilation
  */
 export async function renderTemplate(templatePath, context) {
-    const fullPath = path.join(TEMPLATES_DIR, templatePath);
+    const fullPath = await resolveTemplatePath(templatePath);
     const fileContent = await fs.readFile(fullPath, "utf8");
     const compiled = handlebars.compile(fileContent);
     return compiled(context);
@@ -31,7 +49,7 @@ export async function renderTemplate(templatePath, context) {
  * @param context Optional key-value data for compilation
  */
 export async function readStaticTemplateFile(filePath, context) {
-    const fullPath = path.join(TEMPLATES_DIR, filePath);
+    const fullPath = await resolveTemplatePath(filePath);
     const fileContent = await fs.readFile(fullPath, "utf8");
     if (context) {
         const compiled = handlebars.compile(fileContent);
@@ -43,38 +61,71 @@ export async function readStaticTemplateFile(filePath, context) {
  * Gets all rules files for a stack.
  */
 export async function getStackRules(stack) {
-    const rulesDir = path.join(TEMPLATES_DIR, stack, "rules");
+    const relativeRulesDir = path.join(stack, "rules");
+    const rules = new Set();
+    // Try custom first
+    const config = await loadConfig();
+    if (config.customTemplatesPath) {
+        const customRulesDir = path.resolve(process.cwd(), config.customTemplatesPath, relativeRulesDir);
+        try {
+            const files = await fs.readdir(customRulesDir);
+            for (const f of files) {
+                if (f.endsWith(".md"))
+                    rules.add(f);
+            }
+        }
+        catch {
+            // Ignore
+        }
+    }
+    // Fallback default
+    const defaultRulesDir = path.join(TEMPLATES_DIR, stack, "rules");
     try {
-        const files = await fs.readdir(rulesDir);
-        return files.filter((f) => f.endsWith(".md"));
+        const files = await fs.readdir(defaultRulesDir);
+        for (const f of files) {
+            if (f.endsWith(".md"))
+                rules.add(f);
+        }
     }
     catch {
-        return [];
+        // Ignore
     }
+    return Array.from(rules);
 }
 /**
  * Gets all skills for a stack.
  */
 export async function getStackSkills(stack) {
-    const skillsDir = path.join(TEMPLATES_DIR, stack, "skills");
-    try {
-        const entries = await fs.readdir(skillsDir, { withFileTypes: true });
-        const skills = [];
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                const skillFilePath = path.join(skillsDir, entry.name, "SKILL.md");
-                try {
-                    await fs.access(skillFilePath);
-                    skills.push(`${entry.name}/SKILL.md`);
-                }
-                catch {
-                    // Ignore if SKILL.md doesn't exist
+    const relativeSkillsDir = path.join(stack, "skills");
+    const skills = new Set();
+    const checkDir = async (dirPath) => {
+        try {
+            const entries = await fs.readdir(dirPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const skillFilePath = path.join(dirPath, entry.name, "SKILL.md");
+                    try {
+                        await fs.access(skillFilePath);
+                        skills.add(`${entry.name}/SKILL.md`);
+                    }
+                    catch {
+                        // Ignore
+                    }
                 }
             }
         }
-        return skills;
-    }
-    catch {
-        return [];
+        catch {
+            // Ignore
+        }
+    };
+    // Check custom
+    const config = await loadConfig();
+    if (config.customTemplatesPath) {
+        const customSkillsDir = path.resolve(process.cwd(), config.customTemplatesPath, relativeSkillsDir);
+        await checkDir(customSkillsDir);
     }
+    // Check default
+    const defaultSkillsDir = path.join(TEMPLATES_DIR, stack, "skills");
+    await checkDir(defaultSkillsDir);
+    return Array.from(skills);
 }

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "agent-workflow-kit-cli",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "AI-Ready Repository Workflow Generator & Guideline Optimizer for Codex and Antigravity",
   "type": "module",
   "main": "./dist/index.js",
   "bin": {
-    "agent-workflow-kit": "./dist/index.js"
+    "agent-workflow-kit": "./dist/index.js",
+    "agent-workflow-kit-cli": "./dist/index.js"
   },
   "files": [
     "dist",

package/templates/common/ide-rules.hbs

@@ -0,0 +1,12 @@
+# Agent Workflow Kit - IDE System Instructions
+
+You are an AI assistant ({{#if (eq agent "antigravity")}}Antigravity{{else}}{{#if (eq agent "codex")}}Codex{{else}}Antigravity / Codex{{/if}}{{/if}}) coding inside this repository. You MUST follow these repository standards for every query:
+
+1. Always check for and follow {{#if (eq agent "antigravity")}}[GEMINI.md](file:///GEMINI.md){{else}}{{#if (eq agent "codex")}}[AGENTS.md](file:///AGENTS.md){{else}}[GEMINI.md](file:///GEMINI.md) (if you are Antigravity) or [AGENTS.md](file:///AGENTS.md) (if you are Codex){{/if}}{{/if}} at the workspace root (or current module workspace) before executing any task.
+2. Follow the strict 5-Step Execution Workflow:
+   - Step 1: Research & Context Analysis (scan workspace, read relevant rules in `.agents/rules/` matching the active stack, e.g. `react-style.md` for React. Do not scan irrelevant files).
+   - Step 2: Formulate Implementation Plan (list files to create, modify, or delete).
+   - Step 3: Implementation & Clean Coding (maintain type-safety, styles, and layering).
+   - Step 4: Verification (run validation commands: compile, lint, test, build).
+   - Step 5: Self-Review & QA (review diff, clean logs, summarize edits).
+3. Check and execute custom skills defined inside `.agents/skills/` (like `/spring-feature` or `/react-feature`) by reading their `SKILL.md` instruction file.