@multileaf/ai-workflow 0.1.0 → 0.1.2

package/dist/recommendations.js

@@ -1,8 +1,73 @@
+const local = (resources) => resources;
 const CATALOG = [
+    {
+        id: "brainstorming",
+        provider: "multileaf",
+        rationale: "A project-specific brainstorming flow helps clarify goals and constraints before implementation.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "brainstorming" },
+            { type: "rules", id: "language-policy" },
+            { type: "templates", id: "brainstorm" },
+        ]),
+        matches: (profile) => hasProjectSignals(profile)
+            ? { evidence: projectEvidence(profile), confidence: 0.92 }
+            : undefined,
+    },
+    {
+        id: "requirements-specification",
+        provider: "multileaf",
+        rationale: "The project can use explicit requirements and acceptance criteria before changes are planned.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "requirements-specification" },
+            { type: "agents", id: "requirements-analyst" },
+            { type: "templates", id: "specification" },
+        ]),
+        matches: (profile) => hasProjectSignals(profile)
+            ? { evidence: projectEvidence(profile), confidence: 0.9 }
+            : undefined,
+    },
+    {
+        id: "implementation-planning",
+        provider: "multileaf",
+        rationale: "A traceable implementation plan can connect project requirements, tests, risks, and validation.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "implementation-planning" },
+            { type: "agents", id: "technical-architect" },
+            { type: "templates", id: "implementation-plan" },
+        ]),
+        matches: (profile) => hasProjectSignals(profile)
+            ? { evidence: projectEvidence(profile), confidence: 0.88 }
+            : undefined,
+    },
+    {
+        id: "code-review",
+        provider: "multileaf",
+        rationale: "A consistent review checklist helps validate changes against this repository's conventions.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "code-review" },
+            { type: "agents", id: "quality-reviewer" },
+        ]),
+        matches: (profile) => profile.runtime.languages.length
+            ? { evidence: projectEvidence(profile), confidence: 0.86 }
+            : undefined,
+    },
     {
         id: "tdd-development",
         provider: "multileaf",
-        rationale: "The project uses automated tests and should preserve test-first development.",
+        rationale: "The project uses automated tests and can apply test-first development with its existing runner.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "tdd-development" },
+            { type: "rules", id: "tdd-policy" },
+            { type: "agents", id: "test-engineer" },
+            { type: "hooks", id: "pre-implementation" },
+            { type: "hooks", id: "post-implementation" },
+            { type: "templates", id: "test-plan" },
+        ]),
         matches: (profile) => profile.testing
             ? { evidence: [`testing:${profile.testing.name}`], confidence: 1 }
             : undefined,
@@ -10,7 +75,12 @@ const CATALOG = [
     {
         id: "typescript-quality",
         provider: "multileaf",
-        rationale: "TypeScript is present and benefits from strict, maintainable code-quality rules.",
+        rationale: "TypeScript is detected; add its specialist and tailor quality guidance to the repository's tools.",
+        permissions: [],
+        resources: local([
+            { type: "agents", id: "typescript-engineer" },
+            { type: "rules", id: "quality-gates" },
+        ]),
         matches: (profile) => profile.runtime.languages.includes("typescript")
             ? { evidence: ["language:typescript"], confidence: 1 }
             : undefined,
@@ -18,7 +88,14 @@ const CATALOG = [
     {
         id: "vitest-testing",
         provider: "multileaf",
-        rationale: "Vitest is configured and can be integrated into the verification workflow.",
+        rationale: "Vitest is configured and can be used by the verification skill and test specialist.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "verification" },
+            { type: "agents", id: "test-engineer" },
+            { type: "templates", id: "test-plan" },
+            { type: "templates", id: "verification-report" },
+        ]),
         matches: (profile) => profile.testing?.name === "vitest"
             ? { evidence: ["testing:vitest"], confidence: 1 }
             : undefined,
@@ -26,7 +103,14 @@ const CATALOG = [
     {
         id: "react-best-practices",
         provider: "vercel-skills",
-        rationale: "React is detected; framework-specific guidance can improve component design and performance.",
+        rationale: "React is detected; framework guidance can improve component design and performance.",
+        permissions: ["network:external"],
+        resources: local([
+            { type: "skills", id: "technical-design" },
+            { type: "agents", id: "technical-architect" },
+            { type: "rules", id: "architecture-policy" },
+            { type: "templates", id: "technical-design" },
+        ]),
         matches: (profile) => profile.frameworks.includes("react")
             ? { evidence: ["framework:react"], confidence: 1 }
             : undefined,
@@ -34,11 +118,34 @@ const CATALOG = [
     {
         id: "nextjs-development",
         provider: "multileaf",
-        rationale: "Next.js is detected; project-specific conventions can guide routing and rendering decisions.",
+        rationale: "Next.js is detected; architecture guidance can follow the project's framework conventions.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "technical-design" },
+            { type: "agents", id: "technical-architect" },
+            { type: "rules", id: "architecture-policy" },
+            { type: "templates", id: "technical-design" },
+        ]),
         matches: (profile) => profile.frameworks.includes("nextjs")
             ? { evidence: ["framework:nextjs"], confidence: 1 }
             : undefined,
     },
+    {
+        id: "security-review",
+        provider: "multileaf",
+        rationale: "The detected stack and package tooling benefit from project-aware security and dependency review.",
+        permissions: [],
+        resources: local([
+            { type: "skills", id: "security-review" },
+            { type: "rules", id: "security-policy" },
+            { type: "rules", id: "dependency-policy" },
+            { type: "agents", id: "security-reviewer" },
+            { type: "templates", id: "security-review" },
+        ]),
+        matches: (profile) => hasProjectSignals(profile)
+            ? { evidence: projectEvidence(profile), confidence: 0.83 }
+            : undefined,
+    },
 ];
 export function recommendCapabilities(profile) {
     return CATALOG.flatMap((capability) => {
@@ -46,18 +153,42 @@ export function recommendCapabilities(profile) {
         return match
             ? [
                 {
-                    id: capability.id,
-                    provider: capability.provider,
+                    ...capability,
                     confidence: match.confidence,
-                    rationale: capability.rationale,
                     evidence: match.evidence,
-                    permissions: capability.permissions ?? [],
                     conflicts: [],
                 },
             ]
             : [];
     });
 }
+export function resourcesForCapabilities(ids) {
+    const selected = new Set(ids);
+    const resources = CATALOG.filter(({ id }) => selected.has(id)).flatMap(({ resources }) => resources);
+    return [
+        ...new Map(resources.map((resource) => [`${resource.type}/${resource.id}`, resource])).values(),
+    ];
+}
 export function serializeRecommendations(items, selected = []) {
-    return `schema: 1\nrecommendations:\n${items.map((item) => `  - id: ${item.id}\n    provider: ${item.provider}\n    confidence: ${item.confidence}\n    selected: ${selected.includes(item.id)}\n    evidence: [${item.evidence.map((evidence) => `"${evidence}"`).join(", ")}]\n    rationale: ${item.rationale}`).join("\n")}\n`;
+    return `schema: 1\nrecommendations:\n${items
+        .map((item) => `  - id: ${item.id}\n    provider: ${item.provider}\n    confidence: ${item.confidence}\n    selected: ${selected.includes(item.id)}\n    resources: [${item.resources.map(({ type, id }) => `${type}/${id}`).join(", ")}]\n    evidence: [${item.evidence.map((evidence) => `"${evidence}"`).join(", ")}]\n    rationale: ${item.rationale}`)
+        .join("\n")}\n`;
+}
+function hasProjectSignals(profile) {
+    return Boolean(profile.runtime.languages.length ||
+        profile.frameworks.length ||
+        profile.packageManager !== "unknown" ||
+        profile.testing ||
+        profile.quality.linter ||
+        profile.ci.length);
+}
+function projectEvidence(profile) {
+    return [
+        ...profile.runtime.languages.map((language) => `language:${language}`),
+        ...profile.frameworks.map((framework) => `framework:${framework}`),
+        ...(profile.packageManager === "unknown" ? [] : [`package-manager:${profile.packageManager}`]),
+        ...(profile.testing ? [`testing:${profile.testing.name}`] : []),
+        ...(profile.quality.linter ? [`linter:${profile.quality.linter.name}`] : []),
+        ...(profile.ci.length ? profile.ci.map((system) => `ci:${system}`) : []),
+    ];
 }

package/dist/scanner.js

@@ -1,3 +1,4 @@
+import ignore from "ignore";
 import { lstat, readFile, readdir } from "node:fs/promises";
 import { basename, relative, resolve } from "node:path";
 const DEFAULT_IGNORES = new Set([
@@ -11,48 +12,49 @@ const DEFAULT_IGNORES = new Set([
     "coverage",
 ]);
 const SENSITIVE_NAMES = /^(\.env(?:\..*)?|.*\.(pem|key|p12|pfx|secret))$/i;
-function matchesIgnore(path, patterns) {
-    const name = basename(path);
-    return patterns.some((pattern) => {
-        const normalized = pattern.replace(/^\//, "").replace(/\/$/, "");
-        if (normalized.includes("*")) {
-            const expression = new RegExp(`^${normalized.split("*").map(escapeRegExp).join(".*")}$`);
-            return expression.test(path) || expression.test(name);
-        }
-        return path === normalized || path.startsWith(`${normalized}/`) || name === normalized;
-    });
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function isIgnoredByProjectRules(absolute, isDirectory, scopes) {
+    let ignored = false;
+    for (const scope of scopes) {
+        const scopedPath = relative(scope.root, absolute).split("\\").join("/");
+        if (!scopedPath || scopedPath === ".." || scopedPath.startsWith("../"))
+            continue;
+        const result = scope.matcher.test(isDirectory ? `${scopedPath}/` : scopedPath);
+        if (result.ignored)
+            ignored = true;
+        else if (result.unignored)
+            ignored = false;
+    }
+    return ignored;
 }
-async function ignoredPatterns(root) {
+async function addIgnoreFile(directory, scopes) {
     try {
-        const content = await readFile(resolve(root, ".gitignore"), "utf8");
-        return content
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter((line) => line && !line.startsWith("#"));
+        const content = await readFile(resolve(directory, ".gitignore"), "utf8");
+        return [...scopes, { root: directory, matcher: ignore().add(content) }];
     }
-    catch {
-        return [];
+    catch (error) {
+        if (error.code === "ENOENT")
+            return scopes;
+        throw error;
     }
 }
-async function collect(root, current, patterns, files) {
+async function collect(root, current, inheritedScopes, files) {
+    const scopes = await addIgnoreFile(current, inheritedScopes);
     const entries = await readdir(current, { withFileTypes: true });
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
         const absolute = resolve(current, entry.name);
         const relativePath = relative(root, absolute).split("\\").join("/");
+        const isDirectory = entry.isDirectory();
         if (DEFAULT_IGNORES.has(entry.name) ||
             SENSITIVE_NAMES.test(entry.name) ||
-            matchesIgnore(relativePath, patterns))
+            isIgnoredByProjectRules(absolute, isDirectory, scopes))
             continue;
         if (entry.isSymbolicLink()) {
             const link = await lstat(absolute);
             if (link.isSymbolicLink())
                 continue;
         }
-        if (entry.isDirectory())
-            await collect(root, absolute, patterns, files);
+        if (isDirectory)
+            await collect(root, absolute, scopes, files);
         else if (entry.isFile())
             files.push(relativePath);
     }
@@ -78,6 +80,6 @@ function detectEvidence(files) {
 export async function scanProject(root) {
     const projectRoot = resolve(root);
     const files = [];
-    await collect(projectRoot, projectRoot, await ignoredPatterns(projectRoot), files);
+    await collect(projectRoot, projectRoot, [], files);
     return { files, evidence: detectEvidence(files) };
 }

package/dist/types.d.ts

@@ -11,12 +11,14 @@ export type FileSystem = {
     read(path: string): string;
     readBytes?(path: string): Uint8Array;
     write(path: string, content: string): void;
+    mkdirExclusive?(path: string): boolean;
     createExclusive?(path: string, content: string): boolean;
     writeBytes?(path: string, content: Uint8Array): void;
     mkdir(path: string): void;
     list?(path: string): string[];
     listFiles?(path: string): string[];
     remove?(path: string): void;
+    removeDirectory?(path: string): void;
     pathType?(path: string): PathType;
     realpath?(path: string): string;
 };