@voybio/ace-swarm 0.2.4 → 2.4.0

package/dist/helpers/artifacts.js

@@ -0,0 +1,152 @@
+import { existsSync, readdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { AGENT_FILES, AGENT_MANIFEST_FILES, DEFAULT_AGENT_INSTRUCTION_FILES, DEFAULT_AGENT_MANIFEST_FILES, DEFAULT_KERNEL_FILES, DEFAULTS_SKILLS_ROOT, DEFAULT_TASK_FILES, KERNEL_FILES, STORE_AGENT_FILES, STORE_KERNEL_FILES, STORE_TASK_FILES, TASK_FILES, } from "./constants.js";
+import { acePath, currentWorkspaceRoot, firstExistingPath, readText, resolveWorkspaceWritePath, toAbsoluteWorkspaceCandidates, } from "./path-utils.js";
+import { listStoreSkillReferences, readStoreText } from "./store-resolution.js";
+function shouldPreferWorkspaceTaskFile(key) {
+    return key === "todo" || key === "lessons";
+}
+function readFirstAvailable(paths) {
+    const found = firstExistingPath(paths);
+    if (!found) {
+        return {
+            text: `[FILE NOT FOUND]\nTried:\n${paths.map((p) => `- ${p}`).join("\n")}`,
+            path: undefined,
+        };
+    }
+    return { text: readText(found), path: found };
+}
+export function getAgentInstructionPath(role) {
+    const store = readStoreText(STORE_AGENT_FILES[role].instructions.map((file) => `knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`));
+    if (store)
+        return store.path;
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(AGENT_FILES[role]);
+    return firstExistingPath([...workspaceCandidates, DEFAULT_AGENT_INSTRUCTION_FILES[role]]);
+}
+export function getAgentManifestPath(role) {
+    const store = readStoreText(STORE_AGENT_FILES[role].manifests.map((file) => `knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`));
+    if (store)
+        return store.path;
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(AGENT_MANIFEST_FILES[role]);
+    return firstExistingPath([...workspaceCandidates, DEFAULT_AGENT_MANIFEST_FILES[role]]);
+}
+export function readAgentInstructions(role) {
+    const store = readStoreText(STORE_AGENT_FILES[role].instructions.map((file) => `knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`));
+    if (store)
+        return store.text;
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(AGENT_FILES[role]);
+    return readFirstAvailable([...workspaceCandidates, DEFAULT_AGENT_INSTRUCTION_FILES[role]]).text;
+}
+export function readAgentManifest(role) {
+    const store = readStoreText(STORE_AGENT_FILES[role].manifests.map((file) => `knowledge/agents/${STORE_AGENT_FILES[role].agent}/${file}`));
+    if (store)
+        return store.text;
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(AGENT_MANIFEST_FILES[role]);
+    return readFirstAvailable([...workspaceCandidates, DEFAULT_AGENT_MANIFEST_FILES[role]]).text;
+}
+export function getTaskArtifactPath(key) {
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(TASK_FILES[key]);
+    const workspaceFirst = shouldPreferWorkspaceTaskFile(key);
+    if (workspaceFirst) {
+        const workspace = firstExistingPath(workspaceCandidates);
+        if (workspace)
+            return workspace;
+    }
+    const store = readStoreText([STORE_TASK_FILES[key]]);
+    if (store)
+        return store.path;
+    return firstExistingPath([
+        ...workspaceCandidates,
+        DEFAULT_TASK_FILES[key],
+    ]);
+}
+export function readTaskArtifact(key) {
+    if (shouldPreferWorkspaceTaskFile(key)) {
+        const workspaceCandidates = toAbsoluteWorkspaceCandidates(TASK_FILES[key]);
+        const workspacePath = firstExistingPath(workspaceCandidates);
+        if (workspacePath)
+            return readText(workspacePath);
+    }
+    const store = readStoreText([STORE_TASK_FILES[key]]);
+    if (store)
+        return store.text;
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(TASK_FILES[key]);
+    return readFirstAvailable([...workspaceCandidates, DEFAULT_TASK_FILES[key]]).text;
+}
+export function getKernelArtifactPath(key) {
+    const store = readStoreText(STORE_KERNEL_FILES[key]);
+    if (store)
+        return store.path;
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(KERNEL_FILES[key]);
+    return firstExistingPath([...workspaceCandidates, DEFAULT_KERNEL_FILES[key]]);
+}
+export function readKernelArtifact(key) {
+    const store = readStoreText(STORE_KERNEL_FILES[key]);
+    if (store)
+        return store.text;
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(KERNEL_FILES[key]);
+    return readFirstAvailable([...workspaceCandidates, DEFAULT_KERNEL_FILES[key]]).text;
+}
+export function resolveWritableTaskPath(key) {
+    const workspaceCandidates = toAbsoluteWorkspaceCandidates(TASK_FILES[key]);
+    const existingWorkspacePath = workspaceCandidates.find((candidate) => existsSync(candidate));
+    if (existingWorkspacePath)
+        return existingWorkspacePath;
+    return resolveWorkspaceWritePath(TASK_FILES[key][0]);
+}
+function listSkillDirs() {
+    const root = currentWorkspaceRoot();
+    return [
+        { root: acePath("skills"), source: "workspace" },
+        { root: resolve(root, ".agents", "skills"), source: "workspace" },
+        { root: DEFAULTS_SKILLS_ROOT, source: "package-defaults" },
+    ];
+}
+export function listAvailableSkills() {
+    const dedup = new Map();
+    for (const skill of listStoreSkillReferences()) {
+        dedup.set(skill.name, skill);
+    }
+    for (const { root, source } of listSkillDirs()) {
+        if (!existsSync(root))
+            continue;
+        const entries = readdirSync(root, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const skillName = entry.name;
+            const skillPath = resolve(root, skillName, "SKILL.md");
+            if (!existsSync(skillPath))
+                continue;
+            if (source === "package-defaults" && dedup.has(skillName)) {
+                continue;
+            }
+            dedup.set(skillName, {
+                name: skillName,
+                path: skillPath,
+                source,
+            });
+        }
+    }
+    return [...dedup.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function getSkillPath(name) {
+    const target = name.trim().toLowerCase();
+    const skills = listAvailableSkills();
+    const exact = skills.find((skill) => skill.name.toLowerCase() === target);
+    return exact?.path;
+}
+export function readSkillInstructions(name) {
+    const target = name.trim().toLowerCase();
+    const match = listAvailableSkills().find((skill) => skill.name.toLowerCase() === target);
+    if (!match) {
+        return `Skill not found: ${name}\nAvailable: ${listAvailableSkills()
+            .map((s) => s.name)
+            .join(", ")}`;
+    }
+    if (match.source === "store") {
+        return readStoreText([`knowledge/skills/${match.name}/SKILL.md`])?.text ?? "";
+    }
+    return readText(match.path);
+}
+//# sourceMappingURL=artifacts.js.map

package/dist/helpers/bootstrap.d.ts

@@ -0,0 +1,24 @@
+import { type LlmProvider, type McpClient } from "./constants.js";
+export interface BootstrapOptions {
+    projectName?: string;
+    force?: boolean;
+    includeMcpConfig?: boolean;
+    includeClientConfigBundle?: boolean;
+    llmProvider?: LlmProvider;
+    llmModel?: string;
+    llmBaseUrl?: string;
+    ollamaModel?: string;
+    ollamaBaseUrl?: string;
+    skipStoreManaged?: boolean;
+}
+export interface BootstrapResult {
+    created: string[];
+    updated: string[];
+    skipped: string[];
+}
+export declare function getMcpClientBundlePath(client: McpClient): string;
+export declare function getMcpClientInstallHint(client: McpClient): string;
+export declare function getMcpServerConfigSnippet(client?: McpClient): string;
+export declare function getAllMcpServerConfigSnippets(): Record<McpClient, string>;
+export declare function bootstrapAceWorkspace(options?: BootstrapOptions): BootstrapResult;
+//# sourceMappingURL=bootstrap.d.ts.map