@akira-tl/forgerelay 0.8.8 → 0.8.10

package/dist/workspaces/resources/skills.js

@@ -0,0 +1,283 @@
+import { existsSync, readdirSync, readFileSync, statSync, } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, extname, join, resolve, sep } from "node:path";
+import { parse as parseYaml } from "yaml";
+import { markAdvertisedFileSourceActivated, resolveAdvertisedFileReadPath, } from "../../mcp/filesystem/advertised-files.js";
+import { expandHomePath, isPathInsideRoot } from "../../mcp/filesystem/roots.js";
+const FRONTMATTER_DELIMITER = "---";
+export function effectiveSkillPaths(config, cwd) {
+    const defaultPathCandidates = [
+        join(homedir(), ".agents", "skills"),
+        resolve(cwd, ".agents", "skills"),
+        config.configSkillsDir,
+        join(config.agentDir, "skills"),
+    ];
+    const defaultPaths = defaultPathCandidates.filter((path) => path !== undefined && existsSync(path));
+    const seen = new Set();
+    return [...defaultPaths, ...config.skillPaths]
+        .map((path) => resolveSkillPath(path, cwd))
+        .filter((path) => {
+        if (seen.has(path))
+            return false;
+        seen.add(path);
+        return true;
+    });
+}
+function resolveSkillPath(path, cwd) {
+    return resolve(cwd, expandHomePath(path));
+}
+export function loadWorkspaceSkills(config, cwd) {
+    if (!config.skillsEnabled)
+        return { skills: [], diagnostics: [] };
+    const skills = [];
+    const diagnostics = [];
+    const winners = new Map();
+    for (const sourcePath of effectiveSkillPaths(config, cwd)) {
+        const candidates = discoverSkills(sourcePath, diagnostics);
+        for (const skill of candidates) {
+            const existing = winners.get(skill.name);
+            if (existing) {
+                diagnostics.push({
+                    type: "collision",
+                    message: `Skill '${skill.name}' from ${skill.filePath} was ignored because ${existing.skill.filePath} was loaded first.`,
+                    collision: {
+                        resourceType: "skill",
+                        name: skill.name,
+                        winnerPath: existing.skill.filePath,
+                        loserPath: skill.filePath,
+                        winnerSource: existing.source,
+                        loserSource: sourcePath,
+                    },
+                });
+                continue;
+            }
+            winners.set(skill.name, { skill, source: sourcePath });
+            skills.push(skill);
+        }
+    }
+    if (config.subagents)
+        return { skills, diagnostics };
+    return { skills, diagnostics };
+}
+function discoverSkills(sourcePath, diagnostics) {
+    if (!existsSync(sourcePath))
+        return [];
+    let stats;
+    try {
+        stats = statSync(sourcePath);
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: `Unable to inspect skill path ${sourcePath}: ${errorMessage(error)}`,
+            path: sourcePath,
+        });
+        return [];
+    }
+    if (stats.isFile()) {
+        const skill = loadSkillFile(sourcePath, diagnostics);
+        return skill ? [skill] : [];
+    }
+    if (!stats.isDirectory())
+        return [];
+    const entry = join(sourcePath, "SKILL.md");
+    if (existsSync(entry)) {
+        const skill = loadSkillFile(entry, diagnostics);
+        return skill ? [skill] : [];
+    }
+    const skills = [];
+    for (const entryName of sortedDirectoryEntries(sourcePath, diagnostics)) {
+        const child = join(sourcePath, entryName);
+        let childStats;
+        try {
+            childStats = statSync(child);
+        }
+        catch (error) {
+            diagnostics.push({
+                type: "warning",
+                message: `Unable to inspect skill candidate ${child}: ${errorMessage(error)}`,
+                path: child,
+            });
+            continue;
+        }
+        if (childStats.isDirectory()) {
+            skills.push(...discoverSkills(child, diagnostics));
+            continue;
+        }
+        if (childStats.isFile() && extname(entryName).toLowerCase() === ".md") {
+            const skill = loadSkillFile(child, diagnostics);
+            if (skill)
+                skills.push(skill);
+        }
+    }
+    return skills;
+}
+function sortedDirectoryEntries(path, diagnostics) {
+    try {
+        return readdirSync(path).sort((left, right) => left.localeCompare(right));
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: `Unable to read skill directory ${path}: ${errorMessage(error)}`,
+            path,
+        });
+        return [];
+    }
+}
+function loadSkillFile(filePath, diagnostics) {
+    let content;
+    try {
+        content = readFileSync(filePath, "utf8");
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "warning",
+            message: `Unable to read skill file ${filePath}: ${errorMessage(error)}`,
+            path: filePath,
+        });
+        return undefined;
+    }
+    let frontmatter = {};
+    try {
+        frontmatter = parseSkillFrontmatter(content);
+    }
+    catch (error) {
+        diagnostics.push({
+            type: "error",
+            message: `Invalid skill frontmatter in ${filePath}: ${errorMessage(error)}`,
+            path: filePath,
+        });
+        return undefined;
+    }
+    const baseDir = dirname(filePath);
+    const summary = skillSummaryFromFrontmatter(frontmatter, filePath);
+    if (!summary.name) {
+        diagnostics.push({
+            type: "error",
+            message: `Skill ${filePath} has an invalid or empty name.`,
+            path: filePath,
+        });
+        return undefined;
+    }
+    return {
+        ...summary,
+        filePath: resolve(filePath),
+        baseDir: resolve(baseDir),
+    };
+}
+export function skillSummaryFromContent(content, filePath) {
+    return skillSummaryFromFrontmatter(parseSkillFrontmatter(content), filePath);
+}
+function skillSummaryFromFrontmatter(frontmatter, filePath) {
+    return {
+        name: normalizedSkillName(frontmatter.name, filePath),
+        description: typeof frontmatter.description === "string" ? frontmatter.description.trim() : "",
+        disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+    };
+}
+function parseSkillFrontmatter(content) {
+    const lines = content.replace(/^\uFEFF/, "").split(/\r?\n/);
+    if (lines[0]?.trim() !== FRONTMATTER_DELIMITER)
+        return {};
+    const end = lines.findIndex((line, index) => index > 0 && line.trim() === FRONTMATTER_DELIMITER);
+    if (end < 0)
+        throw new Error("opening '---' is missing a closing delimiter");
+    const parsed = parseYaml(lines.slice(1, end).join("\n"));
+    if (parsed === null || parsed === undefined)
+        return {};
+    if (typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("frontmatter must be a YAML mapping");
+    }
+    return parsed;
+}
+function normalizedSkillName(value, filePath) {
+    const explicit = typeof value === "string" ? value.trim() : "";
+    if (explicit)
+        return explicit;
+    if (basename(filePath).toLowerCase() === "skill.md")
+        return basename(dirname(filePath)).trim();
+    return basename(filePath, extname(filePath)).trim();
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function resolveSkillReadPath(skills, activatedSkillDirs, inputPath) {
+    const virtualRead = resolveVirtualSkillReadPath(skills, activatedSkillDirs, inputPath);
+    if (virtualRead)
+        return virtualRead;
+    const resolution = resolveAdvertisedFileReadPath(skills, activatedSkillDirs, inputPath);
+    if (!resolution)
+        return undefined;
+    return {
+        absolutePath: resolution.absolutePath,
+        skill: resolution.source,
+        isSkillFile: resolution.isEntryFile,
+    };
+}
+function resolveVirtualSkillReadPath(skills, activatedSkillDirs, inputPath) {
+    const prefix = "skills://";
+    if (!inputPath.startsWith(prefix))
+        return undefined;
+    const requested = inputPath.slice(prefix.length);
+    const slashIndex = requested.indexOf("/");
+    const encodedName = slashIndex === -1 ? requested : requested.slice(0, slashIndex);
+    if (!encodedName)
+        throw new Error(`Invalid skill URI: ${inputPath}`);
+    let name;
+    try {
+        name = decodeURIComponent(encodedName);
+    }
+    catch {
+        throw new Error(`Invalid skill URI: ${inputPath}`);
+    }
+    const skill = skills.find((candidate) => candidate.name === name);
+    if (!skill)
+        throw new Error(`Unknown advertised skill: ${name}`);
+    if (slashIndex === -1 || slashIndex === requested.length - 1) {
+        return {
+            absolutePath: resolve(skill.filePath),
+            skill,
+            isSkillFile: true,
+        };
+    }
+    const relativePart = requested.slice(slashIndex + 1);
+    const segments = relativePart.split("/").map((segment) => {
+        let decoded;
+        try {
+            decoded = decodeURIComponent(segment);
+        }
+        catch {
+            throw new Error(`Invalid skill URI: ${inputPath}`);
+        }
+        if (!decoded || decoded === "." || decoded === ".." || decoded.includes("/") || decoded.includes("\\")) {
+            throw new Error(`Invalid skill URI: ${inputPath}`);
+        }
+        return decoded;
+    });
+    const baseDir = resolve(skill.baseDir);
+    if (!activatedSkillDirs.has(baseDir))
+        return undefined;
+    const absolutePath = resolve(baseDir, ...segments);
+    if (!isPathInsideRoot(absolutePath, baseDir)) {
+        throw new Error(`Skill resource is outside its skill directory: ${inputPath}`);
+    }
+    return {
+        absolutePath,
+        skill,
+        isSkillFile: false,
+    };
+}
+export function markSkillActivated(activatedSkillDirs, skill) {
+    markAdvertisedFileSourceActivated(activatedSkillDirs, skill);
+}
+export function formatPathForPrompt(path) {
+    const home = resolve(homedir());
+    const resolvedPath = resolve(path);
+    if (resolvedPath === home)
+        return "~";
+    if (resolvedPath.startsWith(`${home}${sep}`)) {
+        return `~/${resolvedPath.slice(home.length + 1).split(sep).join("/")}`;
+    }
+    return resolvedPath.split(sep).join("/");
+}

package/dist/{review-checkpoints.js → workspaces/review/review-checkpoints.js}

@@ -1,8 +1,8 @@
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { git, getGitEligibility, safeWorkspaceRefSegment } from "./git.js";
-const REVIEW_REF_PREFIX = "refs/devspace/review";
+import { git, getGitEligibility, safeWorkspaceRefSegment } from "../git/git.js";
+const REVIEW_REF_PREFIX = "refs/forgerelay/review";
 const DEFAULT_MAX_REVIEW_WORKSPACE_STATES = 128;
 export function createReviewCheckpointManager(options = {}) {
     const maxWorkspaceStates = options.maxWorkspaceStates ?? DEFAULT_MAX_REVIEW_WORKSPACE_STATES;