@tomsun28/pizza 0.1.0 → 0.1.1

package/dist/core/system-prompt.js

@@ -0,0 +1,179 @@
+/**
+ * System prompt construction and project context loading
+ */
+import { existsSync } from "fs";
+import { execSync } from "child_process";
+import { formatSkillsForPrompt } from "./skills.js";
+/**
+ * Check if the current directory is a git repository
+ */
+function isGitRepository(cwd) {
+    try {
+        const gitDir = existsSync(cwd) ? cwd : process.cwd();
+        execSync("git rev-parse --is-inside-work-tree", { cwd: gitDir, stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Build the environment section to append at the end of the system prompt
+ */
+function buildEnvironmentSection(cwd) {
+    const resolvedCwd = cwd.replace(/\\/g, "/");
+    const isGit = isGitRepository(cwd);
+    const platform = process.platform;
+    const shell = process.env.SHELL || process.env.COMSPEC || "unknown";
+    const osVersion = process.version;
+    const nodeVersion = process.versions.node;
+    return `
+## Environment
+You are being called in the following environment:
+ - Primary working directory: ${resolvedCwd}
+ - Is Git repository: ${isGit ? "Yes" : "No"}
+ - Platform: ${platform}
+ - Shell: ${shell}
+ - Node.js version: ${nodeVersion}
+ - OS version: ${osVersion}
+`;
+}
+/** 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 += `## ${filePath}\n\n${content}\n\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}`;
+        // Add environment section at the end
+        prompt += buildEnvironmentSection(resolvedCwd);
+        return prompt;
+    }
+    // Build tools list - only cli is exposed via function calls.
+    // read/write/edit are handled internally by the cli tool;
+    // grep/find/ls and other commands are passed to the system shell as-is.
+    const tools = selectedTools || (toolSnippets ? Object.keys(toolSnippets) : ["cli"]);
+    const toolSnippetsMap = {
+        cli: "Execute CLI commands",
+        bash: "Execute shell commands",
+        ...toolSnippets,
+    };
+    const visibleTools = tools.filter((name) => !!toolSnippetsMap[name]);
+    const toolsList = visibleTools.length > 0
+        ? visibleTools.map((name) => `- ${name}: ${toolSnippetsMap[name]}`)
+        : "(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 hasCli = tools.includes("cli") || tools.includes("bash");
+    const hasRead = tools.includes("read");
+    // File exploration guidelines
+    if (hasCli) {
+        addGuideline("Use Pizza built-in file commands only for read, write, and edit");
+        addGuideline("Use shell commands such as grep, find, and ls normally; shell handles pipes, redirects, globs, &&, and ;");
+        addGuideline("Use read line anchors as edit range values; edit accepts op/range/new edits");
+    }
+    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");
+    // Native CLI commands documentation
+    const builtinCommandsSection = [
+        "## Built-in Commands (executed internally by the cli tool)",
+        "",
+        "The cli tool recognizes only the following Pizza built-in file commands and executes them internally (no shell fork):",
+        "",
+        "  read <path> [offset] [limit]                Read file content with 2-hex line anchors",
+        "  write <path> <content>                       Write content to file",
+        "  write <path> <<EOF\ncontent\nEOF             Write multi-line content (heredoc)",
+        "  edit <path> <op> <range> [new]               Edit anchored whole line(s)",
+        "",
+        "grep, find, ls, git, npm, and all other commands are passed to the system shell as-is.",
+        "The shell handles native pipes, redirects, globs, command grouping, &&, and ;. If grep/find/ls are missing from PATH, Pizza injects temporary per-process shims for only those missing commands.",
+        "",
+        "Examples:",
+        '- cli("read src/main.ts") - Read a file; text lines include <line>#<2-hex-hash> anchors',
+        '- cli("read src/main.ts 10 50") - Read lines 10-60',
+        '- cli("write output.txt Hello World") - Write to a file',
+        '- cli("edit src/main.ts replace 12#ab \"const value = 2\"") - Replace an anchored line',
+        '- cli("edit src/main.ts insert_after 12#ab \"const next = 3\"") - Insert after an anchored line',
+        '- cli("edit src/main.ts delete 12#ab..14#de") - Delete an anchored range',
+        '- cli("grep -rn \"foo\" . | head") - Search with native shell pipeline',
+        '- cli("find . -name \"*.py\" -maxdepth 2 | wc -l") - Find with native shell pipeline',
+        '- cli("ls -lah *.py") - List files with shell glob expansion',
+    ].join("\n");
+    let prompt = [
+        "You are an expert coding assistant. You help users by reading files, executing commands, editing code, and writing new files.",
+        "",
+        "Available tools:",
+        toolsList,
+        "",
+        builtinCommandsSection,
+        "",
+        "In addition to the tools above, you may have access to other custom tools depending on the project.",
+        "",
+        "Guidelines:",
+        guidelines,
+        "",
+        "Current date: " + date,
+        "Current working directory: " + promptCwd,
+    ].join("\n");
+    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 += `## ${filePath}\n\n${content}\n\n`;
+        }
+    }
+    // Append skills section (only if read tool is available)
+    if (hasRead && skills.length > 0) {
+        prompt += formatSkillsForPrompt(skills);
+    }
+    // Add environment section at the end
+    prompt += buildEnvironmentSection(resolvedCwd);
+    return prompt;
+}

package/dist/core/timings.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Central timing instrumentation for startup profiling.
+ * Enable with PIZZA_TIMING=1 environment variable.
+ */
+export declare function resetTimings(): void;
+export declare function time(label: string): void;
+export declare function printTimings(): void;

package/dist/core/timings.js

@@ -0,0 +1,30 @@
+/**
+ * Central timing instrumentation for startup profiling.
+ * Enable with PIZZA_TIMING=1 environment variable.
+ */
+const ENABLED = process.env.PIZZA_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");
+}

package/dist/core/tools/bash.d.ts

@@ -0,0 +1,95 @@
+import type { AgentTool } from "../agent/types.js";
+import { type Component } from "@earendil-works/pi-tui";
+import { type Static } from "@sinclair/typebox";
+import type { ToolDefinition } from "../extensions/types.js";
+import { type TruncationResult } from "./truncate.js";
+import { type EditToolDetails, type EditToolInput, type EditToolOptions } from "./edit.js";
+import { type ReadToolDetails, type ReadToolInput, type ReadToolOptions } from "./read.js";
+import { type WriteToolInput, type WriteToolOptions } from "./write.js";
+declare const bashSchema: import("@sinclair/typebox").TObject<{
+    command: import("@sinclair/typebox").TString;
+    timeout: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export type BashToolInput = Static<typeof bashSchema>;
+export interface BashToolDetails {
+    truncation?: TruncationResult;
+    fullOutputPath?: string;
+    builtin?: BashBuiltinDetails;
+}
+export type BashBuiltinDetails = {
+    name: "read";
+    args: ReadToolInput;
+    details?: ReadToolDetails;
+} | {
+    name: "write";
+    args: WriteToolInput;
+    details?: undefined;
+} | {
+    name: "edit";
+    args: EditToolInput;
+    details?: EditToolDetails;
+};
+/**
+ * Pluggable operations for the cli tool's shell execution path.
+ * Override these to delegate command execution to remote systems (for example SSH).
+ */
+export interface BashOperations {
+    /**
+     * Execute a command and stream output.
+     * @param command The command to execute
+     * @param cwd Working directory
+     * @param options Execution options
+     * @returns Promise resolving to exit code (null if killed)
+     */
+    exec: (command: string, cwd: string, options: {
+        onData: (data: Buffer) => void;
+        signal?: AbortSignal;
+        timeout?: number;
+        env?: NodeJS.ProcessEnv;
+    }) => Promise<{
+        exitCode: number | null;
+    }>;
+}
+/**
+ * Create bash operations using Pizza's built-in local shell execution backend.
+ *
+ * This is useful for extensions that intercept user_bash and still want Pizza's
+ * standard local shell behavior while wrapping or rewriting commands.
+ */
+export declare function createLocalBashOperations(options?: {
+    shellPath?: string;
+}): BashOperations;
+export interface BashSpawnContext {
+    command: string;
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+}
+export type BashSpawnHook = (context: BashSpawnContext) => BashSpawnContext;
+export interface BashToolOptions {
+    /** Custom operations for command execution. Default: local shell */
+    operations?: BashOperations;
+    /** Options used when routing the built-in read command through the read tool. */
+    read?: ReadToolOptions;
+    /** Options used when routing the built-in write command through the write tool. */
+    write?: WriteToolOptions;
+    /** Options used when routing the built-in edit command through the edit tool. */
+    edit?: EditToolOptions;
+    /** Command prefix prepended to every command (for example shell setup commands) */
+    commandPrefix?: string;
+    /** Optional explicit shell path from settings */
+    shellPath?: string;
+    /** Hook to adjust command, cwd, or env before execution */
+    spawnHook?: BashSpawnHook;
+}
+type BashRenderState = {
+    startedAt: number | undefined;
+    endedAt: number | undefined;
+    interval: NodeJS.Timeout | undefined;
+    builtinKey?: string;
+    builtinCallComponent?: Component;
+    builtinResultComponent?: Component;
+    builtinRendererState?: any;
+};
+export declare function createBashToolDefinition(cwd: string, options?: BashToolOptions): ToolDefinition<typeof bashSchema, BashToolDetails | undefined, BashRenderState>;
+export declare function createBashTool(cwd: string, options?: BashToolOptions): AgentTool<typeof bashSchema>;
+export {};