zero-ai-cli 1.0.0

package/packages/core/src/permissions/index.ts

@@ -0,0 +1,126 @@
+/**
+ * ZERO Permission System
+ * Handles user approval flow for sensitive operations
+ *
+ * Sources:
+ * - crush: permission gates with auto-allow patterns
+ * - opencode: permission evaluation engine
+ * - gemini-cli: policy engine with TOML config
+ * - cline: approval flow with always-allow patterns
+ */
+
+import type {
+  PermissionHandler,
+  PermissionRequest,
+  PermissionDecision,
+  PermissionSet,
+  PermissionLevel,
+} from "../types.js";
+
+export interface PermissionRule {
+  pattern: string;
+  level: PermissionLevel;
+  reason?: string;
+}
+
+export interface PermissionConfig {
+  defaults: PermissionSet;
+  rules: PermissionRule[];
+  alwaysAllow: string[];
+  alwaysDeny: string[];
+}
+
+export const DEFAULT_PERMISSION_CONFIG: PermissionConfig = {
+  defaults: {
+    fileRead: "allow",
+    fileWrite: "ask",
+    shellExecution: "ask",
+    networkAccess: "ask",
+    mcpAccess: "allow",
+  },
+  rules: [],
+  alwaysAllow: [
+    "read_file",
+    "list_directory",
+    "search_files",
+    "search_code",
+    "git_status",
+    "git_diff",
+  ],
+  alwaysDeny: [],
+};
+
+/**
+ * Create a permission handler with configurable rules
+ */
+export function createPermissionHandler(
+  config: PermissionConfig = DEFAULT_PERMISSION_CONFIG,
+  interactiveHandler?: (request: PermissionRequest) => Promise<PermissionDecision>,
+): PermissionHandler {
+  const approvedPatterns = new Set(config.alwaysAllow);
+  const deniedPatterns = new Set(config.alwaysDeny);
+
+  return async (request: PermissionRequest): Promise<PermissionDecision> => {
+    // Check always-deny list
+    if (deniedPatterns.has(request.resource)) {
+      return "deny";
+    }
+
+    // Check always-allow list
+    if (approvedPatterns.has(request.resource)) {
+      return "allow";
+    }
+
+    // Check custom rules
+    for (const rule of config.rules) {
+      if (matchPattern(request.resource, rule.pattern)) {
+        if (rule.level === "allow") return "allow";
+        if (rule.level === "deny") return "deny";
+      }
+    }
+
+    // Check defaults based on type
+    const defaultLevel = getDefaultLevel(config.defaults, request.type);
+    if (defaultLevel === "allow") return "allow";
+    if (defaultLevel === "deny") return "deny";
+
+    // Ask user if interactive handler is available
+    if (interactiveHandler) {
+      const decision = await interactiveHandler(request);
+      if (decision === "allow_always") {
+        approvedPatterns.add(request.resource);
+        return "allow";
+      }
+      return decision;
+    }
+
+    // Default to deny if no interactive handler
+    return "deny";
+  };
+}
+
+function getDefaultLevel(defaults: PermissionSet, type: PermissionRequest["type"]): PermissionLevel {
+  switch (type) {
+    case "file_read": return defaults.fileRead;
+    case "file_write": return defaults.fileWrite;
+    case "shell": return defaults.shellExecution;
+    case "network": return defaults.networkAccess;
+    case "mcp": return defaults.mcpAccess;
+  }
+}
+
+function matchPattern(resource: string, pattern: string): boolean {
+  if (pattern === resource) return true;
+  if (pattern.includes("*")) {
+    const regex = new RegExp("^" + pattern.replace(/\*/g, ".*") + "$");
+    return regex.test(resource);
+  }
+  return false;
+}
+
+/**
+ * Non-interactive permission handler that auto-approves based on config
+ */
+export function createAutoPermissionHandler(config?: PermissionConfig): PermissionHandler {
+  return createPermissionHandler(config || DEFAULT_PERMISSION_CONFIG);
+}

package/packages/core/src/prompts/engine.ts

@@ -0,0 +1,188 @@
+/**
+ * ZERO Prompt Template Engine
+ * Adapted from: crush (Charm/Go) - MIT
+ *
+ * Template-based prompt generation with dynamic context injection.
+ * Supports Go-style templates with variables and conditionals.
+ */
+
+export interface PromptContext {
+  provider?: string;
+  model?: string;
+  workingDir?: string;
+  platform?: string;
+  date?: string;
+  isGitRepo?: boolean;
+  gitStatus?: string;
+  gitBranch?: string;
+  contextFiles?: Array<{ path: string; content: string }>;
+  skills?: string[];
+  userName?: string;
+  customVars?: Record<string, string>;
+}
+
+/**
+ * Simple template engine (Go template style)
+ * Supports: {{.Variable}}, {{if .Var}}...{{end}}, {{range .Arr}}...{{end}}
+ */
+export class PromptEngine {
+  private templates = new Map<string, string>();
+
+  /**
+   * Register a named template
+   */
+  register(name: string, template: string): void {
+    this.templates.set(name, template);
+  }
+
+  /**
+   * Render a template with context
+   */
+  render(templateOrName: string, context: PromptContext): string {
+    const template = this.templates.get(templateOrName) || templateOrName;
+    return this.processTemplate(template, context);
+  }
+
+  private processTemplate(template: string, ctx: PromptContext): string {
+    let result = template;
+
+    // Helper: convert PascalCase to camelCase for context lookup
+    const lookupValue = (varName: string): any => {
+      // Try exact match first
+      if ((ctx as any)[varName] !== undefined) return (ctx as any)[varName];
+      // Try camelCase version (PascalCase → camelCase)
+      const camelCase = varName.charAt(0).toLowerCase() + varName.slice(1);
+      if ((ctx as any)[camelCase] !== undefined) return (ctx as any)[camelCase];
+      // Try custom vars
+      if (ctx.customVars?.[varName] !== undefined) return ctx.customVars[varName];
+      if (ctx.customVars?.[camelCase] !== undefined) return ctx.customVars[camelCase];
+      return undefined;
+    };
+
+    // Process conditionals: {{if .Var}}...{{end}}
+    result = result.replace(/\{\{if\s+\.(\w+)\}\}([\s\S]*?)\{\{end\}\}/g, (_, varName, content) => {
+      const value = lookupValue(varName);
+      if (value) {
+        return this.processTemplate(content, ctx);
+      }
+      return "";
+    });
+
+    // Process variables: {{.Variable}}
+    result = result.replace(/\{\{\.(\w+)\}\}/g, (_, varName) => {
+      const value = lookupValue(varName);
+      if (value !== undefined && value !== null) return String(value);
+      return "";
+    });
+
+    // Process date
+    result = result.replace(/\{\{\.Date\}\}/g, ctx.date || new Date().toISOString().split("T")[0]);
+
+    // Process platform
+    result = result.replace(/\{\{\.Platform\}\}/g, ctx.platform || process.platform);
+
+    // Process context files
+    if (ctx.contextFiles && ctx.contextFiles.length > 0) {
+      result = result.replace(/\{\{range\s+\.ContextFiles\}\}([\s\S]*?)\{\{end\}\}/g, (_, inner) => {
+        return ctx.contextFiles!.map((file) => {
+          let rendered = inner;
+          rendered = rendered.replace(/\{\{\.Path\}\}/g, file.path);
+          rendered = rendered.replace(/\{\{\.Content\}\}/g, file.content);
+          return rendered;
+        }).join("\n");
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Build a full system prompt with all context
+   */
+  buildSystemPrompt(basePrompt: string, context: PromptContext): string {
+    const sections: string[] = [basePrompt];
+
+    if (context.workingDir) {
+      sections.push(`\n## Environment\n- Working Directory: ${context.workingDir}`);
+      sections.push(`- Platform: ${context.platform || process.platform}`);
+      sections.push(`- Date: ${context.date || new Date().toISOString().split("T")[0]}`);
+      if (context.model) sections.push(`- Model: ${context.model}`);
+      if (context.provider) sections.push(`- Provider: ${context.provider}`);
+    }
+
+    if (context.isGitRepo && context.gitBranch) {
+      sections.push(`\n## Git\n- Branch: ${context.gitBranch}`);
+      if (context.gitStatus) sections.push(`- Status: ${context.gitStatus}`);
+    }
+
+    if (context.contextFiles && context.contextFiles.length > 0) {
+      sections.push("\n## Context Files");
+      for (const file of context.contextFiles) {
+        sections.push(`\n### ${file.path}\n\`\`\`\n${file.content}\n\`\`\``);
+      }
+    }
+
+    return sections.join("\n");
+  }
+}
+
+/**
+ * Default ZERO system prompt
+ */
+export const ZERO_SYSTEM_PROMPT = `You are ZERO, an expert AI coding assistant with access to powerful tools.
+
+## Core Capabilities
+- Read, write, and edit files with precision
+- Execute shell commands safely
+- Search codebases efficiently
+- Generate diffs and apply patches
+- Manage git repositories
+- Lint code for quality issues
+- Generate repository maps
+
+## Guidelines
+1. Always read relevant files before making changes
+2. Use search/replace for precise edits (not full file rewrites)
+3. Explain your reasoning when making architectural decisions
+4. Follow existing code style and patterns
+5. Test changes when possible
+6. Ask for clarification when requirements are ambiguous
+
+## Tool Usage
+- Use read_file before editing to understand context
+- Use search_code to find relevant patterns
+- Use edit_file for targeted changes
+- Use lint to verify code quality
+- Use repo_map to understand project structure
+- Use git_diff to review changes before committing`;
+
+/**
+ * Create a pre-configured prompt engine
+ */
+export function createPromptEngine(): PromptEngine {
+  const engine = new PromptEngine();
+
+  engine.register("zero-system", ZERO_SYSTEM_PROMPT);
+
+  engine.register("code-review", `You are ZERO's code review specialist. Analyze the following code for:
+- Bugs and potential issues
+- Security vulnerabilities
+- Performance problems
+- Code style and best practices
+- Test coverage gaps
+
+{{if .WorkingDir}}Working directory: {{.WorkingDir}}{{end}}
+
+Provide clear, actionable feedback with specific line references.`);
+
+  engine.register("architect", `You are ZERO's software architect. Help design and plan:
+- System architecture and component design
+- API design and data models
+- Technology selection and trade-offs
+- Migration strategies
+
+{{if .WorkingDir}}Project: {{.WorkingDir}}{{end}}
+{{if .GitBranch}}Branch: {{.GitBranch}}{{end}}`);
+
+  return engine;
+}