overai 1.4.0

package/dist/cli/config/load.js

@@ -0,0 +1,229 @@
+"use strict";
+/**
+ * Config file loading
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfigFile = loadConfigFile;
+exports.loadConfig = loadConfig;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const cli_spec_1 = require("../spec/cli-spec");
+const schema_1 = require("./schema");
+/**
+ * Find config file in directory hierarchy
+ */
+function findConfigFile(startDir) {
+    let currentDir = startDir;
+    while (true) {
+        for (const filename of cli_spec_1.CONFIG_FILES) {
+            const filePath = path.join(currentDir, filename);
+            if (fs.existsSync(filePath)) {
+                return filePath;
+            }
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            break; // Reached root
+        }
+        currentDir = parentDir;
+    }
+    return null;
+}
+/**
+ * Find user config file
+ */
+function findUserConfigFile() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE;
+    if (!homeDir)
+        return null;
+    for (const filename of cli_spec_1.CONFIG_FILES) {
+        const filePath = path.join(homeDir, filename);
+        if (fs.existsSync(filePath)) {
+            return filePath;
+        }
+    }
+    return null;
+}
+/**
+ * Parse config file content
+ */
+function parseConfigFile(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const ext = path.extname(filePath).toLowerCase();
+    if (ext === '.json') {
+        return JSON.parse(content);
+    }
+    if (ext === '.yaml' || ext === '.yml') {
+        // Simple YAML parsing for basic config
+        // For complex YAML, we'd need a proper parser
+        return parseSimpleYaml(content);
+    }
+    throw new Error(`Unsupported config file format: ${ext}`);
+}
+/**
+ * Simple YAML parser for basic key-value configs
+ * Handles: strings, booleans, numbers, simple objects
+ */
+function parseSimpleYaml(content) {
+    const result = {};
+    const lines = content.split('\n');
+    let currentObject = null;
+    let currentKey = null;
+    let baseIndent = 0;
+    for (const line of lines) {
+        // Skip empty lines and comments
+        if (!line.trim() || line.trim().startsWith('#')) {
+            continue;
+        }
+        const indent = line.search(/\S/);
+        const trimmed = line.trim();
+        // Check for key: value pattern
+        const colonIndex = trimmed.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const key = trimmed.slice(0, colonIndex).trim();
+        const value = trimmed.slice(colonIndex + 1).trim();
+        if (indent === 0) {
+            // Top-level key
+            if (value === '' || value === '{}') {
+                // Start of nested object
+                currentObject = {};
+                currentKey = key;
+                baseIndent = indent;
+                result[key] = currentObject;
+            }
+            else {
+                result[key] = parseYamlValue(value);
+                currentObject = null;
+                currentKey = null;
+            }
+        }
+        else if (currentObject !== null && indent > baseIndent) {
+            // Nested key
+            if (value === '' || value === '{}') {
+                // Nested object within nested object
+                const nestedObj = {};
+                currentObject[key] = nestedObj;
+                // For simplicity, we only support one level of nesting in profiles
+            }
+            else {
+                currentObject[key] = parseYamlValue(value);
+            }
+        }
+    }
+    return result;
+}
+function parseYamlValue(value) {
+    // Remove quotes
+    if ((value.startsWith('"') && value.endsWith('"')) ||
+        (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    // Boolean
+    if (value === 'true')
+        return true;
+    if (value === 'false')
+        return false;
+    // Number
+    const num = Number(value);
+    if (!isNaN(num) && value !== '')
+        return num;
+    return value;
+}
+/**
+ * Load config from file
+ */
+function loadConfigFile(filePath) {
+    try {
+        const parsed = parseConfigFile(filePath);
+        if (!(0, schema_1.validateConfig)(parsed)) {
+            throw new Error('Invalid config format');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Failed to load config from ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Load config with resolution order:
+ * 1. Explicit config path
+ * 2. Project config (current dir and parents)
+ * 3. User config (~/.praisonai.yaml)
+ * 4. Defaults
+ */
+function loadConfig(options = {}) {
+    const configs = [schema_1.DEFAULT_CONFIG];
+    // User config
+    const userConfigPath = findUserConfigFile();
+    if (userConfigPath) {
+        try {
+            configs.push(loadConfigFile(userConfigPath));
+        }
+        catch {
+            // Ignore user config errors
+        }
+    }
+    // Project config
+    const cwd = options.cwd || process.cwd();
+    const projectConfigPath = findConfigFile(cwd);
+    if (projectConfigPath) {
+        try {
+            configs.push(loadConfigFile(projectConfigPath));
+        }
+        catch {
+            // Ignore project config errors
+        }
+    }
+    // Explicit config path
+    if (options.configPath) {
+        configs.push(loadConfigFile(options.configPath));
+    }
+    // Merge all configs
+    const result = { ...schema_1.DEFAULT_CONFIG };
+    for (const config of configs) {
+        if (config.model !== undefined)
+            result.model = config.model;
+        if (config.verbose !== undefined)
+            result.verbose = config.verbose;
+        if (config.stream !== undefined)
+            result.stream = config.stream;
+        if (config.profiles !== undefined) {
+            result.profiles = { ...result.profiles, ...config.profiles };
+        }
+    }
+    return result;
+}

package/dist/cli/config/resolve.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Config resolution with profiles and CLI overrides
+ */
+export interface ResolvedConfig {
+    model: string;
+    verbose: boolean;
+    stream: boolean;
+}
+export interface ResolveOptions {
+    configPath?: string;
+    profile?: string;
+    model?: string;
+    verbose?: boolean;
+    stream?: boolean;
+}
+/**
+ * Resolve final config with precedence:
+ * 1. CLI flags (highest)
+ * 2. Environment variables
+ * 3. Profile settings
+ * 4. Config file
+ * 5. Defaults (lowest)
+ */
+export declare function resolveConfig(options?: ResolveOptions): ResolvedConfig;
+/**
+ * Get available profile names
+ */
+export declare function getAvailableProfiles(configPath?: string): string[];

package/dist/cli/config/resolve.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Config resolution with profiles and CLI overrides
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfig = resolveConfig;
+exports.getAvailableProfiles = getAvailableProfiles;
+const load_1 = require("./load");
+const env_1 = require("../runtime/env");
+const schema_1 = require("./schema");
+/**
+ * Resolve final config with precedence:
+ * 1. CLI flags (highest)
+ * 2. Environment variables
+ * 3. Profile settings
+ * 4. Config file
+ * 5. Defaults (lowest)
+ */
+function resolveConfig(options = {}) {
+    // Load base config from files
+    const fileConfig = (0, load_1.loadConfig)({ configPath: options.configPath });
+    // Load env config
+    const envConfig = (0, env_1.loadEnvConfig)();
+    // Get profile config if specified
+    let profileConfig = {};
+    const profileName = options.profile || envConfig.profile;
+    if (profileName && fileConfig.profiles?.[profileName]) {
+        profileConfig = fileConfig.profiles[profileName];
+    }
+    // Resolve with precedence
+    const resolved = {
+        model: schema_1.DEFAULT_CONFIG.model,
+        verbose: schema_1.DEFAULT_CONFIG.verbose,
+        stream: schema_1.DEFAULT_CONFIG.stream
+    };
+    // Apply file config
+    if (fileConfig.model !== undefined)
+        resolved.model = fileConfig.model;
+    if (fileConfig.verbose !== undefined)
+        resolved.verbose = fileConfig.verbose;
+    if (fileConfig.stream !== undefined)
+        resolved.stream = fileConfig.stream;
+    // Apply profile config
+    if (profileConfig.model !== undefined)
+        resolved.model = profileConfig.model;
+    if (profileConfig.verbose !== undefined)
+        resolved.verbose = profileConfig.verbose;
+    if (profileConfig.stream !== undefined)
+        resolved.stream = profileConfig.stream;
+    // Apply env config
+    if (envConfig.model !== undefined)
+        resolved.model = envConfig.model;
+    if (envConfig.verbose !== undefined)
+        resolved.verbose = envConfig.verbose;
+    // Apply CLI flags (highest precedence)
+    if (options.model !== undefined)
+        resolved.model = options.model;
+    if (options.verbose !== undefined)
+        resolved.verbose = options.verbose;
+    if (options.stream !== undefined)
+        resolved.stream = options.stream;
+    return resolved;
+}
+/**
+ * Get available profile names
+ */
+function getAvailableProfiles(configPath) {
+    const config = (0, load_1.loadConfig)({ configPath });
+    return Object.keys(config.profiles || {});
+}

package/dist/cli/config/schema.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Config schema definitions
+ */
+import { ConfigSchema } from '../spec/cli-spec';
+export interface ProfileConfig {
+    model?: string;
+    verbose?: boolean;
+    stream?: boolean;
+}
+export interface FullConfig extends ConfigSchema {
+    profiles?: Record<string, ProfileConfig>;
+}
+export declare const DEFAULT_CONFIG: FullConfig;
+export declare function validateConfig(config: unknown): config is FullConfig;
+export declare function mergeConfigs(...configs: Partial<FullConfig>[]): FullConfig;

package/dist/cli/config/schema.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Config schema definitions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONFIG = void 0;
+exports.validateConfig = validateConfig;
+exports.mergeConfigs = mergeConfigs;
+exports.DEFAULT_CONFIG = {
+    model: 'openai/gpt-4o-mini',
+    verbose: false,
+    stream: false,
+    profiles: {}
+};
+function validateConfig(config) {
+    if (typeof config !== 'object' || config === null) {
+        return false;
+    }
+    const c = config;
+    if (c.model !== undefined && typeof c.model !== 'string') {
+        return false;
+    }
+    if (c.verbose !== undefined && typeof c.verbose !== 'boolean') {
+        return false;
+    }
+    if (c.stream !== undefined && typeof c.stream !== 'boolean') {
+        return false;
+    }
+    if (c.profiles !== undefined) {
+        if (typeof c.profiles !== 'object' || c.profiles === null) {
+            return false;
+        }
+        for (const profile of Object.values(c.profiles)) {
+            if (typeof profile !== 'object' || profile === null) {
+                return false;
+            }
+            const p = profile;
+            if (p.model !== undefined && typeof p.model !== 'string') {
+                return false;
+            }
+            if (p.verbose !== undefined && typeof p.verbose !== 'boolean') {
+                return false;
+            }
+            if (p.stream !== undefined && typeof p.stream !== 'boolean') {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+function mergeConfigs(...configs) {
+    const result = { ...exports.DEFAULT_CONFIG };
+    for (const config of configs) {
+        if (config.model !== undefined)
+            result.model = config.model;
+        if (config.verbose !== undefined)
+            result.verbose = config.verbose;
+        if (config.stream !== undefined)
+            result.stream = config.stream;
+        if (config.profiles !== undefined) {
+            result.profiles = { ...result.profiles, ...config.profiles };
+        }
+    }
+    return result;
+}

package/dist/cli/features/autonomy-mode.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Autonomy Modes - Control automatic execution behavior
+ */
+export type AutonomyMode = 'suggest' | 'auto_edit' | 'full_auto';
+export type ActionType = 'file_read' | 'file_write' | 'file_delete' | 'shell_command' | 'network_request' | 'git_operation' | 'install_package';
+export interface ApprovalPolicy {
+    action: ActionType;
+    requiresApproval: boolean;
+    autoApprovePatterns?: string[];
+    autoDenyPatterns?: string[];
+}
+export interface AutonomyConfig {
+    mode: AutonomyMode;
+    policies?: ApprovalPolicy[];
+    rememberDecisions?: boolean;
+    maxAutoActions?: number;
+}
+export interface ActionRequest {
+    type: ActionType;
+    description: string;
+    target?: string;
+    details?: Record<string, any>;
+}
+export interface ActionDecision {
+    approved: boolean;
+    reason?: string;
+    remembered?: boolean;
+}
+/**
+ * Default policies for each mode
+ */
+export declare const MODE_POLICIES: Record<AutonomyMode, ApprovalPolicy[]>;
+/**
+ * Autonomy Manager class
+ */
+export declare class AutonomyManager {
+    private config;
+    private rememberedDecisions;
+    private actionCount;
+    private promptCallback?;
+    constructor(config?: Partial<AutonomyConfig>);
+    /**
+     * Set the prompt callback for user approval
+     */
+    setPromptCallback(callback: (request: ActionRequest) => Promise<boolean>): void;
+    /**
+     * Request approval for an action
+     */
+    requestApproval(request: ActionRequest): Promise<ActionDecision>;
+    /**
+     * Get policy for an action type
+     */
+    private getPolicy;
+    /**
+     * Generate decision key for remembering
+     */
+    private getDecisionKey;
+    /**
+     * Match a target against a pattern
+     */
+    private matchPattern;
+    /**
+     * Get current mode
+     */
+    getMode(): AutonomyMode;
+    /**
+     * Set mode
+     */
+    setMode(mode: AutonomyMode): void;
+    /**
+     * Add custom policy
+     */
+    addPolicy(policy: ApprovalPolicy): void;
+    /**
+     * Clear remembered decisions
+     */
+    clearRemembered(): void;
+    /**
+     * Reset action count
+     */
+    resetActionCount(): void;
+    /**
+     * Get action count
+     */
+    getActionCount(): number;
+    /**
+     * Get summary of current settings
+     */
+    getSummary(): string;
+}
+/**
+ * Create an autonomy manager
+ */
+export declare function createAutonomyManager(config?: Partial<AutonomyConfig>): AutonomyManager;
+/**
+ * Simple approval prompt for CLI
+ */
+export declare function cliApprovalPrompt(request: ActionRequest): Promise<boolean>;