profclaw 2.0.0 → 2.4.0

package/dist/agents/permissions.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Permission Dialog System
+ *
+ * Manages per-session tool permissions with configurable rules.
+ * Dangerous tools always prompt; cautious tools prompt once then remember;
+ * safe tools (or unknown tools) are auto-allowed.
+ */
+export type PermissionLevel = 'safe' | 'cautious' | 'dangerous';
+export type PermissionResponse = 'allow' | 'deny' | 'always_allow' | 'always_deny';
+export interface PermissionRule {
+    toolName: string;
+    level: PermissionLevel;
+    reason: string;
+}
+export interface PermissionState {
+    /** Tools permanently allowed for this session */
+    autoAllow: Set<string>;
+    /** Tools permanently denied for this session */
+    autoDeny: Set<string>;
+}
+export interface PermissionCheckResult {
+    allowed: boolean;
+    reason?: string;
+}
+export declare const DEFAULT_PERMISSION_RULES: PermissionRule[];
+type PromptCallback = (toolName: string, args: unknown, rule: PermissionRule) => Promise<PermissionResponse>;
+export declare class PermissionManager {
+    private state;
+    private rules;
+    private promptCallback?;
+    constructor(rules?: PermissionRule[]);
+    /**
+     * Register the interactive prompt callback.
+     * Without this, all tools (including dangerous ones) are allowed — non-interactive mode.
+     */
+    setPromptCallback(cb: PromptCallback): void;
+    /**
+     * Check whether a tool call is permitted.
+     *
+     * Resolution order:
+     * 1. autoAllow set  → allowed immediately
+     * 2. autoDeny set   → denied immediately
+     * 3. No rule / safe → allowed
+     * 4. cautious/dangerous → invoke promptCallback
+     *    - allow       → allow once
+     *    - deny        → deny once
+     *    - always_allow → add to autoAllow, allow
+     *    - always_deny  → add to autoDeny, deny
+     * 5. No callback registered → allow (non-interactive)
+     */
+    check(toolName: string, args?: unknown): Promise<PermissionCheckResult>;
+    /**
+     * Return the permission level for a tool, or 'safe' if no rule exists.
+     */
+    getLevel(toolName: string): PermissionLevel;
+    /**
+     * Clear session-level autoAllow/autoDeny sets.
+     * Useful when starting a fresh session without constructing a new manager.
+     */
+    reset(): void;
+}
+export {};
+//# sourceMappingURL=permissions.d.ts.map

package/dist/agents/permissions.js

@@ -0,0 +1,138 @@
+/**
+ * Permission Dialog System
+ *
+ * Manages per-session tool permissions with configurable rules.
+ * Dangerous tools always prompt; cautious tools prompt once then remember;
+ * safe tools (or unknown tools) are auto-allowed.
+ */
+import { createContextualLogger } from '../utils/logger.js';
+const log = createContextualLogger('PermissionManager');
+// ---------------------------------------------------------------------------
+// Default rules
+// ---------------------------------------------------------------------------
+export const DEFAULT_PERMISSION_RULES = [
+    // Dangerous — always ask
+    { toolName: 'bash', level: 'dangerous', reason: 'Executes arbitrary shell commands' },
+    { toolName: 'exec', level: 'dangerous', reason: 'Executes arbitrary shell commands' },
+    { toolName: 'delete_file', level: 'dangerous', reason: 'Permanently deletes files' },
+    { toolName: 'git_push', level: 'dangerous', reason: 'Pushes changes to remote repository' },
+    {
+        toolName: 'git_force_push',
+        level: 'dangerous',
+        reason: 'Force pushes, potentially losing remote changes',
+    },
+    // Cautious — ask first time, then remember
+    { toolName: 'write_file', level: 'cautious', reason: 'Modifies files on disk' },
+    { toolName: 'patch_file', level: 'cautious', reason: 'Modifies files on disk' },
+    { toolName: 'move_file', level: 'cautious', reason: 'Moves/renames files' },
+    { toolName: 'git_commit', level: 'cautious', reason: 'Creates git commits' },
+    { toolName: 'git_branch', level: 'cautious', reason: 'Creates/switches git branches' },
+    // Safe — auto-allow (read_file, search_files, git_status, git_diff, etc.)
+];
+export class PermissionManager {
+    state;
+    rules;
+    promptCallback;
+    constructor(rules = DEFAULT_PERMISSION_RULES) {
+        this.state = {
+            autoAllow: new Set(),
+            autoDeny: new Set(),
+        };
+        this.rules = new Map();
+        for (const rule of rules) {
+            this.rules.set(rule.toolName, rule);
+        }
+    }
+    /**
+     * Register the interactive prompt callback.
+     * Without this, all tools (including dangerous ones) are allowed — non-interactive mode.
+     */
+    setPromptCallback(cb) {
+        this.promptCallback = cb;
+    }
+    /**
+     * Check whether a tool call is permitted.
+     *
+     * Resolution order:
+     * 1. autoAllow set  → allowed immediately
+     * 2. autoDeny set   → denied immediately
+     * 3. No rule / safe → allowed
+     * 4. cautious/dangerous → invoke promptCallback
+     *    - allow       → allow once
+     *    - deny        → deny once
+     *    - always_allow → add to autoAllow, allow
+     *    - always_deny  → add to autoDeny, deny
+     * 5. No callback registered → allow (non-interactive)
+     */
+    async check(toolName, args) {
+        // 1. Session-level auto-allow
+        if (this.state.autoAllow.has(toolName)) {
+            log.debug('Tool auto-allowed (session rule)', { tool: toolName });
+            return { allowed: true };
+        }
+        // 2. Session-level auto-deny
+        if (this.state.autoDeny.has(toolName)) {
+            log.info('Tool auto-denied (session rule)', { tool: toolName });
+            return { allowed: false, reason: `Tool "${toolName}" has been denied for this session` };
+        }
+        // 3. Look up permission rule
+        const rule = this.rules.get(toolName);
+        if (!rule || rule.level === 'safe') {
+            return { allowed: true };
+        }
+        // 4. cautious or dangerous — need user confirmation
+        if (!this.promptCallback) {
+            // Non-interactive mode: allow but log
+            log.warn('No prompt callback registered — allowing tool in non-interactive mode', {
+                tool: toolName,
+                level: rule.level,
+            });
+            return { allowed: true };
+        }
+        log.debug('Prompting user for permission', { tool: toolName, level: rule.level });
+        let response;
+        try {
+            response = await this.promptCallback(toolName, args, rule);
+        }
+        catch (error) {
+            log.error('[PermissionManager] Prompt callback threw', {
+                tool: toolName,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            // Fail-safe: deny on callback error
+            return { allowed: false, reason: 'Permission prompt failed' };
+        }
+        switch (response) {
+            case 'allow':
+                log.debug('User allowed tool (once)', { tool: toolName });
+                return { allowed: true };
+            case 'deny':
+                log.info('User denied tool (once)', { tool: toolName });
+                return { allowed: false, reason: `User denied "${toolName}"` };
+            case 'always_allow':
+                this.state.autoAllow.add(toolName);
+                log.info('User always-allowed tool for session', { tool: toolName });
+                return { allowed: true };
+            case 'always_deny':
+                this.state.autoDeny.add(toolName);
+                log.info('User always-denied tool for session', { tool: toolName });
+                return { allowed: false, reason: `User permanently denied "${toolName}" for this session` };
+        }
+    }
+    /**
+     * Return the permission level for a tool, or 'safe' if no rule exists.
+     */
+    getLevel(toolName) {
+        return this.rules.get(toolName)?.level ?? 'safe';
+    }
+    /**
+     * Clear session-level autoAllow/autoDeny sets.
+     * Useful when starting a fresh session without constructing a new manager.
+     */
+    reset() {
+        this.state.autoAllow.clear();
+        this.state.autoDeny.clear();
+        log.debug('PermissionManager session state reset');
+    }
+}
+//# sourceMappingURL=permissions.js.map

package/dist/agents/plan-mode.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Plan Mode - Two-phase workflow for agent task planning and execution
+ *
+ * Provides plan storage and management. Plans are persisted to
+ * .profclaw/plans/{id}.json inside the project root (or home dir fallback).
+ */
+export interface PlanStep {
+    index: number;
+    description: string;
+    status: 'pending' | 'in_progress' | 'completed' | 'skipped';
+    files?: string[];
+    estimatedEffort?: 'small' | 'medium' | 'large';
+}
+export interface Plan {
+    id: string;
+    taskId?: string;
+    title: string;
+    steps: PlanStep[];
+    status: 'draft' | 'approved' | 'in_progress' | 'completed' | 'rejected';
+    rejectionReason?: string;
+    createdAt: number;
+    approvedAt?: number;
+    completedAt?: number;
+}
+export declare class PlanManager {
+    private plans;
+    private plansDir;
+    constructor(projectRoot?: string);
+    /** Load all persisted plans from disk into memory */
+    private _loadAll;
+    /**
+     * Create a new plan in draft status.
+     */
+    create(title: string, steps: Omit<PlanStep, 'status'>[]): Plan;
+    /**
+     * Approve a draft plan, transitioning it to in_progress.
+     */
+    approve(planId: string): Plan;
+    /**
+     * Reject a draft plan.
+     */
+    reject(planId: string, reason?: string): Plan;
+    /**
+     * Update the status of a specific step. Automatically marks the plan as
+     * completed when all steps are either completed or skipped.
+     */
+    updateStep(planId: string, stepIndex: number, status: PlanStep['status']): Plan;
+    /**
+     * Get a plan by ID. Returns undefined if not found.
+     */
+    get(planId: string): Plan | undefined;
+    /**
+     * Returns the currently active (in_progress) plan, if any.
+     */
+    getActive(): Plan | undefined;
+    /**
+     * Returns all plans, sorted newest first.
+     */
+    list(): Plan[];
+    /**
+     * Persist a plan to .profclaw/plans/{id}.json
+     */
+    save(plan: Plan): void;
+    /**
+     * Load a single plan from disk by ID.
+     */
+    load(planId: string): Plan | undefined;
+    private _getOrThrow;
+}
+export declare const planManager: PlanManager;
+//# sourceMappingURL=plan-mode.d.ts.map

package/dist/agents/plan-mode.js

@@ -0,0 +1,186 @@
+/**
+ * Plan Mode - Two-phase workflow for agent task planning and execution
+ *
+ * Provides plan storage and management. Plans are persisted to
+ * .profclaw/plans/{id}.json inside the project root (or home dir fallback).
+ */
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { logger } from '../utils/logger.js';
+// Helpers
+function resolvePlansDir(projectRoot) {
+    const base = projectRoot ?? process.cwd();
+    return join(base, '.profclaw', 'plans');
+}
+function ensureDir(dir) {
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+}
+// PlanManager
+export class PlanManager {
+    plans;
+    plansDir;
+    constructor(projectRoot) {
+        this.plans = new Map();
+        this.plansDir = resolvePlansDir(projectRoot ?? homedir());
+        this._loadAll();
+    }
+    /** Load all persisted plans from disk into memory */
+    _loadAll() {
+        try {
+            if (!existsSync(this.plansDir))
+                return;
+            const files = readdirSync(this.plansDir).filter((f) => f.endsWith('.json'));
+            for (const file of files) {
+                const planId = file.replace(/\.json$/, '');
+                const plan = this.load(planId);
+                if (plan) {
+                    this.plans.set(plan.id, plan);
+                }
+            }
+        }
+        catch (err) {
+            logger.warn('[PlanManager] Failed to load plans from disk:', { error: String(err) });
+        }
+    }
+    /**
+     * Create a new plan in draft status.
+     */
+    create(title, steps) {
+        const plan = {
+            id: randomUUID(),
+            title,
+            steps: steps.map((s) => ({ ...s, status: 'pending' })),
+            status: 'draft',
+            createdAt: Date.now(),
+        };
+        this.plans.set(plan.id, plan);
+        this.save(plan);
+        logger.info('[PlanManager] Plan created:', { id: plan.id, title, stepCount: steps.length });
+        return plan;
+    }
+    /**
+     * Approve a draft plan, transitioning it to in_progress.
+     */
+    approve(planId) {
+        const plan = this._getOrThrow(planId);
+        if (plan.status !== 'draft') {
+            throw new Error(`Plan ${planId} is not in draft status (current: ${plan.status})`);
+        }
+        const updated = {
+            ...plan,
+            status: 'in_progress',
+            approvedAt: Date.now(),
+        };
+        this.plans.set(planId, updated);
+        this.save(updated);
+        logger.info('[PlanManager] Plan approved:', { id: planId });
+        return updated;
+    }
+    /**
+     * Reject a draft plan.
+     */
+    reject(planId, reason) {
+        const plan = this._getOrThrow(planId);
+        if (plan.status !== 'draft') {
+            throw new Error(`Plan ${planId} is not in draft status (current: ${plan.status})`);
+        }
+        const updated = {
+            ...plan,
+            status: 'rejected',
+            rejectionReason: reason,
+        };
+        this.plans.set(planId, updated);
+        this.save(updated);
+        logger.info('[PlanManager] Plan rejected:', { id: planId, reason });
+        return updated;
+    }
+    /**
+     * Update the status of a specific step. Automatically marks the plan as
+     * completed when all steps are either completed or skipped.
+     */
+    updateStep(planId, stepIndex, status) {
+        const plan = this._getOrThrow(planId);
+        const stepIdx = plan.steps.findIndex((s) => s.index === stepIndex);
+        if (stepIdx === -1) {
+            throw new Error(`Step ${stepIndex} not found in plan ${planId}`);
+        }
+        const updatedSteps = plan.steps.map((s) => s.index === stepIndex ? { ...s, status } : s);
+        const allDone = updatedSteps.every((s) => s.status === 'completed' || s.status === 'skipped');
+        const updated = {
+            ...plan,
+            steps: updatedSteps,
+            status: allDone ? 'completed' : plan.status,
+            completedAt: allDone ? Date.now() : plan.completedAt,
+        };
+        this.plans.set(planId, updated);
+        this.save(updated);
+        return updated;
+    }
+    /**
+     * Get a plan by ID. Returns undefined if not found.
+     */
+    get(planId) {
+        return this.plans.get(planId);
+    }
+    /**
+     * Returns the currently active (in_progress) plan, if any.
+     */
+    getActive() {
+        for (const plan of this.plans.values()) {
+            if (plan.status === 'in_progress') {
+                return plan;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Returns all plans, sorted newest first.
+     */
+    list() {
+        return Array.from(this.plans.values()).sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /**
+     * Persist a plan to .profclaw/plans/{id}.json
+     */
+    save(plan) {
+        try {
+            ensureDir(this.plansDir);
+            const filePath = join(this.plansDir, `${plan.id}.json`);
+            writeFileSync(filePath, JSON.stringify(plan, null, 2), 'utf-8');
+        }
+        catch (err) {
+            logger.error('[PlanManager] Failed to save plan:', err);
+        }
+    }
+    /**
+     * Load a single plan from disk by ID.
+     */
+    load(planId) {
+        try {
+            const filePath = join(this.plansDir, `${planId}.json`);
+            if (!existsSync(filePath))
+                return undefined;
+            const raw = readFileSync(filePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            logger.warn(`[PlanManager] Failed to load plan ${planId}:`, { error: String(err) });
+            return undefined;
+        }
+    }
+    // Private helpers
+    _getOrThrow(planId) {
+        const plan = this.plans.get(planId);
+        if (!plan) {
+            throw new Error(`Plan not found: ${planId}`);
+        }
+        return plan;
+    }
+}
+// Singleton instance used by tools and CLI commands
+export const planManager = new PlanManager();
+//# sourceMappingURL=plan-mode.js.map

package/dist/agents/prompt-suggestions.d.ts

@@ -0,0 +1,33 @@
+/**
+ * PromptSuggestionEngine
+ *
+ * Generates contextual follow-up prompt suggestions based on the current
+ * conversation context. All logic is local — no LLM calls.
+ */
+export interface Suggestion {
+    text: string;
+    category: 'follow-up' | 'deeper' | 'related' | 'action';
+}
+export interface SuggestionContext {
+    lastUserMessage: string;
+    lastAssistantResponse: string;
+    toolsUsed?: string[];
+    conversationLength: number;
+}
+export declare class PromptSuggestionEngine {
+    /**
+     * Generate up to 3 contextual follow-up suggestions.
+     *
+     * Rules (local, no LLM):
+     * - If assistant mentioned code → "Can you explain X?" or "Write tests for this"
+     * - If assistant used tools    → "What else can you do with {tool}?"
+     * - If short conversation      → exploratory prompts
+     * - If error was mentioned     → "How do I fix this?" or "What caused this?"
+     * - If file was edited         → "Show me the diff" or "Run the tests"
+     * - Vary by conversation length (early = broad, late = specific)
+     * - Always cap at 3
+     */
+    generateSuggestions(context: SuggestionContext): Suggestion[];
+}
+export declare function getPromptSuggestionEngine(): PromptSuggestionEngine;
+//# sourceMappingURL=prompt-suggestions.d.ts.map