@aexol/spectral 0.7.1 → 0.7.5

package/dist/pi/coding-agent/core/skills.js

@@ -0,0 +1,386 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "fs";
+import ignore from "ignore";
+import { basename, dirname, join, relative, resolve, sep } from "path";
+import { CONFIG_DIR_NAME, getAgentDir } from "../config.js";
+import { parseFrontmatter } from "../utils/frontmatter.js";
+import { canonicalizePath, resolvePath } from "../utils/paths.js";
+import { createSyntheticSourceInfo } from "./source-info.js";
+/** Max name length per spec */
+const MAX_NAME_LENGTH = 64;
+/** Max description length per spec */
+const MAX_DESCRIPTION_LENGTH = 1024;
+const IGNORE_FILE_NAMES = [".gitignore", ".ignore", ".fdignore"];
+function toPosixPath(p) {
+    return p.split(sep).join("/");
+}
+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;
+}
+function addIgnoreRules(ig, dir, rootDir) {
+    const relativeDir = relative(rootDir, dir);
+    const prefix = relativeDir ? `${toPosixPath(relativeDir)}/` : "";
+    for (const filename of IGNORE_FILE_NAMES) {
+        const ignorePath = join(dir, filename);
+        if (!existsSync(ignorePath))
+            continue;
+        try {
+            const content = readFileSync(ignorePath, "utf-8");
+            const patterns = content
+                .split(/\r?\n/)
+                .map((line) => prefixIgnorePattern(line, prefix))
+                .filter((line) => Boolean(line));
+            if (patterns.length > 0) {
+                ig.add(patterns);
+            }
+        }
+        catch { }
+    }
+}
+/**
+ * Validate skill name per Agent Skills spec.
+ * Returns array of validation error messages (empty if valid).
+ */
+function validateName(name) {
+    const errors = [];
+    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;
+}
+/**
+ * Validate description per Agent Skills spec.
+ */
+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 createSkillSourceInfo(filePath, baseDir, source) {
+    switch (source) {
+        case "user":
+            return createSyntheticSourceInfo(filePath, {
+                source: "local",
+                scope: "user",
+                baseDir,
+            });
+        case "project":
+            return createSyntheticSourceInfo(filePath, {
+                source: "local",
+                scope: "project",
+                baseDir,
+            });
+        case "path":
+            return createSyntheticSourceInfo(filePath, {
+                source: "local",
+                baseDir,
+            });
+        default:
+            return createSyntheticSourceInfo(filePath, { source, baseDir });
+    }
+}
+/**
+ * Load skills from a directory.
+ *
+ * Discovery rules:
+ * - if a directory contains SKILL.md, treat it as a skill root and do not recurse further
+ * - otherwise, load direct .md children in the root
+ * - recurse into subdirectories to find SKILL.md
+ */
+export function loadSkillsFromDir(options) {
+    const { dir, source } = options;
+    return loadSkillsFromDirInternal(dir, source, true);
+}
+function loadSkillsFromDirInternal(dir, source, includeRootFiles, ignoreMatcher, rootDir) {
+    const skills = [];
+    const diagnostics = [];
+    if (!existsSync(dir)) {
+        return { skills, diagnostics };
+    }
+    const root = rootDir ?? dir;
+    const ig = ignoreMatcher ?? ignore();
+    addIgnoreRules(ig, dir, root);
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name !== "SKILL.md") {
+                continue;
+            }
+            const fullPath = join(dir, entry.name);
+            let isFile = entry.isFile();
+            if (entry.isSymbolicLink()) {
+                try {
+                    isFile = statSync(fullPath).isFile();
+                }
+                catch {
+                    continue;
+                }
+            }
+            const relPath = toPosixPath(relative(root, fullPath));
+            if (!isFile || ig.ignores(relPath)) {
+                continue;
+            }
+            const result = loadSkillFromFile(fullPath, source);
+            if (result.skill) {
+                skills.push(result.skill);
+            }
+            diagnostics.push(...result.diagnostics);
+            return { skills, diagnostics };
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".")) {
+                continue;
+            }
+            // Skip node_modules to avoid scanning dependencies
+            if (entry.name === "node_modules") {
+                continue;
+            }
+            const fullPath = join(dir, entry.name);
+            // For symlinks, check if they point to a directory and follow them
+            let isDirectory = entry.isDirectory();
+            let isFile = entry.isFile();
+            if (entry.isSymbolicLink()) {
+                try {
+                    const stats = statSync(fullPath);
+                    isDirectory = stats.isDirectory();
+                    isFile = stats.isFile();
+                }
+                catch {
+                    // Broken symlink, skip it
+                    continue;
+                }
+            }
+            const relPath = toPosixPath(relative(root, fullPath));
+            const ignorePath = isDirectory ? `${relPath}/` : relPath;
+            if (ig.ignores(ignorePath)) {
+                continue;
+            }
+            if (isDirectory) {
+                const subResult = loadSkillsFromDirInternal(fullPath, source, false, ig, root);
+                skills.push(...subResult.skills);
+                diagnostics.push(...subResult.diagnostics);
+                continue;
+            }
+            if (!isFile || !includeRootFiles || !entry.name.endsWith(".md")) {
+                continue;
+            }
+            const result = loadSkillFromFile(fullPath, source);
+            if (result.skill) {
+                skills.push(result.skill);
+            }
+            diagnostics.push(...result.diagnostics);
+        }
+    }
+    catch { }
+    return { skills, diagnostics };
+}
+function loadSkillFromFile(filePath, source) {
+    const diagnostics = [];
+    try {
+        const rawContent = readFileSync(filePath, "utf-8");
+        const { frontmatter } = parseFrontmatter(rawContent);
+        const skillDir = dirname(filePath);
+        const parentDirName = basename(skillDir);
+        // Validate description
+        const descErrors = validateDescription(frontmatter.description);
+        for (const error of descErrors) {
+            diagnostics.push({ type: "warning", message: error, path: filePath });
+        }
+        // Use name from frontmatter, or fall back to parent directory name
+        const name = frontmatter.name || parentDirName;
+        // Validate name
+        const nameErrors = validateName(name);
+        for (const error of nameErrors) {
+            diagnostics.push({ type: "warning", message: error, path: filePath });
+        }
+        // Still load the skill even with warnings (unless description is completely missing)
+        if (!frontmatter.description || frontmatter.description.trim() === "") {
+            return { skill: null, diagnostics };
+        }
+        return {
+            skill: {
+                name,
+                description: frontmatter.description,
+                filePath,
+                baseDir: skillDir,
+                sourceInfo: createSkillSourceInfo(filePath, skillDir, source),
+                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 };
+    }
+}
+/**
+ * Format skills for inclusion in a system prompt.
+ * Uses XML format per Agent Skills standard.
+ * See: https://agentskills.io/integrate-skills
+ *
+ * Skills with disableModelInvocation=true are excluded from the prompt
+ * (they can only be invoked explicitly via /skill:name commands).
+ */
+export function formatSkillsForPrompt(skills) {
+    const visibleSkills = skills.filter((s) => !s.disableModelInvocation);
+    if (visibleSkills.length === 0) {
+        return "";
+    }
+    const lines = [
+        "\n\nThe 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(str) {
+    return str
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&apos;");
+}
+/**
+ * Load skills from all configured locations.
+ * Returns skills and any validation diagnostics.
+ */
+export function loadSkills(options) {
+    const { agentDir, skillPaths, includeDefaults } = options;
+    // Resolve agentDir - if not provided, use default from config
+    const resolvedCwd = resolvePath(options.cwd);
+    const resolvedAgentDir = resolvePath(agentDir ?? getAgentDir());
+    const skillMap = new Map();
+    const realPathSet = new Set();
+    const allDiagnostics = [];
+    const collisionDiagnostics = [];
+    function addSkills(result) {
+        allDiagnostics.push(...result.diagnostics);
+        for (const skill of result.skills) {
+            // Resolve symlinks to detect duplicate files
+            const realPath = canonicalizePath(skill.filePath);
+            // Skip silently if we've already loaded this exact file (via symlink)
+            if (realPathSet.has(realPath)) {
+                continue;
+            }
+            const existing = skillMap.get(skill.name);
+            if (existing) {
+                collisionDiagnostics.push({
+                    type: "collision",
+                    message: `name "${skill.name}" collision`,
+                    path: skill.filePath,
+                    collision: {
+                        resourceType: "skill",
+                        name: skill.name,
+                        winnerPath: existing.filePath,
+                        loserPath: skill.filePath,
+                    },
+                });
+            }
+            else {
+                skillMap.set(skill.name, skill);
+                realPathSet.add(realPath);
+            }
+        }
+    }
+    if (includeDefaults) {
+        addSkills(loadSkillsFromDirInternal(join(resolvedAgentDir, "skills"), "user", true));
+        addSkills(loadSkillsFromDirInternal(resolve(resolvedCwd, CONFIG_DIR_NAME, "skills"), "project", true));
+    }
+    const userSkillsDir = join(resolvedAgentDir, "skills");
+    const projectSkillsDir = resolve(resolvedCwd, CONFIG_DIR_NAME, "skills");
+    const isUnderPath = (target, root) => {
+        const normalizedRoot = resolve(root);
+        if (target === normalizedRoot) {
+            return true;
+        }
+        const prefix = normalizedRoot.endsWith(sep) ? normalizedRoot : `${normalizedRoot}${sep}`;
+        return target.startsWith(prefix);
+    };
+    const getSource = (resolvedPath) => {
+        if (!includeDefaults) {
+            if (isUnderPath(resolvedPath, userSkillsDir))
+                return "user";
+            if (isUnderPath(resolvedPath, projectSkillsDir))
+                return "project";
+        }
+        return "path";
+    };
+    for (const rawPath of skillPaths) {
+        const resolvedPath = resolvePath(rawPath, resolvedCwd, { trim: true });
+        if (!existsSync(resolvedPath)) {
+            allDiagnostics.push({ type: "warning", message: "skill path does not exist", path: resolvedPath });
+            continue;
+        }
+        try {
+            const stats = statSync(resolvedPath);
+            const source = getSource(resolvedPath);
+            if (stats.isDirectory()) {
+                addSkills(loadSkillsFromDirInternal(resolvedPath, source, true));
+            }
+            else if (stats.isFile() && resolvedPath.endsWith(".md")) {
+                const result = loadSkillFromFile(resolvedPath, source);
+                if (result.skill) {
+                    addSkills({ skills: [result.skill], diagnostics: result.diagnostics });
+                }
+                else {
+                    allDiagnostics.push(...result.diagnostics);
+                }
+            }
+            else {
+                allDiagnostics.push({ type: "warning", message: "skill path is not a markdown file", path: resolvedPath });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : "failed to read skill path";
+            allDiagnostics.push({ type: "warning", message, path: resolvedPath });
+        }
+    }
+    return {
+        skills: Array.from(skillMap.values()),
+        diagnostics: [...allDiagnostics, ...collisionDiagnostics],
+    };
+}

package/dist/pi/coding-agent/core/slash-commands.js

@@ -0,0 +1,24 @@
+import { APP_NAME } from "../config.js";
+export const BUILTIN_SLASH_COMMANDS = [
+    { name: "settings", description: "Open settings menu" },
+    { name: "model", description: "Select model (opens selector UI)" },
+    { name: "scoped-models", description: "Enable/disable models for Ctrl+P cycling" },
+    { name: "export", description: "Export session (HTML default, or specify path: .html/.jsonl)" },
+    { name: "import", description: "Import and resume a session from a JSONL file" },
+    { name: "share", description: "Share session as a secret GitHub gist" },
+    { name: "copy", description: "Copy last agent message to clipboard" },
+    { name: "name", description: "Set session display name" },
+    { name: "session", description: "Show session info and stats" },
+    { name: "changelog", description: "Show changelog entries" },
+    { name: "hotkeys", description: "Show all keyboard shortcuts" },
+    { name: "fork", description: "Create a new fork from a previous user message" },
+    { name: "clone", description: "Duplicate the current session at the current position" },
+    { name: "tree", description: "Navigate session tree (switch branches)" },
+    { name: "login", description: "Configure provider authentication" },
+    { name: "logout", description: "Remove provider authentication" },
+    { name: "new", description: "Start a new session" },
+    { name: "compact", description: "Manually compact the session context" },
+    { name: "resume", description: "Resume a different session" },
+    { name: "reload", description: "Reload keybindings, extensions, skills, prompts, and themes" },
+    { name: "quit", description: `Quit ${APP_NAME}` },
+];

package/dist/pi/coding-agent/core/source-info.js

@@ -0,0 +1,18 @@
+export function createSourceInfo(path, metadata) {
+    return {
+        path,
+        source: metadata.source,
+        scope: metadata.scope,
+        origin: metadata.origin,
+        baseDir: metadata.baseDir,
+    };
+}
+export function createSyntheticSourceInfo(path, options) {
+    return {
+        path,
+        source: options.source,
+        scope: options.scope ?? "temporary",
+        origin: options.origin ?? "top-level",
+        baseDir: options.baseDir,
+    };
+}

package/dist/pi/coding-agent/core/system-prompt.js

@@ -0,0 +1,122 @@
+/**
+ * System prompt construction and project context loading
+ */
+import { getDocsPath, getExamplesPath, getReadmePath } from "../config.js";
+import { formatSkillsForPrompt } from "./skills.js";
+/** Build the system prompt with tools, guidelines, and context */
+export function buildSystemPrompt(options) {
+    const { customPrompt, selectedTools, toolSnippets, promptGuidelines, appendSystemPrompt, cwd, contextFiles: providedContextFiles, skills: providedSkills, } = options;
+    const resolvedCwd = cwd;
+    const promptCwd = resolvedCwd.replace(/\\/g, "/");
+    const now = new Date();
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, "0");
+    const day = String(now.getDate()).padStart(2, "0");
+    const date = `${year}-${month}-${day}`;
+    const appendSection = appendSystemPrompt ? `\n\n${appendSystemPrompt}` : "";
+    const contextFiles = providedContextFiles ?? [];
+    const skills = providedSkills ?? [];
+    if (customPrompt) {
+        let prompt = customPrompt;
+        if (appendSection) {
+            prompt += appendSection;
+        }
+        // Append project context files
+        if (contextFiles.length > 0) {
+            prompt += "\n\n<project_context>\n\n";
+            prompt += "Project-specific instructions and guidelines:\n\n";
+            for (const { path: filePath, content } of contextFiles) {
+                prompt += `<project_instructions path="${filePath}">\n${content}\n</project_instructions>\n\n`;
+            }
+            prompt += "</project_context>\n";
+        }
+        // Append skills section (only if read tool is available)
+        const customPromptHasRead = !selectedTools || selectedTools.includes("read");
+        if (customPromptHasRead && skills.length > 0) {
+            prompt += formatSkillsForPrompt(skills);
+        }
+        // Add date and working directory last
+        prompt += `\nCurrent date: ${date}`;
+        prompt += `\nCurrent working directory: ${promptCwd}`;
+        return prompt;
+    }
+    // Get absolute paths to documentation and examples
+    const readmePath = getReadmePath();
+    const docsPath = getDocsPath();
+    const examplesPath = getExamplesPath();
+    // Build tools list based on selected tools.
+    // A tool appears in Available tools only when the caller provides a one-line snippet.
+    const tools = selectedTools || ["read", "bash", "edit", "write"];
+    const visibleTools = tools.filter((name) => !!toolSnippets?.[name]);
+    const toolsList = visibleTools.length > 0 ? visibleTools.map((name) => `- ${name}: ${toolSnippets[name]}`).join("\n") : "(none)";
+    // Build guidelines based on which tools are actually available
+    const guidelinesList = [];
+    const guidelinesSet = new Set();
+    const addGuideline = (guideline) => {
+        if (guidelinesSet.has(guideline)) {
+            return;
+        }
+        guidelinesSet.add(guideline);
+        guidelinesList.push(guideline);
+    };
+    const hasBash = tools.includes("bash");
+    const hasGrep = tools.includes("grep");
+    const hasFind = tools.includes("find");
+    const hasLs = tools.includes("ls");
+    const hasRead = tools.includes("read");
+    // File exploration guidelines
+    if (hasBash && !hasGrep && !hasFind && !hasLs) {
+        addGuideline("Use bash for file operations like ls, rg, find");
+    }
+    else if (hasBash && (hasGrep || hasFind || hasLs)) {
+        addGuideline("Prefer grep/find/ls tools over bash for file exploration (faster, respects .gitignore)");
+    }
+    for (const guideline of promptGuidelines ?? []) {
+        const normalized = guideline.trim();
+        if (normalized.length > 0) {
+            addGuideline(normalized);
+        }
+    }
+    // Always include these
+    addGuideline("Be concise in your responses");
+    addGuideline("Show file paths clearly when working with files");
+    const guidelines = guidelinesList.map((g) => `- ${g}`).join("\n");
+    let prompt = `You are an expert coding assistant operating inside pi, a coding agent harness. You help users by reading files, executing commands, editing code, and writing new files.
+
+Available tools:
+${toolsList}
+
+In addition to the tools above, you may have access to other custom tools depending on the project.
+
+Guidelines:
+${guidelines}
+
+Pi documentation (read only when the user asks about pi itself, its SDK, extensions, themes, skills, or TUI):
+- Main documentation: ${readmePath}
+- Additional docs: ${docsPath}
+- Examples: ${examplesPath} (extensions, custom tools, SDK)
+- When reading pi docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory
+- When asked about: extensions (docs/extensions.md, examples/extensions/), themes (docs/themes.md), skills (docs/skills.md), prompt templates (docs/prompt-templates.md), TUI components (docs/tui.md), keybindings (docs/keybindings.md), SDK integrations (docs/sdk.md), custom providers (docs/custom-provider.md), adding models (docs/models.md), pi packages (docs/packages.md)
+- When working on pi topics, read the docs and examples, and follow .md cross-references before implementing
+- Always read pi .md files completely and follow links to related docs (e.g., tui.md for TUI API details)`;
+    if (appendSection) {
+        prompt += appendSection;
+    }
+    // Append project context files
+    if (contextFiles.length > 0) {
+        prompt += "\n\n<project_context>\n\n";
+        prompt += "Project-specific instructions and guidelines:\n\n";
+        for (const { path: filePath, content } of contextFiles) {
+            prompt += `<project_instructions path="${filePath}">\n${content}\n</project_instructions>\n\n`;
+        }
+        prompt += "</project_context>\n";
+    }
+    // Append skills section (only if read tool is available)
+    if (hasRead && skills.length > 0) {
+        prompt += formatSkillsForPrompt(skills);
+    }
+    // Add date and working directory last
+    prompt += `\nCurrent date: ${date}`;
+    prompt += `\nCurrent working directory: ${promptCwd}`;
+    return prompt;
+}

package/dist/pi/coding-agent/core/telemetry.js

@@ -0,0 +1,8 @@
+function isTruthyEnvFlag(value) {
+    if (!value)
+        return false;
+    return value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes";
+}
+export function isInstallTelemetryEnabled(settingsManager, telemetryEnv = process.env.PI_TELEMETRY) {
+    return telemetryEnv !== undefined ? isTruthyEnvFlag(telemetryEnv) : settingsManager.getEnableInstallTelemetry();
+}

package/dist/pi/coding-agent/core/timings.js

@@ -0,0 +1,30 @@
+/**
+ * Central timing instrumentation for startup profiling.
+ * Enable with PI_TIMING=1 environment variable.
+ */
+const ENABLED = process.env.PI_TIMING === "1";
+const timings = [];
+let lastTime = Date.now();
+export function resetTimings() {
+    if (!ENABLED)
+        return;
+    timings.length = 0;
+    lastTime = Date.now();
+}
+export function time(label) {
+    if (!ENABLED)
+        return;
+    const now = Date.now();
+    timings.push({ label, ms: now - lastTime });
+    lastTime = now;
+}
+export function printTimings() {
+    if (!ENABLED || timings.length === 0)
+        return;
+    console.error("\n--- Startup Timings ---");
+    for (const t of timings) {
+        console.error(`  ${t.label}: ${t.ms}ms`);
+    }
+    console.error(`  TOTAL: ${timings.reduce((a, b) => a + b.ms, 0)}ms`);
+    console.error("------------------------\n");
+}