@brainforge/core 3.0.0

package/dist/index.d.ts

@@ -0,0 +1,393 @@
+import { EventEmitter } from 'events';
+
+type ProjectType = 'student' | 'junior' | 'solo';
+type StudentLevel = 'beginner' | 'intermediate' | 'advanced';
+type Language = 'typescript' | 'javascript' | 'python' | 'java' | 'go' | 'php';
+type PhaseStatus = 'pending' | 'active' | 'completed' | 'blocked';
+type TaskStatus = 'todo' | 'in-progress' | 'done' | 'skipped';
+interface ProjectConfig {
+    name: string;
+    description: string;
+    type: ProjectType;
+    language: Language;
+    framework?: string;
+    studentLevel?: StudentLevel;
+}
+interface Task {
+    id: string;
+    phaseId: string;
+    title: string;
+    description: string;
+    status: TaskStatus;
+    files?: string[];
+    context?: Record<string, unknown>;
+    createdAt: string;
+    updatedAt: string;
+}
+interface Phase {
+    id: string;
+    name: string;
+    description: string;
+    status: PhaseStatus;
+    tasks: Task[];
+    startedAt?: string;
+    completedAt?: string;
+}
+type AIProvider = 'claude' | 'openai' | 'gemini' | 'deepseek';
+interface AIConfig {
+    provider: AIProvider;
+    model?: string;
+    apiKeyEnv: string;
+}
+interface BrainforgeState {
+    version: string;
+    project: ProjectConfig;
+    phases: Phase[];
+    activePhaseId?: string;
+    context: Record<string, unknown>;
+    aiConfig?: AIConfig;
+    metadata: {
+        createdAt: string;
+        updatedAt: string;
+        workingDirectory: string;
+    };
+}
+
+declare class StateManager {
+    private readonly workingDir;
+    private statePath;
+    private state;
+    constructor(workingDir: string);
+    load(): Promise<BrainforgeState>;
+    save(): Promise<void>;
+    init(project: ProjectConfig): Promise<BrainforgeState>;
+    get(): BrainforgeState;
+    set(updater: (state: BrainforgeState) => void): void;
+    configureAI(config: AIConfig): Promise<void>;
+    addPhase(phase: Omit<Phase, 'tasks'>): Promise<Phase>;
+    addTask(task: Task): Promise<void>;
+    updateTaskStatus(taskId: string, status: Task['status']): Promise<void>;
+    private writeDerivedViews;
+    private writeProjectMd;
+    private writeStateMd;
+}
+
+type StateAction = {
+    type: 'SET_ACTIVE_PHASE';
+    phaseId: string;
+} | {
+    type: 'COMPLETE_PHASE';
+    phaseId: string;
+} | {
+    type: 'UPDATE_TASK';
+    taskId: string;
+    updates: Partial<Task>;
+} | {
+    type: 'SET_CONTEXT';
+    key: string;
+    value: unknown;
+};
+declare function reduce(state: BrainforgeState, action: StateAction): BrainforgeState;
+
+interface FileChangeEvent {
+    type: 'add' | 'change' | 'unlink';
+    path: string;
+    timestamp: string;
+}
+declare class FileWatcher extends EventEmitter {
+    private watcher;
+    watch(rootDir: string, patterns?: string[]): void;
+    stop(): Promise<void>;
+}
+
+declare class PromptEngine {
+    private compiled;
+    constructor();
+    render(templateName: string, context: Record<string, unknown>): string;
+    registerTemplate(name: string, source: string): void;
+    listTemplates(): string[];
+}
+
+interface FunctionInfo {
+    name: string;
+    line: number;
+    isExported: boolean;
+    isAsync: boolean;
+}
+interface ClassInfo {
+    name: string;
+    line: number;
+    isExported: boolean;
+    methods: string[];
+}
+interface FileNode {
+    path: string;
+    language: Language;
+    functions: FunctionInfo[];
+    classes: ClassInfo[];
+    imports: string[];
+    exports: string[];
+    lastScanned: string;
+}
+interface CodebaseMap {
+    version: string;
+    scannedAt: string;
+    rootDir: string;
+    files: FileNode[];
+    stats: {
+        totalFiles: number;
+        totalFunctions: number;
+        totalClasses: number;
+    };
+}
+
+declare class CodebaseMapper {
+    private readonly workingDir;
+    constructor(workingDir: string);
+    scan(language: Language): Promise<CodebaseMap>;
+    load(): Promise<CodebaseMap>;
+    findRelevantFiles(map: CodebaseMap, query: string): FileNode[];
+    private findFiles;
+    private walk;
+    private saveMap;
+}
+
+type PlanAction = 'create' | 'modify' | 'delete' | 'review';
+interface PlanStep {
+    id: string;
+    order: number;
+    action: PlanAction;
+    file: string;
+    description: string;
+    targetFunctions?: string[];
+}
+interface TaskPlan {
+    id: string;
+    title: string;
+    description: string;
+    impactedFiles: string[];
+    impactedFunctions: string[];
+    steps: PlanStep[];
+    estimatedComplexity: number;
+    risks: string[];
+    agentPrompt: string;
+    createdAt: string;
+}
+
+declare class TaskPlanner {
+    plan(title: string, description: string, map: CodebaseMap, relevantFiles: FileNode[], project: ProjectConfig): TaskPlan;
+    private buildSteps;
+    private inferAction;
+    private detectRisks;
+    private estimateComplexity;
+    private buildAgentPrompt;
+}
+
+type Severity = 'warn' | 'error';
+interface HeuristicPattern {
+    id: string;
+    name: string;
+    explanation: string;
+    regex: RegExp;
+    languages: Language[];
+    flagForLevels: StudentLevel[];
+    severity: Severity;
+}
+
+interface PatternMatch {
+    patternId: string;
+    name: string;
+    explanation: string;
+    severity: Severity;
+    file: string;
+    line: number;
+    snippet: string;
+}
+interface ScanReport {
+    scannedAt: string;
+    language: Language;
+    studentLevel: StudentLevel;
+    totalFilesScanned: number;
+    matches: PatternMatch[];
+    summary: {
+        errors: number;
+        warnings: number;
+        clean: boolean;
+    };
+}
+declare class ProfessorScanner {
+    private readonly workingDir;
+    constructor(workingDir: string);
+    scan(language: Language, studentLevel: StudentLevel): Promise<ScanReport>;
+    private findFiles;
+    private walk;
+    private writeReport;
+}
+
+declare class BrainForgeServer {
+    private readonly workingDir;
+    readonly port: number;
+    private httpServer;
+    private wss;
+    private clients;
+    private readonly dashboardDir;
+    private boundPort;
+    constructor(workingDir: string, port?: number, dashboardDir?: string);
+    start(): Promise<void>;
+    stop(): void;
+    broadcast(type: string, payload: unknown): void;
+    get url(): string;
+    private handle;
+    private json;
+    private fileJson;
+    private fileText;
+    private static;
+}
+
+interface Question {
+    id: string;
+    text: string;
+    modelAnswer: string;
+    difficulty: 'easy' | 'medium' | 'hard';
+    languages: Language[];
+    levels: StudentLevel[];
+    patternId?: string;
+}
+interface DynamicQuestion {
+    text: string;
+    modelAnswer: string;
+    difficulty: 'easy' | 'medium' | 'hard';
+}
+declare function buildQuestionSet(project: {
+    language: Language;
+    studentLevel?: StudentLevel;
+}, map: CodebaseMap, report: ScanReport | null, maxQuestions?: number): DynamicQuestion[];
+
+interface DefenseAnswer {
+    question: string;
+    answer: string;
+    modelAnswer: string;
+    confidence: 1 | 2 | 3 | 4 | 5;
+}
+interface DefenseSession {
+    projectName: string;
+    language: string;
+    studentLevel: string;
+    completedAt: string;
+    questions: DefenseAnswer[];
+    averageConfidence: number;
+}
+declare class MockDefense {
+    private readonly workingDir;
+    constructor(workingDir: string);
+    selectQuestions(project: ProjectConfig, map: CodebaseMap, report: ScanReport | null, count?: number): DynamicQuestion[];
+    saveSession(session: DefenseSession): Promise<void>;
+}
+
+type SkillCategory = 'backend' | 'frontend' | 'database' | 'testing' | 'devops' | 'academic' | 'review' | 'general';
+type ContextFieldType = 'text' | 'boolean' | 'select';
+interface ContextField {
+    key: string;
+    label: string;
+    type: ContextFieldType;
+    placeholder?: string;
+    options?: string[];
+    default?: string | boolean;
+}
+interface Skill {
+    id: string;
+    name: string;
+    category: SkillCategory;
+    description: string;
+    template: string;
+    contextSchema: ContextField[];
+    tags: string[];
+    version: string;
+}
+interface SkillContext {
+    project: {
+        name: string;
+        language: string;
+        framework?: string;
+        type: string;
+        studentLevel?: string;
+    };
+    [key: string]: unknown;
+}
+
+declare class SkillRegistry {
+    private skills;
+    private compiled;
+    constructor();
+    register(skill: Skill): void;
+    loadUserSkills(skillsDir: string): Promise<void>;
+    get(id: string): Skill | undefined;
+    list(filter?: {
+        category?: SkillCategory;
+        tag?: string;
+    }): Skill[];
+    listByCategory(): Map<SkillCategory, Skill[]>;
+    render(id: string, context: SkillContext): string;
+    count(): {
+        builtin: number;
+        custom: number;
+    };
+    search(query: string): Skill[];
+}
+
+declare const BUILT_IN_SKILLS: Skill[];
+
+interface CompletionOptions {
+    system?: string;
+    maxTokens?: number;
+    temperature?: number;
+}
+interface AIAdapter {
+    readonly provider: AIProvider;
+    readonly model: string;
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+    isConfigured(): boolean;
+}
+
+declare class AdapterManager {
+    static create(config: AIConfig): AIAdapter;
+    static fromState(state: BrainforgeState): AIAdapter | null;
+}
+
+declare class ClaudeAdapter implements AIAdapter {
+    readonly provider: "claude";
+    readonly model: string;
+    private readonly apiKeyEnv;
+    constructor(config: AIConfig);
+    isConfigured(): boolean;
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+}
+
+declare class OpenAIAdapter implements AIAdapter {
+    readonly provider: "openai";
+    readonly model: string;
+    private readonly apiKeyEnv;
+    constructor(config: AIConfig);
+    isConfigured(): boolean;
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+}
+
+declare class GeminiAdapter implements AIAdapter {
+    readonly provider: "gemini";
+    readonly model: string;
+    private readonly apiKeyEnv;
+    constructor(config: AIConfig);
+    isConfigured(): boolean;
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+}
+
+declare class DeepSeekAdapter implements AIAdapter {
+    readonly provider: "deepseek";
+    readonly model: string;
+    private readonly apiKeyEnv;
+    constructor(config: AIConfig);
+    isConfigured(): boolean;
+    complete(prompt: string, options?: CompletionOptions): Promise<string>;
+}
+
+export { type AIAdapter, type AIConfig, type AIProvider, AdapterManager, BUILT_IN_SKILLS, BrainForgeServer, type BrainforgeState, type ClassInfo, ClaudeAdapter, type CodebaseMap, CodebaseMapper, type CompletionOptions, type ContextField, DeepSeekAdapter, type DefenseAnswer, type DefenseSession, type DynamicQuestion, type FileChangeEvent, type FileNode, FileWatcher, type FunctionInfo, GeminiAdapter, type HeuristicPattern, type Language, MockDefense, OpenAIAdapter, type PatternMatch, type Phase, type PhaseStatus, type PlanAction, type PlanStep, ProfessorScanner, type ProjectConfig, type ProjectType, PromptEngine, type Question, type ScanReport, type Severity, type Skill, type SkillCategory, type SkillContext, SkillRegistry, type StateAction, StateManager, type StudentLevel, type Task, type TaskPlan, TaskPlanner, type TaskStatus, buildQuestionSet, reduce };