@fitchmultz/pi-subagents 0.49.1 → 0.51.0

package/dist/agents/management-warnings.js

@@ -1,81 +0,0 @@
-import { isClaudeCodeModel } from "../runs/shared/claude-code.js";
-import { discoverAgentsAll } from "./agents.js";
-import { discoverAvailableSkills } from "./skills.js";
-import { allAgents, discoveryOptions } from "./management-targets.js";
-export function unknownChainAgents(ctx, steps) {
-    const known = new Set(allAgents(discoverAgentsAll(ctx.cwd, discoveryOptions(ctx))).map((agent) => agent.name));
-    return [
-        ...new Set(steps
-            .map((step) => step.agent)
-            .filter((agent) => typeof agent === "string" && !known.has(agent))),
-    ].sort((a, b) => a.localeCompare(b));
-}
-function modelWarning(ctx, model) {
-    if (model === undefined || model.length === 0 || isClaudeCodeModel(model)) {
-        return undefined;
-    }
-    const found = ctx.modelRegistry
-        .getAvailable()
-        .some((entry) => `${entry.provider}/${entry.id}` === model || entry.id === model);
-    return found ? undefined : `Warning: model '${model}' is not in the current model registry.`;
-}
-function fallbackModelsWarning(ctx, models) {
-    if (models === undefined || models.length === 0) {
-        return undefined;
-    }
-    const available = new Set(ctx.modelRegistry
-        .getAvailable()
-        .flatMap((model) => [`${model.provider}/${model.id}`, model.id]));
-    const missing = models.filter((model) => !isClaudeCodeModel(model) && !available.has(model));
-    return missing.length > 0
-        ? `Warning: fallback models not in the current model registry: ${missing.join(", ")}.`
-        : undefined;
-}
-function skillsWarning(ctx, skills) {
-    if (skills === undefined || skills.length === 0) {
-        return undefined;
-    }
-    const available = new Set(discoverAvailableSkills(ctx.cwd, discoveryOptions(ctx)).map((skill) => skill.name));
-    const missing = skills.filter((skill) => !available.has(skill));
-    return missing.length > 0 ? `Warning: skills not found: ${missing.join(", ")}.` : undefined;
-}
-export function agentWarnings(ctx, agent, fields) {
-    const warnings = [
-        Object.hasOwn(fields, "model") ? modelWarning(ctx, agent.model) : undefined,
-        Object.hasOwn(fields, "fallbackModels")
-            ? fallbackModelsWarning(ctx, agent.fallbackModels)
-            : undefined,
-        Object.hasOwn(fields, "skills") ? skillsWarning(ctx, agent.skills) : undefined,
-    ];
-    return warnings.filter((warning) => warning !== undefined && warning.length > 0);
-}
-export function chainStepWarnings(ctx, steps) {
-    const warnings = [];
-    const available = new Set(discoverAvailableSkills(ctx.cwd, discoveryOptions(ctx)).map((skill) => skill.name));
-    for (const [index, step] of steps.entries()) {
-        if (modelWarning(ctx, step.model) !== undefined) {
-            warnings.push(`Warning: step ${index + 1} (${step.agent ?? "undefined"}): model '${step.model ?? "undefined"}' is not in the current model registry.`);
-        }
-        if (step.skills !== undefined && step.skills !== false && step.skills.length > 0) {
-            const missing = step.skills.filter((skill) => !available.has(skill));
-            if (missing.length > 0) {
-                warnings.push(`Warning: step ${index + 1} (${step.agent ?? "undefined"}): skills not found: ${missing.join(", ")}.`);
-            }
-        }
-    }
-    return warnings;
-}
-export function chainWarnings(ctx, steps) {
-    const missing = unknownChainAgents(ctx, steps);
-    return [
-        ...(missing.length > 0
-            ? [`Warning: chain steps reference unknown agents: ${missing.join(", ")}.`]
-            : []),
-        ...chainStepWarnings(ctx, steps),
-    ];
-}
-export function referencingChains(ctx, name) {
-    return discoverAgentsAll(ctx.cwd, discoveryOptions(ctx))
-        .chains.filter((chain) => chain.steps.some((step) => step.agent === name))
-        .map((chain) => `${chain.name} (${chain.source})`);
-}

package/dist/agents/markdown-chain.js

@@ -1,210 +0,0 @@
-import { parseFrontmatter } from "./frontmatter.js";
-import { buildRuntimeName, frontmatterNameForConfig, parsePackageName } from "./identity.js";
-import { csvItems } from "./config-values.js";
-function outputMode(value, agent) {
-    if (value !== "inline" && value !== "file-only") {
-        throw new Error(`Invalid outputMode '${value}' for step '${agent}'.`);
-    }
-    return value;
-}
-function progress(value, agent) {
-    if (value !== "true" && value !== "false") {
-        throw new Error(`Invalid progress '${value}' for step '${agent}'; use true or false.`);
-    }
-    return value === "true";
-}
-function outputSchema(value) {
-    if (value.startsWith("{") || value.startsWith("[")) {
-        throw new Error("Inline outputSchema values are not supported in .chain.md files; use a schema file path.");
-    }
-    return value.length === 0 ? {} : { outputSchema: value };
-}
-function listValue(value) {
-    if (value === "false") {
-        return false;
-    }
-    const items = csvItems(value);
-    return items.length > 0 ? items : false;
-}
-function outputValue(value) {
-    if (value === "false") {
-        return { output: false };
-    }
-    return value.length > 0 ? { output: value } : {};
-}
-function metadata(key, value, agent) {
-    switch (key) {
-        case "output":
-            return outputValue(value);
-        case "phase":
-            return value.length > 0 ? { phase: value } : {};
-        case "label":
-            return value.length > 0 ? { label: value } : {};
-        case "as":
-            return value.length > 0 ? { as: value } : {};
-        case "model":
-            return value.length > 0 ? { model: value } : {};
-        case "outputschema":
-            return outputSchema(value);
-        case "outputmode":
-            return { outputMode: outputMode(value, agent) };
-        case "reads":
-            return { reads: listValue(value) };
-        case "skills":
-            return { skills: listValue(value) };
-        case "progress":
-            return { progress: progress(value, agent) };
-        default:
-            return null;
-    }
-}
-function encodedTask(raw, agent, previous) {
-    if (previous !== undefined) {
-        throw new Error(`Duplicate task-json for step '${agent}'.`);
-    }
-    const value = JSON.parse(raw);
-    if (typeof value !== "string") {
-        throw new Error(`task-json for step '${agent}' must be a JSON string.`);
-    }
-    return value;
-}
-function parseStepHeaderLines(lines, agent) {
-    const leading = [];
-    const patch = {};
-    let taskJson;
-    for (const line of lines) {
-        const match = line.match(/^([\w-]+):\s*(.*)$/);
-        if (match === null) {
-            leading.push(line);
-            continue;
-        }
-        const key = (match.at(1) ?? "").trim().toLowerCase();
-        const value = (match.at(2) ?? "").trim();
-        if (key === "task-json") {
-            taskJson = encodedTask(value, agent, taskJson);
-            continue;
-        }
-        const field = metadata(key, value, agent);
-        if (field === null) {
-            leading.push(line);
-        }
-        else {
-            Object.assign(patch, field);
-        }
-    }
-    return { patch, leading, taskJson };
-}
-function parseStepBody(agent, body) {
-    const lines = body.split("\n");
-    const blankIndex = lines.findIndex((line) => line.trim() === "");
-    const configLines = blankIndex === -1 ? lines : lines.slice(0, blankIndex);
-    const proseLines = blankIndex === -1 ? [] : lines.slice(blankIndex + 1);
-    const { patch, leading, taskJson } = parseStepHeaderLines(configLines, agent);
-    const prose = [...leading, ...proseLines].join("\n").trim();
-    if (taskJson !== undefined && prose.length > 0) {
-        throw new Error(`Step '${agent}' cannot combine task-json with task prose.`);
-    }
-    return { agent, ...patch, task: taskJson ?? prose };
-}
-function markdownSteps(body) {
-    const matches = [...body.matchAll(/^##\s+(.+)[^\S\n]*$/gm)];
-    return matches.map((match, index) => {
-        const agent = (match.at(1) ?? "").trim();
-        const end = match.index + match[0].length;
-        const start = end + (body[end] === "\n" ? 1 : 0);
-        return parseStepBody(agent, body.slice(start, matches.at(index + 1)?.index ?? body.length).trimEnd());
-    });
-}
-function chainExtraFields(frontmatter) {
-    const extraFields = {};
-    for (const [key, value] of Object.entries(frontmatter)) {
-        if (key !== "name" && key !== "package" && key !== "description" && value !== undefined) {
-            extraFields[key] = value;
-        }
-    }
-    return Object.keys(extraFields).length > 0 ? extraFields : undefined;
-}
-export function parseChain(content, source, filePath) {
-    const { frontmatter, body } = parseFrontmatter(content);
-    const name = frontmatter.name;
-    const description = frontmatter.description;
-    if (name === undefined ||
-        name.length === 0 ||
-        description === undefined ||
-        description.length === 0) {
-        throw new Error("Chain frontmatter must include name and description");
-    }
-    const steps = markdownSteps(body);
-    if (steps.length === 0) {
-        throw new Error("Chain must include at least one ## agent step.");
-    }
-    const parsedPackage = parsePackageName(frontmatter.package, `Chain '${name}' package`);
-    if (parsedPackage.error !== undefined) {
-        throw new Error(parsedPackage.error);
-    }
-    return {
-        name: buildRuntimeName(name, parsedPackage.packageName),
-        localName: name,
-        packageName: parsedPackage.packageName,
-        description,
-        source,
-        filePath,
-        steps,
-        extraFields: chainExtraFields(frontmatter),
-    };
-}
-function stringLine(field, value) {
-    return value !== undefined && value.length > 0 ? [`${field}: ${value}`] : [];
-}
-function listLine(field, value) {
-    if (value === false) {
-        return [`${field}: false`];
-    }
-    return value !== undefined && value.length > 0 ? [`${field}: ${value.join(", ")}`] : [];
-}
-function stepOutputLines(step) {
-    return [
-        ...(step.output === false ? ["output: false"] : stringLine("output", step.output)),
-        ...stringLine("phase", step.phase),
-        ...stringLine("label", step.label),
-        ...stringLine("as", step.as),
-        ...(step.outputSchema === undefined
-            ? []
-            : stringLine("outputSchema", typeof step.outputSchema === "string"
-                ? step.outputSchema
-                : Object.prototype.toString.call(step.outputSchema))),
-        ...stringLine("outputMode", step.outputMode),
-        ...listLine("reads", step.reads),
-        ...stringLine("model", step.model),
-        ...listLine("skills", step.skills),
-        ...(step.progress === undefined ? [] : [`progress: ${step.progress ? "true" : "false"}`]),
-    ];
-}
-function taskLines(task) {
-    if (!/^##\s+/m.test(task)) {
-        return ["", task];
-    }
-    // Preserve separators verbatim inside encoded prose, not as Markdown headers.
-    const encoded = JSON.stringify(task)
-        .replace(/\u2028/g, "\\u2028")
-        .replace(/\u2029/g, "\\u2029");
-    return [`task-json: ${encoded}`];
-}
-export function serializeChain(config) {
-    const lines = [
-        "---",
-        `name: ${frontmatterNameForConfig(config)}`,
-        ...stringLine("package", config.packageName),
-        `description: ${config.description}`,
-        ...Object.entries(config.extraFields ?? {}).map(([key, value]) => `${key}: ${value}`),
-        "---",
-        "",
-    ];
-    for (const [index, step] of config.steps.entries()) {
-        lines.push(`## ${step.agent ?? "undefined"}`, ...stepOutputLines(step), ...taskLines(step.task ?? ""));
-        if (index < config.steps.length - 1) {
-            lines.push("");
-        }
-    }
-    return `${lines.join("\n")}\n`;
-}

package/dist/agents/package-agents.js

@@ -1,154 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { DefaultPackageManager, SettingsManager } from "@earendil-works/pi-coding-agent";
-import { getAgentDir } from "../shared/agent-dir.js";
-import { readSettingsFileStrict, isConfigObject } from "./config-values.js";
-import { findNearestProjectRoot, pathIsInside, isDirectory, } from "./discovery-paths.js";
-import { clearAgentDiagnosticsForDirs, loadAgentsFromDir } from "./agent-definition.js";
-let lastPackageManager;
-function packageManagerFor(cwd, scope, options) {
-    const projectRoot = findNearestProjectRoot(cwd) ?? cwd;
-    const agentDir = getAgentDir();
-    const projectTrusted = options.projectTrusted !== false;
-    const settings = {
-        global: scope === "project"
-            ? undefined
-            : JSON.stringify(readSettingsFileStrict(path.join(agentDir, "settings.json"))),
-        project: scope === "user" || !projectTrusted
-            ? undefined
-            : JSON.stringify(readSettingsFileStrict(path.join(projectRoot, ".pi", "settings.json"))),
-    };
-    const key = JSON.stringify([agentDir, projectRoot, scope, projectTrusted, settings]);
-    if (lastPackageManager?.key !== key) {
-        const settingsManager = SettingsManager.fromStorage({
-            withLock(settingsScope, read) {
-                read(settings[settingsScope]);
-            },
-        }, { projectTrusted });
-        const error = settingsManager.drainErrors().at(0);
-        if (error !== undefined) {
-            throw error.error;
-        }
-        lastPackageManager = {
-            key,
-            manager: new DefaultPackageManager({ cwd: projectRoot, agentDir, settingsManager }),
-            settingsManager,
-        };
-    }
-    return { ...lastPackageManager, projectRoot, agentDir };
-}
-function isRemotePackage(source) {
-    return source.startsWith("npm:") || /^(?:git:|https?:\/\/|ssh:\/\/)/.test(source.trim());
-}
-function packageKind(configured, userRoot, context) {
-    if (configured.source.startsWith("npm:")) {
-        return "npm";
-    }
-    if (!/^(?:git:|https?:\/\/|ssh:\/\/)/.test(configured.source.trim())) {
-        return "local";
-    }
-    const gitBase = configured.scope === "user"
-        ? path.join(context.agentDir, "git")
-        : path.join(context.projectRoot, ".pi", "git");
-    const managed = (configured.installedPath !== undefined && pathIsInside(gitBase, configured.installedPath)) ||
-        (userRoot !== undefined && pathIsInside(path.join(context.agentDir, "git"), userRoot));
-    return managed ? "git" : "local";
-}
-function packageIdentity(configured, manager, context) {
-    const userRoot = context.scope === "both" && configured.scope === "project" && isRemotePackage(configured.source)
-        ? manager.getInstalledPath(configured.source, "user")
-        : undefined;
-    const kind = packageKind(configured, userRoot, context);
-    // Pi's remote identities ignore refs; unparseable Git-like strings remain local paths.
-    const root = kind === "local" ? configured.installedPath : (userRoot ?? configured.installedPath);
-    return root === undefined || root.length === 0 ? undefined : `${kind}:${fs.realpathSync(root)}`;
-}
-function effectivePackage(identity, settingsManager) {
-    const { user, project } = identity;
-    const declaration = settingsManager
-        .getProjectSettings()
-        .packages?.findLast((pkg) => (typeof pkg === "string" ? pkg : pkg.source) === project?.source);
-    const delta = typeof declaration === "object" && declaration.autoload === false;
-    return delta && user !== undefined ? user : (project ?? user);
-}
-function selectedPackages(manager, settingsManager, context) {
-    const configuredPackages = manager.listConfiguredPackages();
-    const identities = new Map();
-    for (const configured of configuredPackages) {
-        const identity = packageIdentity(configured, manager, context);
-        if (identity === undefined) {
-            continue;
-        }
-        const entries = identities.get(identity) ?? {};
-        if (configured.scope === "project") {
-            entries.project = configured;
-        }
-        else {
-            entries.user ??= configured;
-        }
-        identities.set(identity, entries);
-    }
-    const selected = new Set();
-    for (const identity of identities.values()) {
-        const entry = effectivePackage(identity, settingsManager);
-        if (entry !== undefined) {
-            selected.add(entry);
-        }
-    }
-    return configuredPackages.filter((entry) => selected.has(entry));
-}
-function manifestAgentDirs(root) {
-    const subagents = readSettingsFileStrict(path.join(root, "package.json")).subagents;
-    if (subagents === undefined) {
-        return [];
-    }
-    if (!isConfigObject(subagents) || !Array.isArray(subagents.agents)) {
-        throw new Error(`Package '${root}' subagents.agents must be an array of relative directories.`);
-    }
-    const realRoot = fs.realpathSync(root);
-    return subagents.agents.map((entry) => {
-        if (typeof entry !== "string" ||
-            entry.length === 0 ||
-            path.isAbsolute(entry) ||
-            entry.split(/[\\/]/).includes("..")) {
-            throw new Error(`Package '${root}' subagents.agents must contain relative directories inside the package.`);
-        }
-        const dir = path.resolve(root, entry);
-        const realDir = isDirectory(dir) ? fs.realpathSync(dir) : undefined;
-        if (realDir === undefined || !pathIsInside(realRoot, realDir)) {
-            throw new Error(`Package '${root}' subagents.agents directory is missing or outside the package: ${entry}`);
-        }
-        return dir;
-    });
-}
-function eligiblePackageRoot(configured, scope, options) {
-    if ((scope !== "both" && configured.scope !== scope) ||
-        (configured.scope === "project" && options.projectTrusted === false)) {
-        return undefined;
-    }
-    const root = configured.installedPath;
-    return root !== undefined && root.length > 0 && fs.existsSync(path.join(root, "package.json"))
-        ? root
-        : undefined;
-}
-export function loadConfiguredPackageAgents(cwd, scope, options) {
-    const { manager, settingsManager, agentDir, projectRoot } = packageManagerFor(cwd, scope, options);
-    const selected = selectedPackages(manager, settingsManager, { scope, agentDir, projectRoot });
-    const dirs = [];
-    const seenDirs = new Set();
-    for (const configured of selected) {
-        const root = eligiblePackageRoot(configured, scope, options);
-        if (root === undefined) {
-            continue;
-        }
-        for (const dir of manifestAgentDirs(root)) {
-            const realDir = fs.realpathSync(dir);
-            if (!seenDirs.has(realDir)) {
-                dirs.push(dir);
-            }
-            seenDirs.add(realDir);
-        }
-    }
-    clearAgentDiagnosticsForDirs(dirs);
-    return { dirs, agents: dirs.flatMap((dir) => loadAgentsFromDir(dir, "package")) };
-}

package/dist/agents/skill-files.js

@@ -1,157 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { getGlobalNpmRoot } from "./skill-search-paths.js";
-const skillCache = new Map();
-const MAX_CACHE_SIZE = 50;
-function stripFrontmatter(content) {
-    const normalized = content.replace(/\r\n/g, "\n");
-    if (!normalized.startsWith("---")) {
-        return normalized;
-    }
-    const end = normalized.indexOf("\n---", 3);
-    return end === -1 ? normalized : normalized.slice(end + 4).trim();
-}
-function isWithinPath(filePath, dir) {
-    const relative = path.relative(dir, filePath);
-    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-}
-function inferSource(filePath, cwd, agentDir, hint) {
-    if (hint !== undefined) {
-        return hint;
-    }
-    const roots = [
-        { path: path.resolve(cwd, ".pi", "npm", "node_modules"), source: "project-package" },
-        { path: path.resolve(cwd, ".pi", "skills"), source: "project" },
-        { path: path.resolve(cwd, ".agents"), source: "project" },
-        { path: path.resolve(cwd, ".pi"), source: "project-settings" },
-        { path: path.resolve(agentDir, "npm", "node_modules"), source: "user-package" },
-        { path: path.resolve(agentDir, "skills"), source: "user" },
-        { path: path.resolve(os.homedir(), ".agents"), source: "user" },
-        { path: path.resolve(agentDir), source: "user-settings" },
-    ];
-    const matched = roots.find((root) => isWithinPath(filePath, root.path));
-    if (matched !== undefined) {
-        return matched.source;
-    }
-    const globalRoot = getGlobalNpmRoot();
-    return globalRoot !== null && globalRoot.length > 0 && isWithinPath(filePath, globalRoot)
-        ? "user-package"
-        : "unknown";
-}
-function description(filePath) {
-    try {
-        const normalized = fs.readFileSync(filePath, "utf-8").replace(/\r\n/g, "\n");
-        if (!normalized.startsWith("---")) {
-            return undefined;
-        }
-        const end = normalized.indexOf("\n---", 3);
-        if (end === -1) {
-            return undefined;
-        }
-        return normalized
-            .slice(3, end)
-            .trim()
-            .match(/^description:\s*(.+)$/m)?.[1]
-            ?.trim()
-            .replace(/^['"]|['"]$/g, "");
-    }
-    catch {
-        // Descriptions are optional metadata; failure does not hide an otherwise readable skill.
-        return undefined;
-    }
-}
-function childSkills(dir) {
-    let children;
-    try {
-        children = fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return [];
-    }
-    return children.flatMap((child) => {
-        if (child.name.startsWith(".")) {
-            return [];
-        }
-        const childPath = path.join(dir, child.name);
-        if (child.isDirectory() || child.isSymbolicLink()) {
-            return [{ name: child.name, filePath: path.join(childPath, "SKILL.md") }];
-        }
-        return child.isFile() && child.name.toLowerCase().endsWith(".md")
-            ? [{ name: path.basename(child.name, path.extname(child.name)), filePath: childPath }]
-            : [];
-    });
-}
-function pathSkills(skillPath) {
-    let stat;
-    try {
-        stat = fs.statSync(skillPath);
-    }
-    catch {
-        return [];
-    }
-    if (stat.isFile()) {
-        const fileName = path.basename(skillPath);
-        if (!fileName.toLowerCase().endsWith(".md")) {
-            return [];
-        }
-        const name = fileName.toLowerCase() === "skill.md"
-            ? path.basename(path.dirname(skillPath))
-            : path.basename(fileName, path.extname(fileName));
-        return [{ name, filePath: skillPath }];
-    }
-    return stat.isDirectory()
-        ? [
-            { name: path.basename(skillPath), filePath: path.join(skillPath, "SKILL.md") },
-            ...childSkills(skillPath),
-        ]
-        : [];
-}
-export function collectFilesystemSkills(cwd, agentDir, skillPaths) {
-    const entries = [];
-    const seen = new Set();
-    for (const skillPath of skillPaths) {
-        for (const entry of pathSkills(skillPath.path)) {
-            const filePath = path.resolve(entry.filePath);
-            if (seen.has(filePath) || !fs.existsSync(filePath)) {
-                continue;
-            }
-            seen.add(filePath);
-            entries.push({
-                name: entry.name,
-                filePath,
-                source: inferSource(filePath, cwd, agentDir, skillPath.source),
-                description: description(filePath),
-                order: entries.length,
-            });
-        }
-    }
-    return entries;
-}
-export function readSkill(skillName, skillPath, source) {
-    try {
-        const stat = fs.statSync(skillPath);
-        const cached = skillCache.get(skillPath);
-        if (cached !== undefined && cached.mtime === stat.mtimeMs) {
-            return cached.skill;
-        }
-        const skill = {
-            name: skillName,
-            path: skillPath,
-            content: stripFrontmatter(fs.readFileSync(skillPath, "utf-8")),
-            source,
-        };
-        skillCache.set(skillPath, { mtime: stat.mtimeMs, skill });
-        if (skillCache.size > MAX_CACHE_SIZE) {
-            const firstKey = skillCache.keys().next().value;
-            if (firstKey !== undefined && firstKey.length > 0) {
-                skillCache.delete(firstKey);
-            }
-        }
-        return skill;
-    }
-    catch {
-        // Resolution surfaces unreadable files as missing rather than failing the invocation.
-        return undefined;
-    }
-}