@psnext/slingcli 2.4.20260507-3 → 2.4.20260509-2

package/node_modules/@earendil-works/pi-agent-core/dist/harness/skills.js

@@ -0,0 +1,258 @@
+import ignore from "ignore";
+import { parse } from "yaml";
+const MAX_NAME_LENGTH = 64;
+const MAX_DESCRIPTION_LENGTH = 1024;
+const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
+/** Expand a skill into a prompt, optionally appending additional user instructions. */
+export function expandSkillCommand(skill, additionalInstructions) {
+    const skillBlock = `<skill name="${skill.name}" location="${skill.filePath}">\nReferences are relative to ${dirnameEnvPath(skill.filePath)}.\n\n${skill.content}\n</skill>`;
+    return additionalInstructions ? `${skillBlock}\n\n${additionalInstructions}` : skillBlock;
+}
+/**
+ * Load skills from one or more directories.
+ *
+ * Traverses directories recursively, loads `SKILL.md` files, loads direct root `.md` files as skills, honors ignore files,
+ * and returns diagnostics for invalid skill files. Missing input directories are skipped.
+ */
+export async function loadSkills(env, dirs) {
+    const skills = [];
+    const diagnostics = [];
+    for (const dir of Array.isArray(dirs) ? dirs : [dirs]) {
+        const rootInfo = await safeFileInfo(env, dir);
+        if (!rootInfo || (await resolveKind(env, rootInfo)) !== "directory")
+            continue;
+        const result = await loadSkillsFromDirInternal(env, rootInfo.path, true, ignore(), rootInfo.path);
+        skills.push(...result.skills);
+        diagnostics.push(...result.diagnostics);
+    }
+    return { skills, diagnostics };
+}
+/**
+ * Load skills from source-tagged directories.
+ *
+ * Source values are preserved exactly and attached to every loaded skill and diagnostic. The agent package does not
+ * interpret source values; applications define their own provenance shape.
+ */
+export async function loadSourcedSkills(env, inputs) {
+    const skills = [];
+    const diagnostics = [];
+    for (const input of inputs) {
+        const result = await loadSkills(env, input.path);
+        for (const skill of result.skills)
+            skills.push({ skill, source: input.source });
+        for (const diagnostic of result.diagnostics)
+            diagnostics.push({ ...diagnostic, source: input.source });
+    }
+    return { skills, diagnostics };
+}
+async function loadSkillsFromDirInternal(env, dir, includeRootFiles, ignoreMatcher, rootDir) {
+    const skills = [];
+    const diagnostics = [];
+    if (!(await env.exists(dir)))
+        return { skills, diagnostics };
+    const dirInfo = await safeFileInfo(env, dir);
+    if (!dirInfo || (await resolveKind(env, dirInfo)) !== "directory")
+        return { skills, diagnostics };
+    await addIgnoreRules(env, ignoreMatcher, dir, rootDir);
+    let entries;
+    try {
+        entries = await env.listDir(dir);
+    }
+    catch {
+        return { skills, diagnostics };
+    }
+    for (const entry of entries) {
+        if (entry.name !== "SKILL.md")
+            continue;
+        const fullPath = entry.path;
+        const kind = await resolveKind(env, entry);
+        if (kind !== "file")
+            continue;
+        const relPath = relativeEnvPath(rootDir, fullPath);
+        if (ignoreMatcher.ignores(relPath))
+            continue;
+        const result = await loadSkillFromFile(env, fullPath);
+        if (result.skill)
+            skills.push(result.skill);
+        diagnostics.push(...result.diagnostics);
+        return { skills, diagnostics };
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        if (entry.name.startsWith(".") || entry.name === "node_modules")
+            continue;
+        const fullPath = entry.path;
+        const kind = await resolveKind(env, entry);
+        if (!kind)
+            continue;
+        const relPath = relativeEnvPath(rootDir, fullPath);
+        const ignorePath = kind === "directory" ? `${relPath}/` : relPath;
+        if (ignoreMatcher.ignores(ignorePath))
+            continue;
+        if (kind === "directory") {
+            const result = await loadSkillsFromDirInternal(env, fullPath, false, ignoreMatcher, rootDir);
+            skills.push(...result.skills);
+            diagnostics.push(...result.diagnostics);
+            continue;
+        }
+        if (kind !== "file" || !includeRootFiles || !entry.name.endsWith(".md"))
+            continue;
+        const result = await loadSkillFromFile(env, fullPath);
+        if (result.skill)
+            skills.push(result.skill);
+        diagnostics.push(...result.diagnostics);
+    }
+    return { skills, diagnostics };
+}
+async function addIgnoreRules(env, ig, dir, rootDir) {
+    const relativeDir = relativeEnvPath(rootDir, dir);
+    const prefix = relativeDir ? `${relativeDir}/` : "";
+    for (const filename of IGNORE_FILE_NAMES) {
+        const ignorePath = joinEnvPath(dir, filename);
+        const info = await safeFileInfo(env, ignorePath);
+        if (info?.kind !== "file")
+            continue;
+        try {
+            const content = await env.readTextFile(ignorePath);
+            const patterns = content
+                .split(/\r?\n/)
+                .map((line) => prefixIgnorePattern(line, prefix))
+                .filter((line) => Boolean(line));
+            if (patterns.length > 0)
+                ig.add(patterns);
+        }
+        catch { }
+    }
+}
+function prefixIgnorePattern(line, prefix) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("#") && !trimmed.startsWith("\\#"))
+        return null;
+    let pattern = line;
+    let negated = false;
+    if (pattern.startsWith("!")) {
+        negated = true;
+        pattern = pattern.slice(1);
+    }
+    else if (pattern.startsWith("\\!")) {
+        pattern = pattern.slice(1);
+    }
+    if (pattern.startsWith("/"))
+        pattern = pattern.slice(1);
+    const prefixed = prefix ? `${prefix}${pattern}` : pattern;
+    return negated ? `!${prefixed}` : prefixed;
+}
+async function loadSkillFromFile(env, filePath) {
+    const diagnostics = [];
+    try {
+        const rawContent = await env.readTextFile(filePath);
+        const { frontmatter, body } = parseFrontmatter(rawContent);
+        const skillDir = dirnameEnvPath(filePath);
+        const parentDirName = basenameEnvPath(skillDir);
+        for (const error of validateDescription(frontmatter.description)) {
+            diagnostics.push({ type: "warning", message: error, path: filePath });
+        }
+        const name = frontmatter.name || parentDirName;
+        for (const error of validateName(name, parentDirName)) {
+            diagnostics.push({ type: "warning", message: error, path: filePath });
+        }
+        if (!frontmatter.description || frontmatter.description.trim() === "") {
+            return { skill: null, diagnostics };
+        }
+        return {
+            skill: {
+                name,
+                description: frontmatter.description,
+                content: body,
+                filePath,
+                disableModelInvocation: frontmatter["disable-model-invocation"] === true,
+            },
+            diagnostics,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "failed to parse skill file";
+        diagnostics.push({ type: "warning", message, path: filePath });
+        return { skill: null, diagnostics };
+    }
+}
+function validateName(name, parentDirName) {
+    const errors = [];
+    if (name !== parentDirName)
+        errors.push(`name "${name}" does not match parent directory "${parentDirName}"`);
+    if (name.length > MAX_NAME_LENGTH)
+        errors.push(`name exceeds ${MAX_NAME_LENGTH} characters (${name.length})`);
+    if (!/^[a-z0-9-]+$/.test(name)) {
+        errors.push("name contains invalid characters (must be lowercase a-z, 0-9, hyphens only)");
+    }
+    if (name.startsWith("-") || name.endsWith("-"))
+        errors.push("name must not start or end with a hyphen");
+    if (name.includes("--"))
+        errors.push("name must not contain consecutive hyphens");
+    return errors;
+}
+function validateDescription(description) {
+    const errors = [];
+    if (!description || description.trim() === "") {
+        errors.push("description is required");
+    }
+    else if (description.length > MAX_DESCRIPTION_LENGTH) {
+        errors.push(`description exceeds ${MAX_DESCRIPTION_LENGTH} characters (${description.length})`);
+    }
+    return errors;
+}
+function parseFrontmatter(content) {
+    const normalized = content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+    if (!normalized.startsWith("---"))
+        return { frontmatter: {}, body: normalized };
+    const endIndex = normalized.indexOf("\n---", 3);
+    if (endIndex === -1)
+        return { frontmatter: {}, body: normalized };
+    const yamlString = normalized.slice(4, endIndex);
+    const body = normalized.slice(endIndex + 4).trim();
+    return { frontmatter: (parse(yamlString) ?? {}), body };
+}
+async function safeFileInfo(env, path) {
+    try {
+        return await env.fileInfo(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveKind(env, info) {
+    if (info.kind === "file" || info.kind === "directory")
+        return info.kind;
+    try {
+        const realPath = await env.realPath(info.path);
+        const target = await env.fileInfo(realPath);
+        return target.kind === "file" || target.kind === "directory" ? target.kind : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function joinEnvPath(base, child) {
+    return `${base.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+}
+function dirnameEnvPath(path) {
+    const normalized = path.replace(/\/+$/, "");
+    const slashIndex = normalized.lastIndexOf("/");
+    return slashIndex <= 0 ? "/" : normalized.slice(0, slashIndex);
+}
+function basenameEnvPath(path) {
+    const normalized = path.replace(/\/+$/, "");
+    const slashIndex = normalized.lastIndexOf("/");
+    return slashIndex === -1 ? normalized : normalized.slice(slashIndex + 1);
+}
+function relativeEnvPath(root, path) {
+    const normalizedRoot = root.replace(/\/+$/, "");
+    const normalizedPath = path.replace(/\/+$/, "");
+    if (normalizedPath === normalizedRoot)
+        return "";
+    return normalizedPath.startsWith(`${normalizedRoot}/`)
+        ? normalizedPath.slice(normalizedRoot.length + 1)
+        : normalizedPath.replace(/^\/+/, "");
+}
+//# sourceMappingURL=skills.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/system-prompt.js

@@ -0,0 +1,30 @@
+export function formatSkillsForSystemPrompt(skills) {
+    const visibleSkills = skills.filter((skill) => !skill.disableModelInvocation);
+    if (visibleSkills.length === 0)
+        return "";
+    const lines = [
+        "The following skills provide specialized instructions for specific tasks.",
+        "Use the read tool to load a skill's file when the task matches its description.",
+        "When a skill file references a relative path, resolve it against the skill directory (parent of SKILL.md / dirname of the path) and use that absolute path in tool commands.",
+        "",
+        "<available_skills>",
+    ];
+    for (const skill of visibleSkills) {
+        lines.push("  <skill>");
+        lines.push(`    <name>${escapeXml(skill.name)}</name>`);
+        lines.push(`    <description>${escapeXml(skill.description)}</description>`);
+        lines.push(`    <location>${escapeXml(skill.filePath)}</location>`);
+        lines.push("  </skill>");
+    }
+    lines.push("</available_skills>");
+    return lines.join("\n");
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+//# sourceMappingURL=system-prompt.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/types.js

@@ -0,0 +1,16 @@
+/** Error thrown by {@link ExecutionEnv} file operations. */
+export class FileError extends Error {
+    code;
+    path;
+    constructor(
+    /** Backend-independent error code. */
+    code, message, 
+    /** Absolute addressed path associated with the failure, when available. */
+    path, options) {
+        super(message, options);
+        this.code = code;
+        this.path = path;
+        this.name = "FileError";
+    }
+}
+//# sourceMappingURL=types.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/harness/utils/shell-output.js

@@ -0,0 +1,97 @@
+import { randomBytes } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { DEFAULT_MAX_BYTES, truncateTail } from "./truncate.js";
+export function sanitizeBinaryOutput(str) {
+    return Array.from(str)
+        .filter((char) => {
+        const code = char.codePointAt(0);
+        if (code === undefined)
+            return false;
+        if (code === 0x09 || code === 0x0a || code === 0x0d)
+            return true;
+        if (code <= 0x1f)
+            return false;
+        if (code >= 0xfff9 && code <= 0xfffb)
+            return false;
+        return true;
+    })
+        .join("");
+}
+export async function executeShellWithCapture(env, command, options) {
+    const outputChunks = [];
+    let outputBytes = 0;
+    const maxOutputBytes = DEFAULT_MAX_BYTES * 2;
+    let tempFilePath;
+    let tempFileStream;
+    let totalBytes = 0;
+    const ensureTempFile = () => {
+        if (tempFilePath)
+            return;
+        const id = randomBytes(8).toString("hex");
+        tempFilePath = join(tmpdir(), `bash-${id}.log`);
+        tempFileStream = createWriteStream(tempFilePath);
+        for (const chunk of outputChunks) {
+            tempFileStream.write(chunk);
+        }
+    };
+    const onChunk = (chunk) => {
+        totalBytes += Buffer.byteLength(chunk, "utf-8");
+        const text = sanitizeBinaryOutput(chunk).replace(/\r/g, "");
+        if (totalBytes > DEFAULT_MAX_BYTES) {
+            ensureTempFile();
+        }
+        if (tempFileStream) {
+            tempFileStream.write(text);
+        }
+        outputChunks.push(text);
+        outputBytes += text.length;
+        while (outputBytes > maxOutputBytes && outputChunks.length > 1) {
+            const removed = outputChunks.shift();
+            outputBytes -= removed.length;
+        }
+        options?.onChunk?.(text);
+    };
+    try {
+        const result = await env.exec(command, {
+            ...(options ?? {}),
+            onStdout: onChunk,
+            onStderr: onChunk,
+        });
+        const fullOutput = outputChunks.join("");
+        const truncationResult = truncateTail(fullOutput);
+        if (truncationResult.truncated) {
+            ensureTempFile();
+        }
+        tempFileStream?.end();
+        const cancelled = options?.signal?.aborted ?? false;
+        return {
+            output: truncationResult.truncated ? truncationResult.content : fullOutput,
+            exitCode: cancelled ? undefined : result.exitCode,
+            cancelled,
+            truncated: truncationResult.truncated,
+            fullOutputPath: tempFilePath,
+        };
+    }
+    catch (err) {
+        if (options?.signal?.aborted) {
+            const fullOutput = outputChunks.join("");
+            const truncationResult = truncateTail(fullOutput);
+            if (truncationResult.truncated) {
+                ensureTempFile();
+            }
+            tempFileStream?.end();
+            return {
+                output: truncationResult.truncated ? truncationResult.content : fullOutput,
+                exitCode: undefined,
+                cancelled: true,
+                truncated: truncationResult.truncated,
+                fullOutputPath: tempFilePath,
+            };
+        }
+        tempFileStream?.end();
+        throw err;
+    }
+}
+//# sourceMappingURL=shell-output.js.map

package/node_modules/@earendil-works/pi-agent-core/dist/index.js

@@ -0,0 +1,26 @@
+// Core Agent
+export * from "./agent.js";
+// Loop functions
+export * from "./agent-loop.js";
+export * from "./harness/agent-harness.js";
+export { collectEntriesForBranchSummary, generateBranchSummary, prepareBranchEntries, } from "./harness/compaction/branch-summarization.js";
+export { calculateContextTokens, compact, DEFAULT_COMPACTION_SETTINGS, estimateContextTokens, estimateTokens, findCutPoint, findTurnStartIndex, generateSummary, getLastAssistantUsage, prepareCompaction, serializeConversation, shouldCompact, } from "./harness/compaction/compaction.js";
+export * from "./harness/execution-env.js";
+export * from "./harness/factory.js";
+export * from "./harness/messages.js";
+export * from "./harness/prompt-templates.js";
+export * from "./harness/session/repo/jsonl.js";
+export * from "./harness/session/repo/memory.js";
+export * from "./harness/session/repo/shared.js";
+export * from "./harness/session/session.js";
+export * from "./harness/skills.js";
+export * from "./harness/system-prompt.js";
+// Harness
+export * from "./harness/types.js";
+export * from "./harness/utils/shell-output.js";
+export * from "./harness/utils/truncate.js";
+// Proxy utilities
+export * from "./proxy.js";
+// Types
+export * from "./types.js";
+//# sourceMappingURL=index.js.map

package/node_modules/{@mariozechner → @earendil-works}/pi-agent-core/dist/proxy.js

@@ -3,7 +3,7 @@
  * The server manages auth and proxies requests to LLM providers.
  */
 // Internal import for JSON parsing utility
-import { EventStream, parseStreamingJson, } from "@mariozechner/pi-ai";
+import { EventStream, parseStreamingJson, } from "@earendil-works/pi-ai";
 // Create stream class matching ProxyMessageEventStream
 class ProxyMessageEventStream extends EventStream {
     constructor() {

package/node_modules/{@mariozechner → @earendil-works}/pi-agent-core/package.json

@@ -1,6 +1,6 @@
 {
-	"name": "@mariozechner/pi-agent-core",
-	"version": "0.72.1",
+	"name": "@earendil-works/pi-agent-core",
+	"version": "0.74.0",
 	"description": "General-purpose agent with transport abstraction, state management, and attachment support",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -17,8 +17,10 @@
 		"prepublishOnly": "npm run clean && npm run build"
 	},
 	"dependencies": {
-		"@mariozechner/pi-ai": "^0.72.1",
-		"typebox": "^1.1.24"
+		"@earendil-works/pi-ai": "^0.74.0",
+		"ignore": "^7.0.5",
+		"typebox": "^1.1.24",
+		"yaml": "^2.8.2"
 	},
 	"keywords": [
 		"ai",
@@ -31,7 +33,7 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "git+https://github.com/badlogic/pi-mono.git",
+		"url": "git+https://github.com/earendil-works/pi-mono.git",
 		"directory": "packages/agent"
 	},
 	"engines": {

package/node_modules/{@mariozechner → @earendil-works}/pi-ai/dist/cli.js

@@ -55,7 +55,7 @@ async function main() {
     const command = args[0];
     if (!command || command === "help" || command === "--help" || command === "-h") {
         const providerList = PROVIDERS.map((p) => `  ${p.id.padEnd(20)} ${p.name}`).join("\n");
-        console.log(`Usage: npx @mariozechner/pi-ai <command> [provider]
+        console.log(`Usage: npx @earendil-works/pi-ai <command> [provider]
 
 Commands:
   login [provider]  Login to an OAuth provider
@@ -65,9 +65,9 @@ Providers:
 ${providerList}
 
 Examples:
-  npx @mariozechner/pi-ai login              # interactive provider selection
-  npx @mariozechner/pi-ai login anthropic    # login to specific provider
-  npx @mariozechner/pi-ai list               # list providers
+  npx @earendil-works/pi-ai login              # interactive provider selection
+  npx @earendil-works/pi-ai login anthropic    # login to specific provider
+  npx @earendil-works/pi-ai list               # list providers
 `);
         return;
     }
@@ -98,7 +98,7 @@ Examples:
         }
         if (!PROVIDERS.some((p) => p.id === provider)) {
             console.error(`Unknown provider: ${provider}`);
-            console.error(`Use 'npx @mariozechner/pi-ai list' to see available providers`);
+            console.error(`Use 'npx @earendil-works/pi-ai list' to see available providers`);
             process.exit(1);
         }
         console.log(`Logging in to ${provider}...`);
@@ -106,7 +106,7 @@ Examples:
         return;
     }
     console.error(`Unknown command: ${command}`);
-    console.error(`Use 'npx @mariozechner/pi-ai --help' for usage`);
+    console.error(`Use 'npx @earendil-works/pi-ai --help' for usage`);
     process.exit(1);
 }
 main().catch((err) => {

package/node_modules/{@mariozechner → @earendil-works}/pi-ai/dist/env-api-keys.js

@@ -103,6 +103,7 @@ function getApiKeyEnvVars(provider) {
         "moonshotai-cn": "MOONSHOT_API_KEY",
         huggingface: "HF_TOKEN",
         fireworks: "FIREWORKS_API_KEY",
+        together: "TOGETHER_API_KEY",
         opencode: "OPENCODE_API_KEY",
         "opencode-go": "OPENCODE_API_KEY",
         "kimi-coding": "KIMI_API_KEY",