@hyperdrive.bot/gut 0.1.3

package/dist/services/config.service.js

@@ -0,0 +1,230 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigService = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+class ConfigService {
+    workspaceRoot;
+    gutDir;
+    focusFile;
+    configFile;
+    historyFile;
+    focusContextFile;
+    focusDir;
+    config = null;
+    focus = null;
+    history = [];
+    constructor(workspaceRoot) {
+        this.workspaceRoot = workspaceRoot || process.env.DS_WORKSPACE || process.cwd();
+        this.gutDir = path.join(this.workspaceRoot, '.gut');
+        this.focusDir = path.join(this.workspaceRoot, 'focus');
+        this.focusFile = path.join(this.gutDir, 'focus.json');
+        this.configFile = path.join(this.gutDir, 'config.json');
+        this.historyFile = path.join(this.gutDir, 'history.json');
+        this.focusContextFile = path.join(this.focusDir, 'context.yaml');
+        this.ensureDirectories();
+        this.loadAll();
+    }
+    ensureDirectories() {
+        if (!fs.existsSync(this.gutDir)) {
+            fs.mkdirSync(this.gutDir, { recursive: true });
+        }
+        if (!fs.existsSync(this.focusDir)) {
+            fs.mkdirSync(this.focusDir, { recursive: true });
+        }
+    }
+    loadAll() {
+        this.config = this.loadConfigSync();
+        this.focus = this.loadFocus();
+        this.history = this.loadHistory();
+    }
+    async loadConfig() {
+        try {
+            if (fs.existsSync(this.configFile)) {
+                const content = fs.readFileSync(this.configFile, 'utf8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn('⚠️  Could not load config:', error.message);
+        }
+        return { initialized: false, entities: [], workspace: this.workspaceRoot };
+    }
+    loadConfigSync() {
+        try {
+            if (fs.existsSync(this.configFile)) {
+                const content = fs.readFileSync(this.configFile, 'utf8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn('⚠️  Could not load config:', error.message);
+        }
+        return { initialized: false, entities: [] };
+    }
+    loadFocus() {
+        try {
+            if (fs.existsSync(this.focusFile)) {
+                const content = fs.readFileSync(this.focusFile, 'utf8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn('⚠️  Could not load focus state:', error.message);
+        }
+        return null;
+    }
+    loadHistory() {
+        try {
+            if (fs.existsSync(this.historyFile)) {
+                const content = fs.readFileSync(this.historyFile, 'utf8');
+                return JSON.parse(content);
+            }
+        }
+        catch (error) {
+            console.warn('⚠️  Could not load history:', error.message);
+        }
+        return [];
+    }
+    getConfig() {
+        if (!this.config) {
+            this.config = this.loadConfigSync();
+        }
+        return this.config || { initialized: false, entities: [] };
+    }
+    saveConfig(config) {
+        try {
+            fs.writeFileSync(this.configFile, JSON.stringify(config, null, 2));
+            this.config = config;
+        }
+        catch (error) {
+            throw new Error(`Could not save config: ${error.message}`);
+        }
+    }
+    getFocus() {
+        return this.focus;
+    }
+    saveFocus(focus) {
+        try {
+            // Save to history before changing focus
+            if (this.focus && focus) {
+                this.addToHistory(this.focus);
+            }
+            if (focus) {
+                fs.writeFileSync(this.focusFile, JSON.stringify(focus, null, 2));
+            }
+            else if (fs.existsSync(this.focusFile)) {
+                fs.unlinkSync(this.focusFile);
+            }
+            this.focus = focus;
+        }
+        catch (error) {
+            throw new Error(`Could not save focus state: ${error.message}`);
+        }
+    }
+    getHistory() {
+        return this.history;
+    }
+    addToHistory(focus) {
+        try {
+            if (!this.history)
+                this.history = [];
+            // Convert focus entities to string array for history
+            const entityNames = focus.entities ? focus.entities.map(e => e.name) : [focus.name];
+            // Don't add duplicate consecutive entries
+            const lastEntry = this.history[this.history.length - 1];
+            if (lastEntry &&
+                lastEntry.entities.length === entityNames.length &&
+                lastEntry.entities.every(e => entityNames.includes(e))) {
+                return;
+            }
+            // Add timestamp and limit history to 10 entries
+            const entry = {
+                entities: entityNames,
+                timestamp: Date.now()
+            };
+            this.history.push(entry);
+            if (this.history.length > 10) {
+                this.history = this.history.slice(-10);
+            }
+            fs.writeFileSync(this.historyFile, JSON.stringify(this.history, null, 2));
+        }
+        catch (error) {
+            console.warn('⚠️  Could not save history:', error.message);
+        }
+    }
+    clearHistory() {
+        this.history = [];
+        try {
+            if (fs.existsSync(this.historyFile)) {
+                fs.unlinkSync(this.historyFile);
+            }
+        }
+        catch (error) {
+            console.warn('⚠️  Could not clear history:', error.message);
+        }
+    }
+    isInitialized() {
+        return this.config?.initialized || false;
+    }
+    getWorkspaceRoot() {
+        return this.workspaceRoot;
+    }
+    async initWorkspace(workspacePath) {
+        const config = {
+            initialized: true,
+            entities: [],
+            workspace: workspacePath
+        };
+        this.saveConfig(config);
+    }
+    getGutDir() {
+        return this.gutDir;
+    }
+    async saveFocusContext(context) {
+        try {
+            // Convert to YAML format (simplified - would use a YAML library in production)
+            const yamlContent = this.convertToYaml(context);
+            fs.writeFileSync(this.focusContextFile, yamlContent);
+        }
+        catch (error) {
+            console.warn('⚠️  Could not save focus context:', error.message);
+        }
+    }
+    convertToYaml(obj, indent = 0) {
+        // Simple YAML converter - in production would use js-yaml library
+        const spaces = '  '.repeat(indent);
+        let yaml = '';
+        for (const [key, value] of Object.entries(obj)) {
+            if (value === null || value === undefined) {
+                continue;
+            }
+            if (typeof value === 'object' && !Array.isArray(value)) {
+                yaml += `${spaces}${key}:\n`;
+                yaml += this.convertToYaml(value, indent + 1);
+            }
+            else if (Array.isArray(value)) {
+                yaml += `${spaces}${key}:\n`;
+                for (const item of value) {
+                    if (typeof item === 'object') {
+                        yaml += `${spaces}  -\n`;
+                        yaml += this.convertToYaml(item, indent + 2);
+                    }
+                    else {
+                        yaml += `${spaces}  - ${item}\n`;
+                    }
+                }
+            }
+            else {
+                const valueStr = typeof value === 'string' ? `"${value}"` : String(value);
+                yaml += `${spaces}${key}: ${valueStr}\n`;
+            }
+        }
+        return yaml;
+    }
+    getFocusDir() {
+        return this.focusDir;
+    }
+}
+exports.ConfigService = ConfigService;

package/dist/services/entity.service.d.ts

@@ -0,0 +1,19 @@
+import { Entity, EntityType } from '../models/entity.model';
+import { ConfigService } from './config.service';
+export declare class EntityService {
+    private configService;
+    constructor(configService: ConfigService);
+    getAllEntities(): Entity[];
+    listEntities(): Promise<Entity[]>;
+    getEntity(name: string): Promise<Entity | null>;
+    findEntity(name: string): Entity | undefined;
+    findEntityByTypeAndName(type: EntityType, name: string): Entity | undefined;
+    addEntity(name: string, type: EntityType, entityPath: string, repository?: string): Promise<void>;
+    removeEntity(name: string): void;
+    updateEntity(name: string, updates: Partial<Entity>): Promise<void>;
+    discoverEntities(): Entity[];
+    getEntitiesByType(type: EntityType): Entity[];
+    resolveEntityPath(entity: Entity): string;
+    validateEntityName(name: string): boolean;
+    getEntityByPath(searchPath: string): Entity | undefined;
+}

package/dist/services/entity.service.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityService = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+class EntityService {
+    configService;
+    constructor(configService) {
+        this.configService = configService;
+    }
+    getAllEntities() {
+        const config = this.configService.getConfig();
+        return config.entities || [];
+    }
+    async listEntities() {
+        return this.getAllEntities();
+    }
+    async getEntity(name) {
+        const entity = this.findEntity(name);
+        return entity || null;
+    }
+    findEntity(name) {
+        const entities = this.getAllEntities();
+        return entities.find(e => e.name === name);
+    }
+    findEntityByTypeAndName(type, name) {
+        const entities = this.getAllEntities();
+        return entities.find(e => e.type === type && e.name === name);
+    }
+    async addEntity(name, type, entityPath, repository) {
+        const entity = { name, type, path: entityPath, repository };
+        const config = this.configService.getConfig();
+        // Check if entity already exists
+        if (this.findEntity(entity.name)) {
+            throw new Error(`Entity '${entity.name}' already exists`);
+        }
+        // Validate path
+        const absolutePath = path.isAbsolute(entityPath)
+            ? entityPath
+            : path.join(this.configService.getWorkspaceRoot(), entityPath);
+        if (!fs.existsSync(absolutePath)) {
+            // Create directory if it doesn't exist
+            fs.mkdirSync(absolutePath, { recursive: true });
+        }
+        // Add entity
+        config.entities = config.entities || [];
+        config.entities.push(entity);
+        this.configService.saveConfig(config);
+    }
+    removeEntity(name) {
+        const config = this.configService.getConfig();
+        if (!this.findEntity(name)) {
+            throw new Error(`Entity '${name}' not found`);
+        }
+        config.entities = config.entities.filter(e => e.name !== name);
+        this.configService.saveConfig(config);
+    }
+    async updateEntity(name, updates) {
+        const config = this.configService.getConfig();
+        const entityIndex = config.entities.findIndex(e => e.name === name);
+        if (entityIndex === -1) {
+            throw new Error(`Entity '${name}' not found`);
+        }
+        config.entities[entityIndex] = {
+            ...config.entities[entityIndex],
+            ...updates
+        };
+        this.configService.saveConfig(config);
+    }
+    discoverEntities() {
+        const discovered = [];
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        // Common patterns for entity discovery
+        const patterns = [
+            { dir: 'apps', type: 'delivery' },
+            { dir: 'packages', type: 'module' },
+            { dir: 'libs', type: 'module' },
+            { dir: 'services', type: 'service' },
+            { dir: 'tools', type: 'tool' }
+        ];
+        for (const pattern of patterns) {
+            const dirPath = path.join(workspaceRoot, pattern.dir);
+            if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+                const subdirs = fs.readdirSync(dirPath)
+                    .filter(item => {
+                    const itemPath = path.join(dirPath, item);
+                    return fs.statSync(itemPath).isDirectory() && !item.startsWith('.');
+                });
+                for (const subdir of subdirs) {
+                    const entityPath = path.join(pattern.dir, subdir);
+                    const fullPath = path.join(workspaceRoot, entityPath);
+                    // Check if it's a git repository or has package.json
+                    const hasGit = fs.existsSync(path.join(fullPath, '.git'));
+                    const hasPackageJson = fs.existsSync(path.join(fullPath, 'package.json'));
+                    if (hasGit || hasPackageJson) {
+                        discovered.push({
+                            name: subdir,
+                            type: pattern.type,
+                            path: `./${entityPath}`
+                        });
+                    }
+                }
+            }
+        }
+        return discovered;
+    }
+    getEntitiesByType(type) {
+        return this.getAllEntities().filter(e => e.type === type);
+    }
+    resolveEntityPath(entity) {
+        if (path.isAbsolute(entity.path)) {
+            return entity.path;
+        }
+        return path.join(this.configService.getWorkspaceRoot(), entity.path);
+    }
+    validateEntityName(name) {
+        // Entity names should be alphanumeric with hyphens/underscores
+        return /^[a-zA-Z0-9-_]+$/.test(name);
+    }
+    getEntityByPath(searchPath) {
+        const entities = this.getAllEntities();
+        const absoluteSearchPath = path.resolve(searchPath);
+        return entities.find(entity => {
+            const entityPath = this.resolveEntityPath(entity);
+            return path.resolve(entityPath) === absoluteSearchPath;
+        });
+    }
+}
+exports.EntityService = EntityService;

package/dist/services/focus.service.d.ts

@@ -0,0 +1,70 @@
+import { Entity, Focus, HistoryEntry, FocusMode, EntityType } from '../models/entity.model';
+import { ConfigService } from './config.service';
+export interface FocusOptions {
+    entityType?: EntityType;
+    mode?: FocusMode;
+    duration?: string;
+}
+export declare class FocusService {
+    private configService;
+    private entityService;
+    private focusStack;
+    constructor(configService: ConfigService);
+    getCurrentFocus(): Promise<Focus | null>;
+    getFocusedEntities(): Promise<Entity[]>;
+    setFocus(entityNames: string[], options?: FocusOptions): Promise<void>;
+    addToFocus(entityNames: string[], options?: FocusOptions): Promise<void>;
+    clearFocus(): Promise<void>;
+    switchToPrevious(): Promise<void>;
+    getRecentFocus(limit?: number): HistoryEntry[];
+    isFocused(entityName: string): Promise<boolean>;
+    getFocusDescription(): Promise<string>;
+    pushFocusToStack(): Promise<void>;
+    popFocusFromStack(): Promise<Focus | null>;
+    getFocusStack(): Focus[];
+    private generateFocusContext;
+    private generateAIContext;
+    private getPersonaForMode;
+    private getKnowledgeScopeForMode;
+    private getAvailableDataForEntity;
+    private getSuggestedActionsForMode;
+    private getRestrictedKnowledgeForMode;
+    private generateContextIntelligence;
+    private generateLearningInsights;
+    private generateAdaptiveSuggestions;
+    private generateCollaborationContext;
+    private generatePerformanceContext;
+    private getRecentActivity;
+    private getTeamMembers;
+    private getPerformanceMetrics;
+    private getRelatedEntities;
+    private getRecentPatterns;
+    private getBusinessContext;
+    private getTechnicalContext;
+    private determineContextType;
+    private assessComplexity;
+    private estimateFocusDuration;
+    private assessInterruptionRisk;
+    private assessSuccessProbability;
+    private getRecommendedApproach;
+    private getHistoricalPatterns;
+    private getSimilarEntityLessons;
+    private getCommonPitfalls;
+    private getSuccessFactors;
+    private getLearningOpportunities;
+    private getTimeBasedSuggestions;
+    private getDayBasedSuggestions;
+    private getContextSpecificTips;
+    private getProductivityOptimizations;
+    private getWorkflowSuggestions;
+    private getActiveTeamMembers;
+    private getCollaborationPatterns;
+    private getCommunicationPreferences;
+    private getSharedResources;
+    private getCoordinationNeeds;
+    private getCurrentVelocity;
+    private getPerformanceTrends;
+    private identifyBottlenecks;
+    private getOptimizationOpportunities;
+    private getBenchmarks;
+}