@baselineos/cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,616 @@
+/**
+ * Baseline Command System
+ *
+ * Provides workflow execution across all Baseline Protocol layers,
+ * command chaining, and a queue system for orchestrating operations.
+ */
+interface CommandState {
+    customContextFolder: string | null;
+    baselineMode: boolean;
+    commandQueue: string[];
+    executionHistory: WorkflowExecution[];
+    currentWorkflow: WorkflowExecution | null;
+}
+interface WorkflowExecution {
+    id: string;
+    startTime: Date;
+    endTime?: Date;
+    duration?: number;
+    options: Record<string, unknown>;
+    status: string;
+    error?: string;
+}
+interface LexiconEntry {
+    description: string;
+    usage: string;
+    category: string;
+    examples: string[];
+}
+interface SyntaxEntry {
+    pattern: string;
+    parameters: Record<string, string>;
+    examples: string[];
+}
+interface CommandEntry {
+    description: string;
+    action: string;
+    category: string;
+}
+interface LayerResult {
+    success: boolean;
+    error?: string;
+    [key: string]: unknown;
+}
+interface WorkflowResult {
+    success: boolean;
+    error?: string;
+    workflow?: WorkflowExecution;
+    results?: {
+        init: LayerResult;
+        lang: LayerResult;
+        frame: LayerResult;
+        studio: LayerResult;
+        govern: LayerResult;
+    };
+}
+declare class BaselineCommandSystem {
+    private state;
+    private megagem;
+    private contextEngine;
+    private baselineLang;
+    constructor();
+    /**
+     * Initialize the Baseline lexicon with all recognized flags and their
+     * descriptions, usage patterns, categories, and examples.
+     */
+    initializeBaselineLexicon(): Record<string, LexiconEntry>;
+    /**
+     * Initialize syntax patterns for the command system, defining parameter
+     * schemas and usage examples for each pattern.
+     */
+    initializeBaselineSyntax(): Record<string, SyntaxEntry>;
+    /**
+     * Initialize the built-in command registry with descriptions and action
+     * identifiers for each recognized command.
+     */
+    initializeBaselineCommands(): Record<string, CommandEntry>;
+    /**
+     * Execute the full Baseline Protocol workflow across all five layers:
+     * init -> lang -> frame -> studio -> govern
+     */
+    executeBaselineWorkflow(options?: Record<string, unknown>): Promise<WorkflowResult>;
+    private normalizeString;
+    private normalizeBoolean;
+    private resolveContext;
+    private loadOnboardingProfile;
+    private saveOnboardingProfile;
+    private loadBaselineConfig;
+    private saveBaselineConfig;
+    private fileExists;
+    private buildDefaultConfig;
+    private getExperienceCatalog;
+    private getLearningPaths;
+    /**
+     * Execute a guided onboarding flow (team, project, system) and optionally
+     * run the full Baseline workflow. Designed for a 20-minute quickstart.
+     */
+    executeOnboarding(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Execute an immersive experience sequence based on the selected learning path.
+     * Uses onboarding profile data and persists progress.
+     */
+    executeExperience(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Initialize Baseline and optionally persist config to disk.
+     */
+    executeInit(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Update or show Baseline configuration.
+     */
+    executeConfig(options?: Record<string, unknown>): Promise<LayerResult>;
+    private collectIndexEntries;
+    /**
+     * Index documentation/context files for retrieval.
+     */
+    executeIndex(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Placeholder for MCP server/daemon execution.
+     */
+    executeServe(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Placeholder for agent status and management.
+     */
+    executePersona(_options?: Record<string, unknown>): LayerResult;
+    executeAgents(options?: Record<string, unknown>): Promise<LayerResult>;
+    private buildBaselineOS;
+    executeServeWithOptions(options: Record<string, unknown>): Promise<LayerResult>;
+    executeAgentsWithOptions(options: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Run diagnostics for configuration and readiness.
+     */
+    executeDoctor(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Initialize the Baseline environment, setting up context folder,
+     * configuration, and mode.
+     */
+    initializeBaseline(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Execute the Baseline Language layer -- parsing, validation,
+     * and semantic analysis of the project context.
+     */
+    executeBaselineLang(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Execute the Baseline Frame layer -- scaffolding, composition,
+     * and framework orchestration.
+     */
+    executeBaselineFrame(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Execute the Baseline Studio layer -- design rendering,
+     * preview generation, and visual asset processing.
+     */
+    executeBaselineStudio(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Execute the Baseline Govern layer -- audit, policy enforcement,
+     * compliance checking, and governance controls.
+     */
+    executeBaselineGovern(options?: Record<string, unknown>): Promise<LayerResult>;
+    /**
+     * Execute a chain of commands sequentially. Each command in the array
+     * is executed in order. If any command fails, the chain halts.
+     */
+    executeChainedCommands(commands: string[]): Promise<LayerResult>;
+    /**
+     * Add a command to the execution queue for deferred execution.
+     */
+    queueCommand(command: string): void;
+    /**
+     * Execute all commands currently in the queue, in FIFO order,
+     * then clear the queue.
+     */
+    executeQueue(): Promise<LayerResult>;
+    /**
+     * Execute a single command string by dispatching to the appropriate
+     * handler based on the command flag.
+     */
+    executeCommand(command: string): Promise<LayerResult | WorkflowResult>;
+    /**
+     * Return the current status of the Baseline system, including
+     * state, execution history, and queue contents.
+     */
+    getStatus(): Record<string, unknown>;
+    /**
+     * Display help information for all available commands, flags,
+     * and syntax patterns.
+     */
+    showHelp(): void;
+    /**
+     * Set the MEGAGEM integration instance for autonomous operations.
+     */
+    setMegagem(megagem: unknown): void;
+    /**
+     * Set the Context Engine integration instance for context management.
+     */
+    setContextEngine(contextEngine: unknown): void;
+}
+
+/**
+ * MEGAGEM Core System and Autonomous Agent
+ *
+ * Combined module providing the MEGAGEM core system for autonomous
+ * operations and the autonomous agent framework for project ownership,
+ * learning, and collaboration.
+ */
+interface AutonomyLevelConfig {
+    name: string;
+    description: string;
+}
+interface MEGAGEMConfig {
+    system: {
+        name: string;
+        version: string;
+        description: string;
+    };
+    autonomy: {
+        defaultLevel: number;
+        maxLevel: number;
+        safetyThresholds: {
+            riskTolerance: string;
+            humanOversight: string;
+        };
+    };
+    learning: {
+        continuousLearning: boolean;
+        selfImprovement: boolean;
+        knowledgeSharing: boolean;
+    };
+    safety: {
+        riskAssessment: boolean;
+        boundaryEnforcement: boolean;
+        humanOverride: boolean;
+        auditLogging: boolean;
+    };
+}
+interface ProjectData {
+    name: string;
+    description: string;
+    type: string;
+    objectives?: string[];
+    constraints?: string[];
+    resources?: Record<string, unknown>;
+    timeline?: Record<string, unknown>;
+}
+interface Project {
+    id: string;
+    name: string;
+    description: string;
+    type: string;
+    status: string;
+    ownershipLevel: string;
+    startDate: Date;
+    endDate?: Date;
+    objectives: string[];
+    constraints: string[];
+    resources: Record<string, unknown>;
+    timeline: Record<string, unknown>;
+    team: Set<string>;
+    teamMembers?: unknown[];
+    tasks: Map<string, unknown>;
+    milestones: Map<string, unknown>;
+    risks: Map<string, unknown>;
+    progress: number;
+    plan?: Record<string, unknown>;
+    strategy?: Record<string, unknown>;
+    healthMetrics?: Record<string, unknown>;
+    qualityGates?: string[];
+    deliverables?: Record<string, unknown>;
+    qualityScore?: number;
+    error?: string;
+}
+interface PerformanceMetrics {
+    decisionsAccuracy: number;
+    taskCompletionRate: number;
+    learningRate: number;
+    collaborationScore: number;
+    safetyCompliance: number;
+    totalDecisions: number;
+    totalTasks: number;
+    totalCollaborations: number;
+    uptime: number;
+    startTime: Date;
+}
+interface AutonomyController {
+    currentLevel: number;
+    maxLevel: number;
+    levels: Record<number, AutonomyLevelConfig>;
+    escalationRules: EscalationRule[];
+    overrideActive: boolean;
+}
+interface EscalationRule {
+    condition: string;
+    action: string;
+    targetLevel: number;
+}
+interface DecisionEngine {
+    pendingDecisions: unknown[];
+    decisionHistory: unknown[];
+    decisionThresholds: Record<string, number>;
+    autoApprove: boolean;
+}
+interface ProjectOwner {
+    activeProjects: Map<string, Project>;
+    completedProjects: Map<string, Project>;
+    projectTemplates: Map<string, Record<string, unknown>>;
+}
+interface LearningEngine {
+    knowledgeBase: Map<string, unknown>;
+    learningHistory: unknown[];
+    patterns: Map<string, unknown>;
+    adaptationRate: number;
+}
+interface SafetyEngine {
+    riskAssessments: Map<string, unknown>;
+    boundaries: Map<string, unknown>;
+    safetyEvents: unknown[];
+    overrideEnabled: boolean;
+}
+interface CollaborationEngine {
+    activeCollaborations: Map<string, unknown>;
+    communicationLog: unknown[];
+    teamRegistry: Map<string, unknown>;
+}
+interface AgentCapabilities {
+    [key: string]: boolean | string | number | string[];
+}
+interface AgentPerformanceMetrics {
+    tasksCompleted: number;
+    tasksFailed: number;
+    successRate: number;
+    averageCompletionTime: number;
+    qualityScore: number;
+    learningProgress: number;
+}
+interface TaskResult {
+    success: boolean;
+    output?: unknown;
+    error?: string;
+    duration?: number;
+}
+interface TeamRequirements {
+    roles: string[];
+    skills: string[];
+    minSize: number;
+    maxSize: number;
+}
+interface HealthAssessment {
+    overall: string;
+    score: number;
+    timeline: string;
+    quality: string;
+    resources: string;
+    risks: string;
+    details?: Record<string, unknown>;
+}
+declare class MEGAGEMCoreSystem {
+    systemName: string;
+    version: string;
+    autonomyLevel: number;
+    isActive: boolean;
+    learningMode: boolean;
+    safetyMode: boolean;
+    autonomyController: AutonomyController;
+    decisionEngine: DecisionEngine;
+    projectOwner: ProjectOwner;
+    learningEngine: LearningEngine;
+    safetyEngine: SafetyEngine;
+    collaborationEngine: CollaborationEngine;
+    currentProjects: Map<string, Project>;
+    performanceMetrics: PerformanceMetrics;
+    learningHistory: unknown[];
+    safetyEvents: unknown[];
+    config: MEGAGEMConfig;
+    constructor();
+    /**
+     * Set up the autonomy controller with five operational levels
+     * and escalation rules.
+     */
+    initializeAutonomyController(): AutonomyController;
+    /**
+     * Set up the decision engine with thresholds and history tracking.
+     */
+    initializeDecisionEngine(): DecisionEngine;
+    /**
+     * Set up the project ownership engine with project stores and templates.
+     */
+    initializeProjectOwner(): ProjectOwner;
+    /**
+     * Set up the learning engine with knowledge base and adaptation rate.
+     */
+    initializeLearningEngine(): LearningEngine;
+    /**
+     * Set up the safety engine with risk assessment stores and boundary
+     * configuration.
+     */
+    initializeSafetyEngine(): SafetyEngine;
+    /**
+     * Set up the collaboration engine with registries and communication log.
+     */
+    initializeCollaborationEngine(): CollaborationEngine;
+    /**
+     * Perform full system initialization: activate learning, safety, and
+     * log startup information.
+     */
+    initializeSystem(): Promise<{
+        success: boolean;
+        status: Record<string, unknown>;
+    }>;
+    /**
+     * Set the autonomy level (1-5) and update the system behavior accordingly.
+     */
+    setAutonomyLevel(level: number): {
+        success: boolean;
+        level: number;
+        name: string;
+        error?: string;
+    };
+    /**
+     * Update internal system behavior based on the autonomy level.
+     */
+    updateSystemBehavior(level: number): void;
+    /**
+     * Return a comprehensive snapshot of the current system status.
+     */
+    getSystemStatus(): Record<string, unknown>;
+    /**
+     * Attempt to load a configuration file from the given path.
+     * Falls back to defaults if the file does not exist.
+     */
+    loadConfiguration(configPath: string): MEGAGEMConfig;
+    /**
+     * Return the default MEGAGEM configuration object.
+     */
+    getDefaultConfig(): MEGAGEMConfig;
+    /**
+     * Activate autonomous operation mode: sets the system active, starts
+     * performance tracking, and returns the active capabilities.
+     */
+    startAutonomousOperation(): Promise<{
+        success: boolean;
+        capabilities: string[];
+        error?: string;
+    }>;
+    /**
+     * Determine which capabilities should be active given the current
+     * autonomy level and return them as a list.
+     */
+    activateAutonomousCapabilities(): string[];
+    /**
+     * Return the list of capabilities currently active.
+     */
+    getActiveCapabilities(): string[];
+}
+declare class MEGAGEMAutonomousAgent {
+    agentId: string;
+    agentType: string;
+    capabilities: AgentCapabilities;
+    autonomyLevel: number;
+    isActive: boolean;
+    currentProjects: Map<string, Project>;
+    performanceMetrics: AgentPerformanceMetrics;
+    learningHistory: unknown[];
+    collaborationHistory: unknown[];
+    status: string;
+    currentTask: string | null;
+    teamMembers: string[];
+    resources: Map<string, unknown>;
+    knowledgeBase: Map<string, unknown>;
+    skillLevels: Map<string, number>;
+    adaptationRate: number;
+    constructor(agentType?: string, autonomyLevel?: number);
+    /**
+     * Generate a unique agent identifier.
+     */
+    generateAgentId(): string;
+    /**
+     * Activate the agent for autonomous operation.
+     */
+    activate(): void;
+    /**
+     * Initialize capabilities based on the agent type. Supports five
+     * types: project-manager, developer, designer, analyst, general.
+     */
+    initializeCapabilities(agentType: string): void;
+    /**
+     * Take ownership of a project, creating the internal project record
+     * and setting status to planning.
+     */
+    takeProjectOwnership(projectData: ProjectData): Promise<Project>;
+    /**
+     * Execute a project autonomously through all lifecycle phases:
+     * plan -> form team -> allocate resources -> execute -> monitor -> deliver.
+     */
+    executeProjectAutonomously(projectId: string): Promise<Project>;
+    /**
+     * Create a strategic plan for the project including phases, milestones,
+     * task breakdown, timeline, resource plan, and risk assessment.
+     */
+    planProject(project: Project): Promise<void>;
+    /**
+     * Form a team for the project by analyzing requirements and assigning roles.
+     */
+    formProjectTeam(project: Project): Promise<void>;
+    /**
+     * Allocate resources to the project based on current plan and constraints.
+     */
+    allocateResources(project: Project): Promise<void>;
+    /**
+     * Execute the project plan by iterating through all tasks.
+     */
+    executeProjectPlan(project: Project): Promise<void>;
+    /**
+     * Monitor project health and adjust the plan if deviations are detected.
+     */
+    monitorAndControl(project: Project): Promise<void>;
+    /**
+     * Deliver project outputs, perform quality checks, and prepare deliverables.
+     */
+    deliverProject(project: Project): Promise<void>;
+    /**
+     * Build a strategic plan from the project's objectives and constraints.
+     */
+    createStrategicPlan(project: Project): Record<string, unknown>;
+    /**
+     * Define project phases based on the project type.
+     */
+    defineProjectPhases(project: Project): Record<string, unknown>[];
+    /**
+     * Define milestones for the project plan.
+     */
+    defineMilestones(_project: Project): Record<string, unknown>[];
+    /**
+     * Break project objectives down into concrete tasks.
+     */
+    breakDownTasks(project: Project): Record<string, unknown>[];
+    /**
+     * Build a timeline for the project based on tasks and milestones.
+     */
+    createTimeline(project: Project): Record<string, unknown>;
+    /**
+     * Create a resource allocation plan for the project.
+     */
+    planResources(project: Project): Record<string, unknown>;
+    /**
+     * Assess potential risks for the project and return a list of risk records.
+     */
+    assessRisks(project: Project): Record<string, unknown>[];
+    /**
+     * Analyze the team requirements for a project based on its type and scope.
+     */
+    analyzeTeamRequirements(project: Project): TeamRequirements;
+    /**
+     * Return the capabilities expected for a given team role.
+     */
+    getRoleCapabilities(role: string): string[];
+    /**
+     * Execute a single task and return the result.
+     */
+    executeTask(task: Record<string, unknown>): Promise<TaskResult>;
+    /**
+     * Determine if a project phase is complete by checking task statuses.
+     */
+    isPhaseComplete(project: Project, phaseIndex: number): boolean;
+    /**
+     * Assess overall project health across timeline, quality, resources,
+     * and risks dimensions.
+     */
+    assessProjectHealth(project: Project): HealthAssessment;
+    /**
+     * Assess the timeline health of the project (0.0 - 1.0).
+     */
+    assessTimelineHealth(project: Project): number;
+    /**
+     * Assess the quality health of the project (0.0 - 1.0).
+     */
+    assessQualityHealth(_project: Project): number;
+    /**
+     * Assess the resource health of the project (0.0 - 1.0).
+     */
+    assessResourceHealth(project: Project): number;
+    /**
+     * Assess the risk health of the project (0.0 - 1.0).
+     */
+    assessRiskHealth(project: Project): number;
+    /**
+     * Adjust the project plan to address health assessment findings.
+     */
+    adjustProjectPlan(project: Project, health: HealthAssessment): Promise<void>;
+    /**
+     * Accelerate project execution by reprioritizing tasks.
+     */
+    accelerateProject(project: Project): void;
+    /**
+     * Improve quality by adding quality gates to the project.
+     */
+    improveQuality(project: Project): void;
+    /**
+     * Optimize resource usage by consolidating and redistributing.
+     */
+    optimizeResources(project: Project): void;
+    /**
+     * Perform a quality check on the project deliverables.
+     */
+    performQualityCheck(project: Project): Record<string, unknown>;
+    /**
+     * Prepare the final deliverables summary for the project.
+     */
+    prepareDeliverables(project: Project): Record<string, unknown>;
+    /**
+     * Return a status snapshot for this agent.
+     */
+    getAgentStatus(): Record<string, unknown>;
+    /**
+     * Generate a unique project identifier.
+     */
+    generateProjectId(): string;
+}
+
+export { type AutonomyLevelConfig, BaselineCommandSystem, type CommandEntry, type CommandState, type LayerResult, type LexiconEntry, MEGAGEMAutonomousAgent, type MEGAGEMConfig, MEGAGEMCoreSystem, type Project, type ProjectData, type SyntaxEntry, type WorkflowExecution, type WorkflowResult };