@agent-api/sdk 1.0.6 → 1.1.0

package/dist/local/core.js

@@ -0,0 +1,1057 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants as fsConstants, watch as watchFS } from "node:fs";
+import { access, copyFile, mkdir, readdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { homedir, tmpdir } from "node:os";
+import path from "node:path";
+import { localSkillFromDirectory } from "../local-skills.js";
+export class LocalError extends Error {
+    code;
+    path;
+    constructor(code, message, options = {}) {
+        super(message, { cause: options.cause });
+        this.name = "LocalError";
+        this.code = code;
+        this.path = options.path;
+    }
+}
+export class LocalPathError extends LocalError {
+    constructor(message, path) {
+        super("local_path_error", message, { path });
+        this.name = "LocalPathError";
+    }
+}
+export class LocalIgnoredPathError extends LocalError {
+    constructor(path) {
+        super("local_ignored_path", `local workspace path is ignored: ${path}`, { path });
+        this.name = "LocalIgnoredPathError";
+    }
+}
+export class LocalFileTooLargeError extends LocalError {
+    constructor(path) {
+        super("local_file_too_large", `local file is too large: ${path}`, { path });
+        this.name = "LocalFileTooLargeError";
+    }
+}
+export class LocalNotTextFileError extends LocalError {
+    constructor(path) {
+        super("local_not_text_file", `local file must be text: ${path}`, { path });
+        this.name = "LocalNotTextFileError";
+    }
+}
+export class LocalConfigError extends LocalError {
+    constructor(message, path) {
+        super("local_config_error", message, { path });
+        this.name = "LocalConfigError";
+    }
+}
+export function createLocalRuntime(options) {
+    const appName = normalizeAppName(options.appName);
+    const dirs = localAppDirs({ ...options, appName });
+    const data = new LocalFileStore(dirs.data, { label: "data" });
+    const cache = new LocalFileStore(dirs.cache, { label: "cache" });
+    const logs = new LocalFileStore(dirs.logs, { label: "logs" });
+    const temp = new LocalFileStore(dirs.temp, { label: "temp" });
+    const configFiles = new LocalFileStore(dirs.config, { label: "config" });
+    return {
+        appName,
+        dirs,
+        files: data,
+        data,
+        cache,
+        logs,
+        temp,
+        config: new LocalConfigStore(configFiles),
+        skills: new LocalSkillStore(data.child("skills")),
+        workspaces: new LocalWorkspaceManager(),
+        workspace(root, workspaceOptions = {}) {
+            return new LocalWorkspace(root, workspaceOptions);
+        },
+        async ensure() {
+            await Promise.all([data.ensure(), cache.ensure(), logs.ensure(), temp.ensure(), configFiles.ensure()]);
+        },
+    };
+}
+export function localAppDirs(options) {
+    const appName = normalizeAppName(options.appName);
+    const env = options.env ?? process.env;
+    const platform = options.platform ?? process.platform;
+    const home = path.resolve(env.HOME || env.USERPROFILE || homedir());
+    const baseDir = options.baseDir ? path.resolve(options.baseDir) : "";
+    const authorSegment = sanitizePathSegment(options.appAuthor || appName);
+    const appSegment = sanitizePathSegment(appName);
+    const defaults = defaultDirs(platform, env, home, authorSegment, appSegment, baseDir);
+    return {
+        home,
+        data: path.resolve(options.dirs?.data ?? defaults.data),
+        config: path.resolve(options.dirs?.config ?? defaults.config),
+        cache: path.resolve(options.dirs?.cache ?? defaults.cache),
+        logs: path.resolve(options.dirs?.logs ?? defaults.logs),
+        temp: path.resolve(options.dirs?.temp ?? defaults.temp),
+    };
+}
+export class LocalFileStore {
+    root;
+    label;
+    constructor(root, options = {}) {
+        this.root = path.resolve(root);
+        this.label = options.label ?? "local";
+    }
+    child(relativePath, options = {}) {
+        return new LocalFileStore(this.resolvePath(relativePath), { label: options.label ?? this.label });
+    }
+    async ensure() {
+        await mkdir(this.root, { recursive: true });
+    }
+    resolvePath(relativePath = ".") {
+        const clean = normalizeRelativePath(relativePath);
+        const fullPath = path.resolve(this.root, clean);
+        assertInsideRoot(this.root, fullPath);
+        return fullPath;
+    }
+    relativePath(fullPath) {
+        const absolute = path.resolve(fullPath);
+        assertInsideRoot(this.root, absolute);
+        return toPortablePath(path.relative(this.root, absolute));
+    }
+    async exists(relativePath = ".") {
+        try {
+            await access(this.resolvePath(relativePath), fsConstants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async stat(relativePath = ".") {
+        const fullPath = this.resolvePath(relativePath);
+        const info = await stat(fullPath);
+        return {
+            path: toPortablePath(path.relative(this.root, fullPath)) || ".",
+            fullPath,
+            type: fileType(info),
+            size: info.size,
+            modifiedAt: info.mtime,
+        };
+    }
+    async mkdir(relativePath = ".") {
+        const fullPath = this.resolvePath(relativePath);
+        await mkdir(fullPath, { recursive: true });
+        return fullPath;
+    }
+    async list(relativePath = ".", options = {}) {
+        const base = this.resolvePath(relativePath);
+        const maxDepth = options.recursive ? options.maxDepth ?? Number.POSITIVE_INFINITY : 1;
+        const out = [];
+        await this.walk(this.root, base, base, out, maxDepth, options);
+        return out.sort((a, b) => a.path.localeCompare(b.path));
+    }
+    async listEntries(relativePath = ".", options = {}) {
+        const stats = await this.list(relativePath, { ...options, includeDirectories: options.includeDirectories ?? true });
+        return { object: "list", entries: stats.map(localEntryFromStat) };
+    }
+    async searchEntries(params) {
+        const query = params.query.trim().toLowerCase();
+        if (!query) {
+            throw new Error("query is required");
+        }
+        const limit = positiveInt(params.limit, 100);
+        const stats = await this.list(params.path ?? ".", { recursive: true, includeDirectories: true });
+        const entries = stats
+            .filter((item) => item.path.toLowerCase().includes(query))
+            .slice(0, limit)
+            .map(localEntryFromStat);
+        return { object: "list", entries };
+    }
+    async readText(relativePath) {
+        return await readFile(this.resolvePath(relativePath), "utf8");
+    }
+    async readJSON(relativePath) {
+        return JSON.parse(await this.readText(relativePath));
+    }
+    async readBytes(relativePath) {
+        return await readFile(this.resolvePath(relativePath));
+    }
+    async readFile(relativePath, params = {}) {
+        const fullPath = this.resolvePath(relativePath);
+        const info = await stat(fullPath);
+        if (!info.isFile()) {
+            throw new LocalPathError("local path is not a file", relativePath);
+        }
+        const maxBytes = params.maxBytes ?? Number.POSITIVE_INFINITY;
+        const raw = await readFile(fullPath);
+        const truncated = Number.isFinite(maxBytes) && raw.byteLength > maxBytes;
+        const content = truncated ? raw.subarray(0, maxBytes) : raw;
+        const portablePath = toPortablePath(path.relative(this.root, fullPath));
+        if ("format" in params && params.format === "raw") {
+            return {
+                path: portablePath,
+                size: info.size,
+                truncated,
+                content,
+                content_type: mimeTypeForPath(portablePath),
+            };
+        }
+        if (looksBinary(content)) {
+            return {
+                path: portablePath,
+                encoding: "base64",
+                mime_type: mimeTypeForPath(portablePath),
+                size: info.size,
+                truncated,
+                content_base64: Buffer.from(content).toString("base64"),
+            };
+        }
+        return {
+            path: portablePath,
+            encoding: "text",
+            mime_type: mimeTypeForPath(portablePath),
+            size: info.size,
+            truncated,
+            content: content.toString("utf8"),
+        };
+    }
+    async writeText(relativePath, content, options = {}) {
+        const fullPath = this.resolvePath(relativePath);
+        await mkdir(path.dirname(fullPath), { recursive: true });
+        if (options.atomic === false) {
+            await writeFile(fullPath, content, "utf8");
+            return fullPath;
+        }
+        await atomicWrite(fullPath, content);
+        return fullPath;
+    }
+    async writeJSON(relativePath, value, options = {}) {
+        const spaces = options.pretty === false ? 0 : 2;
+        const text = JSON.stringify(value, null, spaces) + "\n";
+        return await this.writeText(relativePath, text, { atomic: options.atomic });
+    }
+    async writeBytes(relativePath, content, options = {}) {
+        const fullPath = this.resolvePath(relativePath);
+        await mkdir(path.dirname(fullPath), { recursive: true });
+        if (options.atomic === false) {
+            await writeFile(fullPath, content);
+            return fullPath;
+        }
+        await atomicWrite(fullPath, content);
+        return fullPath;
+    }
+    async writeFile(relativePath, content, options = {}) {
+        const fullPath = typeof content === "string"
+            ? await this.writeText(relativePath, content, options)
+            : await this.writeBytes(relativePath, content, options);
+        const info = await stat(fullPath);
+        return { path: toPortablePath(path.relative(this.root, fullPath)), size: info.size };
+    }
+    async remove(relativePath) {
+        await rm(this.resolvePath(relativePath), { recursive: true, force: true });
+    }
+    async deletePath(relativePath) {
+        await this.remove(relativePath);
+        return { path: normalizeRelativePath(relativePath), recursive: true };
+    }
+    async createDirectory(relativePath = ".") {
+        await this.mkdir(relativePath);
+        return { path: normalizeRelativePath(relativePath) };
+    }
+    async copy(fromRelativePath, toRelativePath) {
+        const from = this.resolvePath(fromRelativePath);
+        const to = this.resolvePath(toRelativePath);
+        await mkdir(path.dirname(to), { recursive: true });
+        await copyFile(from, to);
+        return to;
+    }
+    async readLines(relativePath, params) {
+        const startLine = Math.trunc(params.startLine);
+        const endLine = params.endLine == null ? undefined : Math.trunc(params.endLine);
+        const file = await this.readFile(relativePath, { maxBytes: params.maxBytes, format: "raw" });
+        if (looksBinary(file.content)) {
+            throw new LocalNotTextFileError(relativePath);
+        }
+        const text = Buffer.from(file.content).toString("utf8");
+        const all = splitLines(text);
+        const selected = selectLineRange(all, startLine, endLine);
+        return {
+            path: file.path,
+            start_line: startLine,
+            end_line: selected.endLine,
+            total_lines: all.length,
+            lines: selected.lines,
+            file_truncated: file.truncated,
+            size: file.size,
+        };
+    }
+    async patchLines(relativePath, params) {
+        const startLine = Math.trunc(params.startLine);
+        const endLine = params.endLine == null ? undefined : Math.trunc(params.endLine);
+        const file = await this.readFile(relativePath, { maxBytes: params.maxBytes, format: "raw" });
+        if (file.truncated) {
+            throw new LocalFileTooLargeError(relativePath);
+        }
+        if (looksBinary(file.content)) {
+            throw new LocalNotTextFileError(relativePath);
+        }
+        const original = Buffer.from(file.content).toString("utf8");
+        const patched = patchLineRange(original, startLine, endLine, params.replacement ?? "");
+        const written = await this.writeFile(relativePath, patched.content);
+        return {
+            path: file.path,
+            start_line: startLine,
+            end_line: patched.endLine,
+            total_lines: patched.totalLines,
+            size: written.size,
+        };
+    }
+    async grep(params) {
+        const pattern = params.pattern.trim();
+        if (!pattern) {
+            throw new Error("pattern is required");
+        }
+        const limit = positiveInt(params.limit, 200);
+        const maxFiles = positiveInt(params.maxFiles, 500);
+        const maxBytesPerFile = positiveInt(params.maxBytesPerFile, 512 * 1024);
+        const maxLineLength = positiveInt(params.maxLineLength, 500);
+        const stats = await this.list(params.path ?? ".", { recursive: true, ignore: params.ignore });
+        const matches = [];
+        let filesScanned = 0;
+        let scanTruncated = false;
+        for (const item of stats) {
+            if (matches.length >= limit || filesScanned >= maxFiles) {
+                scanTruncated = true;
+                break;
+            }
+            if (item.type !== "file" || item.size > maxBytesPerFile || !isLikelyTextFile(item.path)) {
+                continue;
+            }
+            const raw = await readFile(item.fullPath);
+            if (looksBinary(raw)) {
+                continue;
+            }
+            filesScanned++;
+            const lines = splitLines(raw.toString("utf8"));
+            for (let i = 0; i < lines.length; i++) {
+                if (!lines[i].includes(pattern)) {
+                    continue;
+                }
+                matches.push({
+                    path: item.path,
+                    line_number: i + 1,
+                    line: lines[i].length > maxLineLength ? lines[i].slice(0, maxLineLength) : lines[i],
+                });
+                if (matches.length >= limit) {
+                    scanTruncated = true;
+                    break;
+                }
+            }
+        }
+        return { object: "list", matches, files_scanned: filesScanned, scan_truncated: scanTruncated };
+    }
+    async summarize(params = {}) {
+        const maxFiles = positiveInt(params.maxFiles, 2000);
+        const maxPreviews = positiveInt(params.maxPreviews, 20);
+        const previewBytes = positiveInt(params.previewBytes, 4096);
+        const topPaths = positiveInt(params.topPaths, 20);
+        const stats = await this.list(params.path ?? ".", { recursive: true, ignore: params.ignore });
+        const files = stats.filter((item) => item.type === "file").slice(0, maxFiles);
+        const scanTruncated = stats.filter((item) => item.type === "file").length > files.length;
+        const totalBytes = files.reduce((sum, item) => sum + item.size, 0);
+        const bySize = [...files].sort((a, b) => (b.size !== a.size ? b.size - a.size : a.path.localeCompare(b.path)));
+        const previews = [];
+        for (const item of bySize) {
+            if (previews.length >= maxPreviews) {
+                break;
+            }
+            if (!isLikelyTextFile(item.path) || item.size > previewBytes * 4) {
+                continue;
+            }
+            const raw = await readFile(item.fullPath);
+            if (looksBinary(raw)) {
+                continue;
+            }
+            const truncated = raw.byteLength > previewBytes;
+            previews.push({
+                path: item.path,
+                size: item.size,
+                preview: raw.subarray(0, previewBytes).toString("utf8"),
+                preview_truncated: truncated || undefined,
+            });
+        }
+        return {
+            summary_path: "",
+            file_count: files.length,
+            total_bytes: totalBytes,
+            top_paths_by_size: bySize.slice(0, topPaths).map((item) => `${item.path} (${item.size} bytes)`),
+            text_previews: previews,
+            generated_at_unix: Math.floor(Date.now() / 1000),
+            scan_truncated: scanTruncated,
+        };
+    }
+    async walk(storeRoot, scanRoot, dir, out, maxDepth, options) {
+        const entries = await readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            const relativePath = toPortablePath(path.relative(storeRoot, fullPath));
+            if (ignored(relativePath, options.ignore)) {
+                continue;
+            }
+            const info = await stat(fullPath);
+            const item = {
+                path: relativePath,
+                fullPath,
+                type: fileType(info),
+                size: info.size,
+                modifiedAt: info.mtime,
+            };
+            if (entry.isDirectory()) {
+                if (options.includeDirectories) {
+                    out.push(item);
+                }
+                const depth = toPortablePath(path.relative(scanRoot, fullPath)).split("/").filter(Boolean).length;
+                if (depth < maxDepth) {
+                    await this.walk(storeRoot, scanRoot, fullPath, out, maxDepth, options);
+                }
+                continue;
+            }
+            out.push(item);
+        }
+    }
+}
+export class LocalConfigStore {
+    files;
+    constructor(files) {
+        this.files = files;
+    }
+    async read(name = "settings.json", fallback) {
+        try {
+            return await this.files.readJSON(name);
+        }
+        catch (error) {
+            if (error?.code === "ENOENT" && arguments.length >= 2) {
+                return fallback;
+            }
+            throw error;
+        }
+    }
+    async write(name, value) {
+        return await this.files.writeJSON(name, value);
+    }
+    async get(name, key, fallback) {
+        const config = await this.readRecord(name);
+        return (key in config ? config[key] : fallback);
+    }
+    async set(name, key, value) {
+        const config = await this.readRecord(name);
+        config[key] = value;
+        return await this.write(name, config);
+    }
+    async delete(name, key) {
+        const config = await this.readRecord(name);
+        delete config[key];
+        return await this.write(name, config);
+    }
+    async readRecord(name) {
+        const value = await this.read(name, {});
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            throw new LocalConfigError(`local config ${name} must contain a JSON object`, name);
+        }
+        return value;
+    }
+}
+export class LocalWorkspaceManager {
+    open(root, options = {}) {
+        return new LocalWorkspace(root, options);
+    }
+}
+export class LocalWorkspace {
+    root;
+    name;
+    metadata;
+    trusted;
+    files;
+    ignore;
+    gitignore;
+    maxFileBytes;
+    constructor(root, options = {}) {
+        this.root = path.resolve(root);
+        this.name = options.name?.trim() || path.basename(this.root) || "workspace";
+        this.metadata = { ...(options.metadata ?? {}) };
+        this.trusted = options.trusted ?? false;
+        this.files = new LocalFileStore(this.root, { label: "workspace" });
+        this.ignore = [...defaultWorkspaceIgnoreRules(), ...(options.ignore ?? [])];
+        this.gitignore = options.gitignore ?? true;
+        this.maxFileBytes = positiveInt(options.maxFileBytes, 10 * 1024 * 1024);
+    }
+    async ensure() {
+        await this.files.ensure();
+        if (this.gitignore) {
+            await this.loadIgnoreFiles();
+        }
+    }
+    async loadIgnoreFiles(files = [".gitignore"]) {
+        const loaded = [];
+        for (const file of files) {
+            try {
+                const text = await this.files.readText(file);
+                loaded.push(...parseIgnoreFile(text));
+            }
+            catch (error) {
+                if (error?.code !== "ENOENT") {
+                    throw error;
+                }
+            }
+        }
+        this.ignore.push(...loaded);
+        return loaded;
+    }
+    child(relativePath, options = {}) {
+        return new LocalWorkspace(this.files.resolvePath(relativePath), {
+            name: options.name,
+            metadata: options.metadata ?? this.metadata,
+            trusted: options.trusted ?? this.trusted,
+            ignore: options.ignore ?? this.ignore,
+            gitignore: options.gitignore ?? this.gitignore,
+            maxFileBytes: options.maxFileBytes ?? this.maxFileBytes,
+        });
+    }
+    resolvePath(relativePath = ".") {
+        this.assertAllowed(relativePath);
+        return this.files.resolvePath(relativePath);
+    }
+    async list(relativePath = ".", options = {}) {
+        return await this.files.list(relativePath, this.scopedListOptions(options));
+    }
+    async listEntries(relativePath = ".", options = {}) {
+        return await this.files.listEntries(relativePath, this.scopedListOptions(options));
+    }
+    async searchEntries(params) {
+        const query = params.query.trim().toLowerCase();
+        if (!query) {
+            throw new Error("query is required");
+        }
+        const limit = positiveInt(params.limit, 100);
+        const stats = await this.list(params.path ?? ".", { recursive: true, includeDirectories: true });
+        return {
+            object: "list",
+            entries: stats
+                .filter((item) => item.path.toLowerCase().includes(query))
+                .slice(0, limit)
+                .map(localEntryFromStat),
+        };
+    }
+    async readFile(relativePath, params = {}) {
+        this.assertAllowed(relativePath);
+        return await this.files.readFile(relativePath, { maxBytes: params.maxBytes ?? this.maxFileBytes, ...params });
+    }
+    async writeFile(relativePath, content, options = {}) {
+        this.assertAllowed(relativePath);
+        return await this.files.writeFile(relativePath, content, options);
+    }
+    async readText(relativePath) {
+        this.assertAllowed(relativePath);
+        return await this.files.readText(relativePath);
+    }
+    async writeText(relativePath, content, options = {}) {
+        this.assertAllowed(relativePath);
+        return await this.files.writeText(relativePath, content, options);
+    }
+    async deletePath(relativePath) {
+        this.assertAllowed(relativePath);
+        return await this.files.deletePath(relativePath);
+    }
+    async createDirectory(relativePath = ".") {
+        this.assertAllowed(relativePath);
+        return await this.files.createDirectory(relativePath);
+    }
+    async readLines(relativePath, params) {
+        this.assertAllowed(relativePath);
+        return await this.files.readLines(relativePath, { maxBytes: params.maxBytes ?? this.maxFileBytes, ...params });
+    }
+    async previewPatchLines(relativePath, params) {
+        this.assertAllowed(relativePath);
+        const lines = await this.readLines(relativePath, {
+            startLine: params.startLine,
+            endLine: params.endLine,
+            maxBytes: params.maxBytes ?? this.maxFileBytes,
+        });
+        const file = await this.files.readFile(relativePath, { maxBytes: params.maxBytes ?? this.maxFileBytes, format: "raw" });
+        if (file.truncated) {
+            throw new Error("local file is too large to patch");
+        }
+        if (looksBinary(file.content)) {
+            throw new Error("local file must be text");
+        }
+        const patched = patchLineRange(Buffer.from(file.content).toString("utf8"), params.startLine, params.endLine, params.replacement ?? "");
+        return {
+            path: lines.path,
+            start_line: lines.start_line,
+            end_line: lines.end_line,
+            total_lines: patched.totalLines,
+            before: lines.lines,
+            after: params.replacement === "" ? [] : splitLines(params.replacement ?? ""),
+        };
+    }
+    async patchLines(relativePath, params) {
+        this.assertAllowed(relativePath);
+        return await this.files.patchLines(relativePath, { maxBytes: params.maxBytes ?? this.maxFileBytes, ...params });
+    }
+    async previewEdits(edits) {
+        const previews = [];
+        for (const edit of edits) {
+            await this.assertExpectedHash(edit.path, edit.expectedSha256);
+            previews.push(await this.previewPatchLines(edit.path, edit));
+        }
+        return { edits: edits.map((edit) => ({ ...edit })), previews };
+    }
+    async applyEdits(edits) {
+        const backups = [];
+        const applied = [];
+        try {
+            for (const edit of edits) {
+                await this.assertExpectedHash(edit.path, edit.expectedSha256);
+                backups.push({ path: edit.path, content: await this.readText(edit.path) });
+                applied.push(await this.patchLines(edit.path, edit));
+            }
+        }
+        catch (error) {
+            for (const backup of backups.reverse()) {
+                await this.writeText(backup.path, backup.content);
+            }
+            throw error;
+        }
+        return { applied, backups };
+    }
+    classifyPath(relativePath) {
+        return classifyLocalPathSensitivity(relativePath);
+    }
+    async grep(params) {
+        return await this.files.grep({ ...params, ignore: this.mergeIgnore(params.ignore) });
+    }
+    async summarize(params = {}) {
+        return await this.files.summarize({ ...params, ignore: this.mergeIgnore(params.ignore) });
+    }
+    async snapshot(params = {}) {
+        const maxBytes = positiveInt(params.maxBytesPerFile, this.maxFileBytes);
+        const shouldHash = params.hash ?? true;
+        const stats = await this.list(params.path ?? ".", { recursive: true });
+        const files = [];
+        for (const item of stats) {
+            if (item.type !== "file") {
+                continue;
+            }
+            const snap = {
+                path: item.path,
+                size: item.size,
+                modified_at_unix: Math.floor(item.modifiedAt.getTime() / 1000),
+            };
+            if (shouldHash && item.size <= maxBytes) {
+                snap.sha256 = createHash("sha256").update(await readFile(item.fullPath)).digest("hex");
+            }
+            files.push(snap);
+        }
+        return {
+            root: this.root,
+            name: this.name,
+            generated_at_unix: Math.floor(Date.now() / 1000),
+            files,
+        };
+    }
+    diff(before, after) {
+        const beforeByPath = new Map(before.files.map((file) => [file.path, file]));
+        const afterByPath = new Map(after.files.map((file) => [file.path, file]));
+        const added = [];
+        const modified = [];
+        const deleted = [];
+        const unchanged = [];
+        for (const afterFile of after.files) {
+            const beforeFile = beforeByPath.get(afterFile.path);
+            if (!beforeFile) {
+                added.push(afterFile);
+            }
+            else if (snapshotFileChanged(beforeFile, afterFile)) {
+                modified.push({ before: beforeFile, after: afterFile });
+            }
+            else {
+                unchanged.push(afterFile);
+            }
+        }
+        for (const beforeFile of before.files) {
+            if (!afterByPath.has(beforeFile.path)) {
+                deleted.push(beforeFile);
+            }
+        }
+        return { added, modified, deleted, unchanged };
+    }
+    watch(onEvent, options = {}) {
+        const watcher = watchFS(this.root, { recursive: options.recursive ?? process.platform !== "linux" }, (eventType, filename) => {
+            const rel = filename ? toPortablePath(String(filename)) : ".";
+            if (ignored(rel, this.ignore)) {
+                return;
+            }
+            onEvent({ type: eventType === "rename" ? "rename" : "change", path: rel });
+        });
+        return { close: () => watcher.close() };
+    }
+    scopedListOptions(options) {
+        return { ...options, ignore: this.mergeIgnore(options.ignore) };
+    }
+    mergeIgnore(ignore) {
+        return [...this.ignore, ...(ignore ?? [])];
+    }
+    assertAllowed(relativePath) {
+        const rel = normalizeRelativePath(relativePath);
+        if (rel !== "." && ignored(rel, this.ignore)) {
+            throw new LocalIgnoredPathError(rel);
+        }
+    }
+    async assertExpectedHash(relativePath, expectedSha256) {
+        if (!expectedSha256) {
+            return;
+        }
+        const raw = await readFile(this.files.resolvePath(relativePath));
+        const actual = createHash("sha256").update(raw).digest("hex");
+        if (actual !== expectedSha256) {
+            throw new LocalError("local_edit_conflict", `local file changed before edit: ${relativePath}`, { path: relativePath });
+        }
+    }
+}
+export class LocalSkillStore {
+    files;
+    constructor(files) {
+        this.files = files;
+    }
+    async fromDirectory(rootDir, options = {}) {
+        return await localSkillFromDirectory(rootDir, options);
+    }
+    async discover(options = {}) {
+        const roots = options.roots?.length ? options.roots : [this.files.root];
+        const skillDirs = [];
+        for (const root of roots) {
+            skillDirs.push(...await discoverSkillDirectories(path.resolve(root), options));
+        }
+        const unique = [...new Set(skillDirs)].sort((a, b) => a.localeCompare(b));
+        return await Promise.all(unique.map((dir) => localSkillFromDirectory(dir, options)));
+    }
+}
+function defaultDirs(platform, env, home, authorSegment, appSegment, baseDir) {
+    if (baseDir) {
+        return {
+            data: path.join(baseDir, "data"),
+            config: path.join(baseDir, "config"),
+            cache: path.join(baseDir, "cache"),
+            logs: path.join(baseDir, "logs"),
+            temp: path.join(baseDir, "tmp"),
+        };
+    }
+    if (platform === "darwin") {
+        return {
+            data: path.join(home, "Library", "Application Support", appSegment),
+            config: path.join(home, "Library", "Application Support", appSegment),
+            cache: path.join(home, "Library", "Caches", appSegment),
+            logs: path.join(home, "Library", "Logs", appSegment),
+            temp: path.join(tmpdir(), appSegment),
+        };
+    }
+    if (platform === "win32") {
+        const roaming = env.APPDATA || path.join(home, "AppData", "Roaming");
+        const local = env.LOCALAPPDATA || path.join(home, "AppData", "Local");
+        return {
+            data: path.join(roaming, authorSegment, appSegment),
+            config: path.join(roaming, authorSegment, appSegment),
+            cache: path.join(local, authorSegment, appSegment, "Cache"),
+            logs: path.join(local, authorSegment, appSegment, "Logs"),
+            temp: path.join(tmpdir(), appSegment),
+        };
+    }
+    return {
+        data: path.join(env.XDG_DATA_HOME || path.join(home, ".local", "share"), appSegment),
+        config: path.join(env.XDG_CONFIG_HOME || path.join(home, ".config"), appSegment),
+        cache: path.join(env.XDG_CACHE_HOME || path.join(home, ".cache"), appSegment),
+        logs: path.join(env.XDG_STATE_HOME || path.join(home, ".local", "state"), appSegment, "logs"),
+        temp: path.join(tmpdir(), appSegment),
+    };
+}
+async function discoverSkillDirectories(root, options) {
+    try {
+        const info = await stat(root);
+        if (!info.isDirectory()) {
+            return [];
+        }
+    }
+    catch (error) {
+        if (error?.code === "ENOENT") {
+            return [];
+        }
+        throw error;
+    }
+    const out = [];
+    const maxDepth = options.recursive ? options.maxDepth ?? Number.POSITIVE_INFINITY : 1;
+    await walkSkillDirectories(root, root, out, maxDepth);
+    return out;
+}
+async function walkSkillDirectories(root, dir, out, maxDepth) {
+    if (await fileExists(path.join(dir, "SKILL.md"))) {
+        out.push(dir);
+    }
+    const relative = path.relative(root, dir);
+    const depth = relative ? relative.split(path.sep).length : 0;
+    if (depth >= maxDepth) {
+        return;
+    }
+    const entries = await readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory() || ignoredDirectoryName(entry.name)) {
+            continue;
+        }
+        await walkSkillDirectories(root, path.join(dir, entry.name), out, maxDepth);
+    }
+}
+async function fileExists(fullPath) {
+    try {
+        const info = await stat(fullPath);
+        return info.isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeAppName(appName) {
+    const trimmed = appName.trim();
+    if (!trimmed) {
+        throw new LocalConfigError("appName is required");
+    }
+    return trimmed;
+}
+function sanitizePathSegment(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "agent-api";
+}
+function normalizeRelativePath(value) {
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === ".") {
+        return ".";
+    }
+    if (path.isAbsolute(trimmed)) {
+        throw new LocalPathError("local path must be relative", value);
+    }
+    return trimmed;
+}
+function assertInsideRoot(root, fullPath) {
+    const relative = path.relative(root, fullPath);
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new LocalPathError("local path must stay inside the store root", fullPath);
+    }
+}
+function toPortablePath(value) {
+    return value.split(path.sep).join("/");
+}
+function fileType(info) {
+    if (info.isFile())
+        return "file";
+    if (info.isDirectory())
+        return "directory";
+    if (info.isSymbolicLink())
+        return "symlink";
+    return "other";
+}
+function localEntryFromStat(item) {
+    return {
+        path: item.path,
+        is_dir: item.type === "directory",
+        size: item.type === "directory" ? 0 : item.size,
+        modified_at_unix: Math.floor(item.modifiedAt.getTime() / 1000),
+    };
+}
+async function atomicWrite(fullPath, content) {
+    const tmpPath = path.join(path.dirname(fullPath), `.${path.basename(fullPath)}.${process.pid}.${randomUUID()}.tmp`);
+    await writeFile(tmpPath, content);
+    await rename(tmpPath, fullPath);
+}
+function ignored(relativePath, ignore) {
+    if (!ignore?.length) {
+        return false;
+    }
+    return ignore.some((rule) => {
+        if (typeof rule === "string") {
+            return relativePath === rule || relativePath.startsWith(`${rule}/`) || relativePath.endsWith(`/${rule}`) || relativePath.includes(`/${rule}/`);
+        }
+        if (rule instanceof RegExp)
+            return rule.test(relativePath);
+        return rule(relativePath);
+    });
+}
+function ignoredDirectoryName(name) {
+    return name === ".git" || name === "node_modules" || name === "__pycache__";
+}
+function defaultWorkspaceIgnoreRules() {
+    return [
+        ".git",
+        "node_modules",
+        "__pycache__",
+        ".DS_Store",
+        "dist",
+        "build",
+        "coverage",
+        ".next",
+        ".turbo",
+        ".cache",
+        /\.pyc$/,
+        /\.pyo$/,
+        /\.class$/,
+        /\.log$/,
+    ];
+}
+function parseIgnoreFile(text) {
+    const rules = [];
+    for (const rawLine of text.split(/\r?\n/)) {
+        let line = rawLine.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        if (line.startsWith("!")) {
+            continue;
+        }
+        line = line.replace(/\\/g, "/");
+        if (line.startsWith("/")) {
+            line = line.slice(1);
+        }
+        if (line.endsWith("/")) {
+            line = line.slice(0, -1);
+        }
+        if (!line || line.includes("*")) {
+            rules.push(globIgnoreRule(line));
+            continue;
+        }
+        rules.push(line);
+    }
+    return rules;
+}
+function globIgnoreRule(pattern) {
+    const escaped = pattern
+        .split("*")
+        .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, "\\$&"))
+        .join(".*");
+    const regex = new RegExp(`(^|/)${escaped}($|/)`);
+    return (relativePath) => regex.test(relativePath);
+}
+function snapshotFileChanged(before, after) {
+    if (before.sha256 || after.sha256) {
+        return before.sha256 !== after.sha256;
+    }
+    return before.size !== after.size || before.modified_at_unix !== after.modified_at_unix;
+}
+export function classifyLocalPathSensitivity(relativePath) {
+    const rel = normalizeRelativePath(relativePath);
+    const lower = rel.toLowerCase();
+    const base = path.basename(lower);
+    if (base === ".env" ||
+        base.startsWith(".env.") ||
+        lower.includes("id_rsa") ||
+        lower.includes("id_ed25519") ||
+        lower.endsWith(".pem") ||
+        lower.endsWith(".key") ||
+        lower.endsWith(".p12") ||
+        lower.endsWith(".pfx")) {
+        return { path: rel, sensitivity: "secret", reason: "path commonly contains credentials or private keys" };
+    }
+    if (lower.includes("secret") ||
+        lower.includes("token") ||
+        lower.includes("credential") ||
+        lower.includes("password") ||
+        lower.endsWith(".crt") ||
+        lower.endsWith(".cert")) {
+        return { path: rel, sensitivity: "sensitive", reason: "path name suggests sensitive material" };
+    }
+    return { path: rel, sensitivity: "normal" };
+}
+function positiveInt(value, fallback) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed > 0 ? Math.trunc(parsed) : fallback;
+}
+function looksBinary(content) {
+    return content.includes(0);
+}
+const textExtensions = new Set([
+    ".txt", ".md", ".markdown", ".json", ".yaml", ".yml", ".toml", ".xml", ".csv",
+    ".py", ".go", ".js", ".mjs", ".cjs", ".ts", ".tsx", ".jsx", ".html", ".htm",
+    ".css", ".scss", ".sh", ".bash", ".zsh", ".sql", ".env", ".ini", ".cfg",
+    ".conf", ".log", ".rst", ".adoc", ".gradle", ".properties", ".mod", ".sum",
+    ".dockerfile",
+]);
+function isLikelyTextFile(relativePath) {
+    const lower = relativePath.toLowerCase();
+    const ext = path.extname(lower);
+    return !ext || textExtensions.has(ext) || lower.endsWith("dockerfile");
+}
+function mimeTypeForPath(relativePath) {
+    const ext = path.extname(relativePath).toLowerCase();
+    switch (ext) {
+        case ".json":
+            return "application/json";
+        case ".md":
+        case ".markdown":
+            return "text/markdown";
+        case ".html":
+        case ".htm":
+            return "text/html";
+        case ".css":
+            return "text/css";
+        case ".csv":
+            return "text/csv";
+        case ".xml":
+            return "application/xml";
+        case ".png":
+            return "image/png";
+        case ".jpg":
+        case ".jpeg":
+            return "image/jpeg";
+        case ".gif":
+            return "image/gif";
+        case ".svg":
+            return "image/svg+xml";
+        case ".pdf":
+            return "application/pdf";
+        default:
+            return isLikelyTextFile(relativePath) ? "text/plain" : "application/octet-stream";
+    }
+}
+function splitLines(content) {
+    if (content.length === 0) {
+        return [""];
+    }
+    let text = content;
+    if (text.endsWith("\n")) {
+        text = text.slice(0, -1);
+        if (text === "") {
+            return [""];
+        }
+    }
+    return text.split("\n");
+}
+function selectLineRange(lines, startLine, endLine) {
+    if (startLine < 1) {
+        throw new Error("startLine must be >= 1");
+    }
+    const total = lines.length || 1;
+    const end = endLine == null || endLine <= 0 ? total : Math.min(endLine, total);
+    if (startLine > total || end < startLine) {
+        throw new Error("invalid line range");
+    }
+    return { lines: lines.slice(startLine - 1, end), endLine: end };
+}
+function patchLineRange(content, startLine, endLine, replacement) {
+    const lines = splitLines(content);
+    const selected = selectLineRange(lines, startLine, endLine);
+    const replacementLines = replacement === "" ? [] : splitLines(replacement);
+    const patched = [
+        ...lines.slice(0, startLine - 1),
+        ...replacementLines,
+        ...lines.slice(selected.endLine),
+    ];
+    let out = patched.join("\n");
+    if (content.endsWith("\n")) {
+        out += "\n";
+    }
+    return { content: out, endLine: selected.endLine, totalLines: patched.length };
+}