@hyperdrive.bot/gut 0.1.3

package/dist/commands/workspace.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../base-command");
+const chalk_1 = tslib_1.__importDefault(require("chalk"));
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+class Workspace extends base_command_1.BaseCommand {
+    static description = 'Manage workspace structure and entity metadata';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> init',
+        '<%= config.bin %> <%= command.id %> structure',
+        '<%= config.bin %> <%= command.id %> generate-metadata',
+    ];
+    static args = {
+        action: core_1.Args.string({
+            name: 'action',
+            required: true,
+            description: 'Action to perform (init, structure, generate-metadata)',
+            options: ['init', 'structure', 'generate-metadata'],
+        }),
+    };
+    static flags = {
+        force: core_1.Flags.boolean({
+            char: 'f',
+            description: 'force overwrite existing files',
+        }),
+        'entity-type': core_1.Flags.string({
+            char: 't',
+            description: 'entity type for metadata generation',
+            options: ['client', 'prospect', 'company', 'initiative', 'system'],
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(Workspace);
+        switch (args.action) {
+            case 'init':
+                await this.initWorkspaceStructure(flags.force);
+                break;
+            case 'structure':
+                await this.showWorkspaceStructure();
+                break;
+            case 'generate-metadata':
+                await this.generateEntityMetadata(flags['entity-type'], flags.force);
+                break;
+            default:
+                this.error(`Unknown action: ${args.action}`);
+        }
+    }
+    async initWorkspaceStructure(force) {
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        this.log(chalk_1.default.bold('\n🏗️  Initializing Workspace Structure'));
+        this.log(chalk_1.default.dim('─'.repeat(50)));
+        // Create directory structure
+        const directories = [
+            'entities/clients',
+            'entities/prospects',
+            'entities/companies',
+            'entities/initiatives',
+            'systems/api',
+            'systems/tools',
+            'systems/shared',
+            'focus/current',
+            'focus/recent',
+            'focus/breadcrumbs',
+            'focus/stack',
+        ];
+        for (const dir of directories) {
+            const fullPath = path.join(workspaceRoot, dir);
+            if (!fs.existsSync(fullPath)) {
+                fs.mkdirSync(fullPath, { recursive: true });
+                this.log(`✓ Created ${chalk_1.default.green(dir)}`);
+            }
+            else {
+                this.log(`  ${chalk_1.default.dim(dir)} (already exists)`);
+            }
+        }
+        // Create workspace configuration
+        const workspaceConfigPath = path.join(workspaceRoot, '.workspace', 'config.yaml');
+        const workspaceConfigDir = path.dirname(workspaceConfigPath);
+        if (!fs.existsSync(workspaceConfigDir)) {
+            fs.mkdirSync(workspaceConfigDir, { recursive: true });
+        }
+        if (!fs.existsSync(workspaceConfigPath) || force) {
+            const workspaceConfig = this.generateWorkspaceConfig();
+            fs.writeFileSync(workspaceConfigPath, workspaceConfig);
+            this.log(`✓ Created ${chalk_1.default.green('.workspace/config.yaml')}`);
+        }
+        else {
+            this.log(`  ${chalk_1.default.dim('.workspace/config.yaml')} (already exists)`);
+        }
+        // Create contexts configuration
+        const contextsConfigPath = path.join(workspaceRoot, '.workspace', 'contexts.yaml');
+        if (!fs.existsSync(contextsConfigPath) || force) {
+            const contextsConfig = this.generateContextsConfig();
+            fs.writeFileSync(contextsConfigPath, contextsConfig);
+            this.log(`✓ Created ${chalk_1.default.green('.workspace/contexts.yaml')}`);
+        }
+        else {
+            this.log(`  ${chalk_1.default.dim('.workspace/contexts.yaml')} (already exists)`);
+        }
+        this.log(chalk_1.default.dim('\n─'.repeat(50)));
+        this.log(chalk_1.default.green('✅ Workspace structure initialized'));
+        this.log(chalk_1.default.dim('Next steps:'));
+        this.log(chalk_1.default.dim('• Add entities: gut entity add <name> <type> <path>'));
+        this.log(chalk_1.default.dim('• Generate metadata: gut workspace generate-metadata'));
+        this.log(chalk_1.default.dim('• Set focus: gut focus client <name>'));
+    }
+    async showWorkspaceStructure() {
+        const workspaceRoot = this.configService.getWorkspaceRoot();
+        this.log(chalk_1.default.bold('\n📁 Workspace Structure'));
+        this.log(chalk_1.default.dim('─'.repeat(50)));
+        // Show directory tree
+        this.showDirectoryTree(workspaceRoot, '', 0, 2);
+        // Show entities summary
+        const entities = this.entityService.getAllEntities();
+        if (entities.length > 0) {
+            this.log(chalk_1.default.bold('\n🏢 Entities Summary'));
+            this.log(chalk_1.default.dim('─'.repeat(50)));
+            const byType = entities.reduce((acc, entity) => {
+                if (!acc[entity.type])
+                    acc[entity.type] = 0;
+                acc[entity.type]++;
+                return acc;
+            }, {});
+            for (const [type, count] of Object.entries(byType)) {
+                const emoji = this.getTypeEmoji(type);
+                this.log(`${emoji} ${type}: ${count}`);
+            }
+        }
+    }
+    showDirectoryTree(dirPath, prefix, depth, maxDepth) {
+        if (depth > maxDepth)
+            return;
+        try {
+            const items = fs.readdirSync(dirPath)
+                .filter(item => !item.startsWith('.') || item === '.workspace')
+                .sort();
+            items.forEach((item, index) => {
+                const itemPath = path.join(dirPath, item);
+                const isLast = index === items.length - 1;
+                const currentPrefix = isLast ? '└── ' : '├── ';
+                const nextPrefix = prefix + (isLast ? '    ' : '│   ');
+                try {
+                    const stats = fs.statSync(itemPath);
+                    if (stats.isDirectory()) {
+                        this.log(`${prefix}${currentPrefix}${chalk_1.default.blue(item)}/`);
+                        if (depth < maxDepth) {
+                            this.showDirectoryTree(itemPath, nextPrefix, depth + 1, maxDepth);
+                        }
+                    }
+                    else {
+                        this.log(`${prefix}${currentPrefix}${item}`);
+                    }
+                }
+                catch {
+                    // Skip items we can't access
+                }
+            });
+        }
+        catch {
+            // Skip directories we can't read
+        }
+    }
+    async generateEntityMetadata(entityType, force) {
+        const entities = entityType
+            ? this.entityService.getEntitiesByType(entityType)
+            : this.entityService.getAllEntities();
+        if (entities.length === 0) {
+            this.error('No entities found. Add entities first with "gut entity add"');
+        }
+        this.log(chalk_1.default.bold('\n📝 Generating Entity Metadata'));
+        this.log(chalk_1.default.dim('─'.repeat(50)));
+        for (const entity of entities) {
+            const entityPath = this.entityService.resolveEntityPath(entity);
+            const metadataPath = path.join(entityPath, '.entity.yaml');
+            if (fs.existsSync(metadataPath) && !force) {
+                this.log(`  ${chalk_1.default.dim(entity.name)} (metadata already exists)`);
+                continue;
+            }
+            // Ensure entity directory exists
+            if (!fs.existsSync(entityPath)) {
+                fs.mkdirSync(entityPath, { recursive: true });
+            }
+            const metadata = this.generateEntityMetadataContent(entity);
+            fs.writeFileSync(metadataPath, metadata);
+            this.log(`✓ Generated metadata for ${chalk_1.default.green(entity.name)}`);
+        }
+        this.log(chalk_1.default.dim('\n─'.repeat(50)));
+        this.log(chalk_1.default.green('✅ Entity metadata generated'));
+    }
+    generateWorkspaceConfig() {
+        return `# DevSquad Context Operating System - Workspace Configuration
+# Generated on ${new Date().toISOString()}
+
+workspace:
+  version: "1.0"
+  name: "DevSquad Workspace"
+  description: "Context-aware development workspace"
+  
+  structure:
+    entities_dir: "entities"
+    systems_dir: "systems"
+    focus_dir: "focus"
+    
+  settings:
+    default_focus_mode: "delivery"
+    auto_context_generation: true
+    focus_session_tracking: true
+    
+  integrations:
+    git:
+      auto_sync: false
+      multi_repo_operations: true
+    ai:
+      context_generation: true
+      persona_switching: true
+    jira:
+      enabled: false
+      base_url: ""
+      
+# Entity type definitions
+entity_types:
+  client:
+    description: "Active client relationships"
+    default_modes: ["delivery", "strategy", "audit"]
+    
+  prospect:
+    description: "Potential client relationships"
+    default_modes: ["research", "proposal"]
+    
+  company:
+    description: "DevSquad group companies"
+    default_modes: ["strategy", "audit"]
+    
+  initiative:
+    description: "Strategic cross-entity initiatives"
+    default_modes: ["strategy", "delivery"]
+    
+  system:
+    description: "Supporting systems and infrastructure"
+    default_modes: ["delivery", "debug"]
+`;
+    }
+    generateContextsConfig() {
+        return `# Context Definitions for AI and Focus Management
+# Generated on ${new Date().toISOString()}
+
+contexts:
+  # Example client context
+  # clients:
+  #   mindtools:
+  #     type: "client"
+  #     description: "MindTools React platform - 24M+ users"
+  #     status: "active_development"
+  #     
+  #     repositories:
+  #       primary: "entities/clients/mindtools/delivery"
+  #       private: "entities/clients/mindtools/business"
+  #       related: ["systems/api", "systems/shared/design-system"]
+  #     
+  #     focus_modes:
+  #       delivery:
+  #         include: ["delivery/repos/", "systems/shared/design-system/"]
+  #         exclude: ["business/contracts/"]
+  #         ai_persona: "senior_react_developer"
+  #         suggested_duration: "1h 30m"
+  #         
+  #       strategy:
+  #         include: ["delivery/", "business/", "insights/"]
+  #         exclude: []
+  #         ai_persona: "ceo_strategic_advisor"
+  #         suggested_duration: "2h 30m"
+
+# Focus mode definitions
+focus_modes:
+  delivery:
+    description: "Technical development and implementation"
+    typical_duration: "1-2 hours"
+    ai_persona: "senior_developer"
+    
+  strategy:
+    description: "Business strategy and planning"
+    typical_duration: "2-3 hours"
+    ai_persona: "strategic_advisor"
+    
+  audit:
+    description: "Review and compliance analysis"
+    typical_duration: "45-90 minutes"
+    ai_persona: "business_auditor"
+    
+  debug:
+    description: "Problem investigation and resolution"
+    typical_duration: "30-60 minutes"
+    ai_persona: "debugging_specialist"
+    
+  research:
+    description: "Market and technical research"
+    typical_duration: "1-2 hours"
+    ai_persona: "research_analyst"
+    
+  proposal:
+    description: "Proposal preparation and client communication"
+    typical_duration: "2-4 hours"
+    ai_persona: "business_consultant"
+`;
+    }
+    generateEntityMetadataContent(entity) {
+        const now = new Date().toISOString();
+        return `# Entity Metadata for ${entity.name}
+# Generated on ${now}
+
+entity:
+  type: "${entity.type}"
+  name: "${entity.name}"
+  description: "${entity.description || `${entity.type} entity: ${entity.name}`}"
+  created: "${now}"
+  
+# Business information (for client/prospect entities)
+business:
+  # primary_contact: ""
+  # contract_value: ""
+  # team_size: 0
+  # priority: "medium"  # low, medium, high
+  # status: "active"
+
+# Relationships with other entities
+relationships:
+  # similar_entities: []
+  # dependent_systems: ["systems/api"]
+  # related_initiatives: []
+
+# Working patterns and preferences
+working_patterns:
+  # typical_focus_duration: "2h"
+  # common_paired_entities: []
+  # strategic_review_frequency: "weekly"
+  # productive_times: ["9-11am", "2-4pm"]
+
+# AI context configuration
+ai_context:
+  # persona: "senior_developer"
+  # knowledge_scope: "complete_technical_context"
+  # decision_authority: "technical_implementation"
+
+# Focus intelligence (learned from usage)
+focus_intelligence:
+  # optimal_session_duration: ""
+  # average_interruptions: 0
+  # effectiveness_metrics:
+  #   commits_per_session: 0
+  #   lines_changed_per_session: 0
+  #   issues_resolved_per_session: 0
+
+# Repository information
+repository:
+  path: "${entity.path}"
+  # remote: "${entity.repository || ''}"
+  # branch: "main"
+  # last_sync: ""
+`;
+    }
+}
+exports.default = Workspace;

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/dist/models/entity.model.d.ts

@@ -0,0 +1,81 @@
+export type EntityType = 'client' | 'prospect' | 'company' | 'initiative' | 'system' | 'delivery' | 'module' | 'service' | 'tool';
+export type FocusMode = 'delivery' | 'strategy' | 'audit' | 'debug' | 'research' | 'proposal';
+export interface Entity {
+    name: string;
+    type: EntityType;
+    path: string;
+    repository?: string;
+    repo?: string;
+    remote?: string;
+    description?: string;
+    metadata?: EntityMetadata;
+}
+export interface EntityMetadata {
+    business?: {
+        primary_contact?: string;
+        contract_value?: string;
+        team_size?: number;
+        priority?: 'low' | 'medium' | 'high';
+        status?: string;
+    };
+    relationships?: {
+        similar_entities?: string[];
+        dependent_systems?: string[];
+        related_initiatives?: string[];
+    };
+    working_patterns?: {
+        typical_focus_duration?: string;
+        common_paired_entities?: string[];
+        strategic_review_frequency?: string;
+    };
+    ai_context?: {
+        persona?: string;
+        knowledge_scope?: string;
+        decision_authority?: string;
+    };
+}
+export interface Focus {
+    type: string;
+    name: string;
+    path: string;
+    timestamp?: number;
+    entities?: Entity[];
+    mode?: FocusMode;
+    duration?: string;
+    remember?: boolean;
+}
+export interface FocusContext {
+    current_focus?: Focus;
+    entity_type?: EntityType;
+    entity_name?: string;
+    mode?: FocusMode;
+    duration?: string;
+    start_time?: string;
+    ai_context?: {
+        persona?: string;
+        knowledge_scope?: string[];
+        available_data?: Record<string, any>;
+        suggested_actions?: string[];
+        restricted_knowledge?: string[];
+    };
+}
+export interface HistoryEntry {
+    entities: string[];
+    timestamp: number;
+}
+export interface Config {
+    initialized: boolean;
+    entities: Entity[];
+    workspace?: string;
+    defaultRemote?: string;
+}
+export interface RepoStatus {
+    entity: string;
+    path: string;
+    branch: string;
+    ahead: number;
+    behind: number;
+    changes: string[];
+    untracked: string[];
+    hasChanges: boolean;
+}

package/dist/models/entity.model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,34 @@
+import { Config, Focus, HistoryEntry, FocusContext } from '../models/entity.model';
+export declare class ConfigService {
+    private readonly workspaceRoot;
+    private readonly gutDir;
+    private readonly focusFile;
+    private readonly configFile;
+    private readonly historyFile;
+    private readonly focusContextFile;
+    private readonly focusDir;
+    private config;
+    private focus;
+    private history;
+    constructor(workspaceRoot?: string);
+    private ensureDirectories;
+    private loadAll;
+    loadConfig(): Promise<Config>;
+    private loadConfigSync;
+    private loadFocus;
+    private loadHistory;
+    getConfig(): Config;
+    saveConfig(config: Config): void;
+    getFocus(): Focus | null;
+    saveFocus(focus: Focus | null): void;
+    getHistory(): HistoryEntry[];
+    addToHistory(focus: Focus): void;
+    clearHistory(): void;
+    isInitialized(): boolean;
+    getWorkspaceRoot(): string;
+    initWorkspace(workspacePath: string): Promise<void>;
+    getGutDir(): string;
+    saveFocusContext(context: FocusContext): Promise<void>;
+    private convertToYaml;
+    getFocusDir(): string;
+}