@compilr-dev/cli 0.4.0

package/dist/themes/registry.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Theme Registry
+ *
+ * Load, save, and manage themes.
+ * Persistence in ~/.compilr-dev/settings.json
+ */
+import type { Theme, ThemeConfig } from './types.js';
+/**
+ * Get all available themes
+ */
+export declare function getAllThemes(): Theme[];
+/**
+ * Get curated/featured themes
+ */
+export declare function getCuratedThemes(): Theme[];
+/**
+ * Get theme by ID
+ */
+export declare function getThemeById(id: string): Theme | undefined;
+/**
+ * Search themes by name (case-insensitive)
+ */
+export declare function searchThemes(query: string): Theme[];
+/**
+ * Filter themes by type
+ */
+export declare function filterThemesByType(type: 'all' | 'dark' | 'light'): Theme[];
+/**
+ * Search and filter themes
+ */
+export declare function searchAndFilterThemes(query: string, type: 'all' | 'dark' | 'light'): Theme[];
+/**
+ * Get theme count
+ */
+export declare function getThemeCount(): {
+    total: number;
+    dark: number;
+    light: number;
+    curated: number;
+};
+/**
+ * Load theme config
+ */
+export declare function loadThemeConfig(): ThemeConfig;
+/**
+ * Save theme config
+ */
+export declare function saveThemeConfig(config: ThemeConfig): void;
+/**
+ * Get current theme (cached)
+ */
+export declare function getCurrentTheme(): Theme;
+/**
+ * Set current theme
+ */
+export declare function setCurrentTheme(themeId: string): Theme;
+/**
+ * Clear theme cache (for testing or forced reload)
+ */
+export declare function clearThemeCache(): void;

package/dist/themes/registry.js

@@ -0,0 +1,195 @@
+/**
+ * Theme Registry
+ *
+ * Load, save, and manage themes.
+ * Persistence in ~/.compilr-dev/settings.json
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+// =============================================================================
+// Constants
+// =============================================================================
+const CONFIG_DIR = path.join(os.homedir(), '.compilr-dev');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'settings.json');
+const DEFAULT_THEME = 'compilr-dark';
+// =============================================================================
+// Theme Data (loaded once)
+// =============================================================================
+// Load themes from JSON file
+// Resolve path relative to this file's location (works in both src and dist)
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Try multiple possible locations for themes.json
+function loadThemes() {
+    const possiblePaths = [
+        path.join(__dirname, '../data/themes.json'), // dist/themes -> dist/data
+        path.join(__dirname, '../../src/data/themes.json'), // dist/themes -> src/data
+        path.join(__dirname, '../../data/themes.json'), // src/themes -> data (if running from src)
+    ];
+    for (const themePath of possiblePaths) {
+        if (fs.existsSync(themePath)) {
+            const data = fs.readFileSync(themePath, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    throw new Error(`themes.json not found. Tried: ${possiblePaths.join(', ')}`);
+}
+const themesData = loadThemes();
+// =============================================================================
+// Theme Query Functions
+// =============================================================================
+/**
+ * Get all available themes
+ */
+export function getAllThemes() {
+    return themesData;
+}
+/**
+ * Get curated/featured themes
+ */
+export function getCuratedThemes() {
+    return themesData.filter((t) => t.curated);
+}
+/**
+ * Get theme by ID
+ */
+export function getThemeById(id) {
+    return themesData.find((t) => t.id === id);
+}
+/**
+ * Search themes by name (case-insensitive)
+ */
+export function searchThemes(query) {
+    if (!query.trim())
+        return themesData;
+    const lower = query.toLowerCase();
+    return themesData.filter((t) => t.name.toLowerCase().includes(lower));
+}
+/**
+ * Filter themes by type
+ */
+export function filterThemesByType(type) {
+    if (type === 'all')
+        return themesData;
+    return themesData.filter((t) => t.type === type);
+}
+/**
+ * Search and filter themes
+ */
+export function searchAndFilterThemes(query, type) {
+    let results = themesData;
+    // Apply type filter
+    if (type !== 'all') {
+        results = results.filter((t) => t.type === type);
+    }
+    // Apply search
+    if (query.trim()) {
+        const lower = query.toLowerCase();
+        results = results.filter((t) => t.name.toLowerCase().includes(lower));
+    }
+    return results;
+}
+/**
+ * Get theme count
+ */
+export function getThemeCount() {
+    return {
+        total: themesData.length,
+        dark: themesData.filter((t) => t.type === 'dark').length,
+        light: themesData.filter((t) => t.type === 'light').length,
+        curated: themesData.filter((t) => t.curated).length,
+    };
+}
+/**
+ * Load settings from config file
+ */
+function loadSettings() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            const data = fs.readFileSync(CONFIG_FILE, 'utf-8');
+            return JSON.parse(data);
+        }
+    }
+    catch {
+        // Ignore errors, return defaults
+    }
+    return {};
+}
+/**
+ * Save settings to config file
+ */
+function saveSettings(settings) {
+    try {
+        fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(settings, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to save settings:', error);
+    }
+}
+/**
+ * Load theme config
+ */
+export function loadThemeConfig() {
+    const settings = loadSettings();
+    return {
+        currentTheme: settings.theme || DEFAULT_THEME,
+    };
+}
+/**
+ * Save theme config
+ */
+export function saveThemeConfig(config) {
+    const settings = loadSettings();
+    settings.theme = config.currentTheme;
+    saveSettings(settings);
+}
+// =============================================================================
+// Current Theme Management
+// =============================================================================
+// In-memory cache of current theme
+let currentThemeCache = null;
+/**
+ * Get current theme (cached)
+ */
+export function getCurrentTheme() {
+    if (currentThemeCache) {
+        return currentThemeCache;
+    }
+    const config = loadThemeConfig();
+    const theme = getThemeById(config.currentTheme);
+    if (theme) {
+        currentThemeCache = theme;
+        return theme;
+    }
+    // Fallback to default
+    const defaultTheme = getThemeById(DEFAULT_THEME);
+    if (defaultTheme) {
+        currentThemeCache = defaultTheme;
+        return defaultTheme;
+    }
+    // Ultimate fallback - first theme in list
+    currentThemeCache = themesData[0];
+    return themesData[0];
+}
+/**
+ * Set current theme
+ */
+export function setCurrentTheme(themeId) {
+    const theme = getThemeById(themeId);
+    if (!theme) {
+        throw new Error(`Theme not found: ${themeId}`);
+    }
+    saveThemeConfig({ currentTheme: themeId });
+    currentThemeCache = theme;
+    return theme;
+}
+/**
+ * Clear theme cache (for testing or forced reload)
+ */
+export function clearThemeCache() {
+    currentThemeCache = null;
+}

package/dist/themes/types.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Theme Types
+ *
+ * Type definitions for the 418-theme system.
+ * Themes sourced from Ghostty terminal themes (MIT licensed).
+ */
+export interface Theme {
+    /** Unique identifier (e.g., "compilr-dark", "dracula") */
+    id: string;
+    /** Display name (e.g., "compilr.dev Dark", "Dracula") */
+    name: string;
+    /** Theme type */
+    type: 'dark' | 'light';
+    /** Source of the theme (e.g., "custom", "ghostty") */
+    source: string;
+    /** Theme author */
+    author?: string;
+    /** Color palette */
+    colors: ThemeColors;
+    /** Whether this is a curated/featured theme */
+    curated?: boolean;
+}
+export interface ThemeColors {
+    /** Background color (e.g., "#0A0A0A") */
+    background: string;
+    /** Foreground/text color (e.g., "#FAFAFA") */
+    foreground: string;
+    /** Primary accent color (e.g., "#FF5722") */
+    primary: string;
+    /** Secondary accent color */
+    secondary?: string;
+    /** Border color */
+    border: string;
+    /** Card/panel background color */
+    card?: string;
+    /** Muted/dim text color */
+    muted: string;
+    /** Selection highlight color */
+    selection: string;
+    /** Cursor color */
+    cursor: string;
+}
+export interface ThemeConfig {
+    /** Currently selected theme ID */
+    currentTheme: string;
+}
+export interface ThemeStyleFunctions {
+    /** Primary accent color (headers, emphasis) */
+    primary: (text: string) => string;
+    /** Secondary accent color (links, highlights) */
+    secondary: (text: string) => string;
+    /** Normal foreground text */
+    foreground: (text: string) => string;
+    /** Muted/dim text (metadata, hints) */
+    muted: (text: string) => string;
+    /** Border color */
+    border: (text: string) => string;
+    /** Background color (for background on text) */
+    background: (text: string) => string;
+    /** Card/panel background color */
+    card: (text: string) => string;
+    /** Selection highlight color */
+    selection: (text: string) => string;
+    /** Cursor color */
+    cursor: (text: string) => string;
+    /** Success messages (green) */
+    success: (text: string) => string;
+    /** Warning messages (yellow) */
+    warning: (text: string) => string;
+    /** Error messages (red) */
+    error: (text: string) => string;
+    /** Info messages (cyan/blue) */
+    info: (text: string) => string;
+    /** Bold text in primary color */
+    primaryBold: (text: string) => string;
+    /** Inverse (swap fg/bg) */
+    inverse: (text: string) => string;
+    /** Text with selection background */
+    selected: (text: string) => string;
+    /** Text on card background */
+    onCard: (text: string) => string;
+}

package/dist/themes/types.js

@@ -0,0 +1,7 @@
+/**
+ * Theme Types
+ *
+ * Type definitions for the 418-theme system.
+ * Themes sourced from Ghostty terminal themes (MIT licensed).
+ */
+export {};

package/dist/tool-selector.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Tool Selector - Category-based tool filtering
+ *
+ * Reduces token usage by selecting only relevant tools based on user intent.
+ * This is a PoC implementation to validate the approach before adding to the library.
+ */
+import type { Tool } from '@compilr-dev/agents';
+/**
+ * Tool categories for grouping related tools
+ */
+export declare const TOOL_CATEGORIES: Record<string, string[]>;
+/**
+ * Intent detection rules - maps keywords to relevant categories
+ */
+export declare const INTENT_RULES: Array<{
+    keywords: string[];
+    categories: string[];
+}>;
+/**
+ * Default tools to always include (core functionality)
+ */
+export declare const CORE_TOOLS: string[];
+/**
+ * Select relevant tool names based on user message intent
+ */
+export declare function selectToolNamesByIntent(userMessage: string): string[];
+/**
+ * Filter tools array to only include selected tool names
+ */
+export declare function filterTools(allTools: Tool[], selectedNames: string[]): Tool[];
+/**
+ * Get a human-readable summary of selected tools
+ */
+export declare function getToolSelectionSummary(selectedNames: string[], totalTools: number): string;
+/**
+ * Estimate token savings from tool filtering
+ */
+export declare function estimateTokenSavings(selectedCount: number, totalCount: number, avgTokensPerTool?: number): {
+    selected: number;
+    total: number;
+    saved: number;
+    percentage: number;
+};
+/**
+ * ToolSelector class for stateful tool selection
+ */
+export declare class ToolSelector {
+    private readonly allTools;
+    private readonly toolsByName;
+    constructor(tools: Tool[]);
+    /**
+     * Select tools based on user message
+     */
+    select(userMessage: string): Tool[];
+    /**
+     * Get tools by name
+     */
+    getToolsByNames(names: string[]): Tool[];
+    /**
+     * Get all tools
+     */
+    getAll(): Tool[];
+    /**
+     * Get tool count
+     */
+    get count(): number;
+    /**
+     * Get selection summary for a message
+     */
+    getSummary(userMessage: string): string;
+}

package/dist/tool-selector.js

@@ -0,0 +1,184 @@
+/**
+ * Tool Selector - Category-based tool filtering
+ *
+ * Reduces token usage by selecting only relevant tools based on user intent.
+ * This is a PoC implementation to validate the approach before adding to the library.
+ */
+/**
+ * Tool categories for grouping related tools
+ */
+export const TOOL_CATEGORIES = {
+    file_ops: ['read_file', 'write_file', 'edit', 'glob'],
+    shell: ['bash'],
+    git: ['git_status', 'git_diff', 'git_log', 'git_commit', 'git_branch'],
+    search: ['grep', 'glob'],
+    project: ['detect_project', 'find_project_root', 'run_tests', 'run_lint'],
+    task_mgmt: ['todo_write', 'todo_read'],
+    delegation: ['task'],
+};
+/**
+ * Intent detection rules - maps keywords to relevant categories
+ */
+export const INTENT_RULES = [
+    // Git operations
+    {
+        keywords: ['git', 'commit', 'branch', 'diff', 'status', 'log', 'push', 'pull'],
+        categories: ['git'],
+    },
+    // Search operations
+    {
+        keywords: ['search', 'find', 'grep', 'look for', 'where is', 'locate'],
+        categories: ['search', 'file_ops'],
+    },
+    // Shell/command operations
+    {
+        keywords: ['run', 'execute', 'command', 'shell', 'echo', 'npm', 'node'],
+        categories: ['shell'],
+    },
+    // Project operations
+    {
+        keywords: ['test', 'lint', 'build', 'project', 'framework', 'type of'],
+        categories: ['project', 'shell'],
+    },
+    // File operations
+    {
+        keywords: ['file', 'read', 'write', 'edit', 'create', 'modify', 'replace', 'content'],
+        categories: ['file_ops'],
+    },
+    // Todo operations
+    {
+        keywords: ['todo', 'task', 'list', 'add item', 'show todos'],
+        categories: ['task_mgmt'],
+    },
+    // Directory/file listing
+    {
+        keywords: ['list', 'files', 'directory', 'folder', 'typescript', '*.ts'],
+        categories: ['file_ops', 'search'],
+    },
+    // Delegation / sub-agents
+    {
+        keywords: [
+            'explore',
+            'investigate',
+            'analyze',
+            'review code',
+            'code review',
+            'security audit',
+            'refactor',
+            'help me find',
+            'search the codebase',
+            'look through',
+            'scan for',
+            'debug',
+            'figure out',
+            'understand',
+            'complex task',
+            'multi-step',
+            'delegate',
+            'sub-agent',
+            'agent',
+        ],
+        categories: ['delegation', 'search', 'file_ops'],
+    },
+];
+/**
+ * Default tools to always include (core functionality)
+ */
+export const CORE_TOOLS = ['bash', 'read_file'];
+/**
+ * Select relevant tool names based on user message intent
+ */
+export function selectToolNamesByIntent(userMessage) {
+    const message = userMessage.toLowerCase();
+    const selectedCategories = new Set();
+    // Match intent rules
+    for (const rule of INTENT_RULES) {
+        if (rule.keywords.some((kw) => message.includes(kw))) {
+            rule.categories.forEach((cat) => selectedCategories.add(cat));
+        }
+    }
+    // If no categories matched, use default
+    if (selectedCategories.size === 0) {
+        return [...CORE_TOOLS];
+    }
+    // Flatten categories to tool names
+    const toolNames = new Set(CORE_TOOLS);
+    for (const category of selectedCategories) {
+        const tools = TOOL_CATEGORIES[category];
+        // Always execute - tools is guaranteed to exist by categoryNames definition
+        tools.forEach((t) => toolNames.add(t));
+    }
+    return Array.from(toolNames);
+}
+/**
+ * Filter tools array to only include selected tool names
+ */
+export function filterTools(allTools, selectedNames) {
+    const nameSet = new Set(selectedNames);
+    return allTools.filter((tool) => nameSet.has(tool.definition.name));
+}
+/**
+ * Get a human-readable summary of selected tools
+ */
+export function getToolSelectionSummary(selectedNames, totalTools) {
+    const savings = Math.round((1 - selectedNames.length / totalTools) * 100);
+    return `[Tools: ${String(selectedNames.length)}/${String(totalTools)} selected (${String(savings)}% reduction): ${selectedNames.join(', ')}]`;
+}
+/**
+ * Estimate token savings from tool filtering
+ */
+export function estimateTokenSavings(selectedCount, totalCount, avgTokensPerTool = 200) {
+    const selected = selectedCount * avgTokensPerTool;
+    const total = totalCount * avgTokensPerTool;
+    const saved = total - selected;
+    const percentage = Math.round((saved / total) * 100);
+    return { selected, total, saved, percentage };
+}
+/**
+ * ToolSelector class for stateful tool selection
+ */
+export class ToolSelector {
+    allTools;
+    toolsByName;
+    constructor(tools) {
+        this.allTools = tools;
+        this.toolsByName = new Map();
+        for (const tool of tools) {
+            this.toolsByName.set(tool.definition.name, tool);
+        }
+    }
+    /**
+     * Select tools based on user message
+     */
+    select(userMessage) {
+        const names = selectToolNamesByIntent(userMessage);
+        return this.getToolsByNames(names);
+    }
+    /**
+     * Get tools by name
+     */
+    getToolsByNames(names) {
+        return names
+            .map((name) => this.toolsByName.get(name))
+            .filter((tool) => tool !== undefined);
+    }
+    /**
+     * Get all tools
+     */
+    getAll() {
+        return this.allTools;
+    }
+    /**
+     * Get tool count
+     */
+    get count() {
+        return this.allTools.length;
+    }
+    /**
+     * Get selection summary for a message
+     */
+    getSummary(userMessage) {
+        const selected = selectToolNamesByIntent(userMessage);
+        return getToolSelectionSummary(selected, this.allTools.length);
+    }
+}

package/dist/tools/ask-user-simple.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Ask User Simple Tool - Single question with flat schema
+ *
+ * A simplified version of ask_user designed for smaller models.
+ * Uses a flat schema (no arrays of objects) that's easier for
+ * models like Haiku, Flash, and GPT-4o-mini to generate correctly.
+ *
+ * Used by /sketch command for quick project outlines.
+ */
+interface AskUserSimpleInput {
+    /** The question text */
+    question: string;
+    /** Predefined options (optional, max 5) */
+    options?: string[];
+    /** Allow free-text input (default: true) */
+    allowCustom?: boolean;
+}
+export declare const askUserSimpleTool: import("@compilr-dev/agents").Tool<AskUserSimpleInput>;
+export {};