@multileaf/ai-workflow 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,22 @@
+export declare const TARGETS: readonly ["codex", "claude", "cursor", "gemini", "copilot", "universal"];
+export type Target = (typeof TARGETS)[number];
+export type CommandResult = {
+    exitCode: number;
+    output?: string;
+    error?: string;
+};
+export type PathType = "missing" | "file" | "directory" | "symlink" | "other";
+export type FileSystem = {
+    exists(path: string): boolean;
+    read(path: string): string;
+    readBytes?(path: string): Uint8Array;
+    write(path: string, content: string): void;
+    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;
+    pathType?(path: string): PathType;
+    realpath?(path: string): string;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export const TARGETS = ["codex", "claude", "cursor", "gemini", "copilot", "universal"];

package/dist/universal-layout.d.ts

@@ -0,0 +1,9 @@
+import type { ResourceType } from "./package-contract.js";
+import type { FileSystem } from "./types.js";
+export type UniversalResourceType = ResourceType | "context";
+export type UniversalResourceDescriptor = {
+    path: string;
+    support: "fallback";
+};
+export declare function describeUniversalResource(type: UniversalResourceType, id: string): UniversalResourceDescriptor;
+export declare function renderUniversalContext(root: string, content: string, fs: FileSystem): string;

package/dist/universal-layout.js

@@ -0,0 +1,21 @@
+import { join } from "node:path";
+const ROOTS = {
+    skills: ".aiw/resources/skills",
+    rules: ".aiw/resources/rules",
+    agents: ".aiw/resources/agents",
+    hooks: ".aiw/resources/hooks",
+    templates: ".aiw/resources/templates",
+    context: ".aiw/resources/context",
+};
+export function describeUniversalResource(type, id) {
+    const root = ROOTS[type];
+    if (!root)
+        throw new Error(`Unsupported universal resource type: ${type}`);
+    const filename = type === "skills" ? "SKILL.md" : `${id}.md`;
+    return { path: `${root}/${id}/${filename}`, support: "fallback" };
+}
+export function renderUniversalContext(root, content, fs) {
+    const path = describeUniversalResource("context", "project").path;
+    fs.write(join(root, path), content);
+    return path;
+}

package/dist/vercel-skills.d.ts

@@ -0,0 +1,17 @@
+export type VercelSkillsCommand = "find" | "inspect" | "add" | "check" | "update";
+export type VercelSkillsRequest = {
+    command: VercelSkillsCommand;
+    source?: string;
+    skill?: string;
+    agent?: string;
+};
+export interface CommandExecutor {
+    execute(command: string[]): Promise<{
+        stdout: string;
+        exitCode: number;
+    }>;
+}
+export declare const nodeCommandExecutor: CommandExecutor;
+export declare function buildVercelSkillsCommand(request: VercelSkillsRequest): string[];
+export declare function executeVercelSkills(executor: CommandExecutor, request: VercelSkillsRequest): Promise<string>;
+export declare function installVercelSkill(executor: CommandExecutor, source: string, skill: string, agent: string): Promise<string>;

package/dist/vercel-skills.js

@@ -0,0 +1,49 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const executeFile = promisify(execFile);
+export const nodeCommandExecutor = {
+    async execute(command) {
+        const [program, ...args] = command;
+        try {
+            const result = await executeFile(program, args, { maxBuffer: 1024 * 1024 });
+            return { stdout: result.stdout, exitCode: 0 };
+        }
+        catch (error) {
+            const failure = error;
+            return { stdout: failure.stdout ?? String(error), exitCode: failure.status ?? 1 };
+        }
+    },
+};
+export function buildVercelSkillsCommand(request) {
+    if (request.command === "find")
+        return ["npx", "skills", "find", request.skill ?? ""];
+    if (request.command === "inspect") {
+        if (!request.source)
+            throw new Error("A source is required to inspect Vercel skills.");
+        return ["npx", "skills", "add", request.source, "--list"];
+    }
+    if (request.command === "add") {
+        if (!request.source)
+            throw new Error("A source is required to add a Vercel skill.");
+        return [
+            "npx",
+            "skills",
+            "add",
+            request.skill ? `${request.source}@${request.skill}` : request.source,
+            ...(request.agent ? ["--agent", request.agent] : []),
+            "--yes",
+        ];
+    }
+    return ["npx", "skills", request.command];
+}
+export async function executeVercelSkills(executor, request) {
+    const result = await executor.execute(buildVercelSkillsCommand(request));
+    if (result.exitCode !== 0)
+        throw new Error(`Vercel Skills ${request.command} failed: ${result.stdout}`);
+    if (/failed to (?:check|update)|failed to update/i.test(result.stdout))
+        throw new Error(`Vercel Skills ${request.command} failed: ${result.stdout}`);
+    return result.stdout;
+}
+export async function installVercelSkill(executor, source, skill, agent) {
+    return executeVercelSkills(executor, { command: "add", source, skill, agent });
+}

package/dist/workflow.d.ts

@@ -0,0 +1,4 @@
+import type { CommandResult, FileSystem } from "./types.js";
+import type { WorkflowDependencies } from "./services.js";
+export type WorkflowServices = WorkflowDependencies;
+export declare function runCommand(args: string[], root: string, fs: FileSystem, services?: WorkflowServices): Promise<CommandResult>;