@grunnverk/kilde 0.1.0

package/src/constants.ts

@@ -0,0 +1,162 @@
+import os from 'os';
+import path from 'path';
+
+/**
+ * Version and build information (replaced at build time)
+ */
+export const VERSION = '__VERSION__ (__GIT_BRANCH__/__GIT_COMMIT__ __GIT_TAGS__ __GIT_COMMIT_DATE__) __SYSTEM_INFO__';
+export const BUILD_HOSTNAME = '__BUILD_HOSTNAME__';
+export const BUILD_TIMESTAMP = '__BUILD_TIMESTAMP__';
+
+/**
+ * Program identification
+ */
+export const PROGRAM_NAME = 'kilde';
+
+/**
+ * Character encodings
+ */
+export const DEFAULT_CHARACTER_ENCODING = 'utf-8';
+export const DEFAULT_BINARY_TO_TEXT_ENCODING = 'base64';
+
+/**
+ * Global defaults
+ */
+export const DEFAULT_VERBOSE = false;
+export const DEFAULT_DRY_RUN = false;
+export const DEFAULT_DEBUG = false;
+export const DEFAULT_MODEL = 'gpt-4o-mini';
+export const DEFAULT_MODEL_STRONG = 'gpt-4o';
+export const DEFAULT_OPENAI_REASONING = 'low';
+export const DEFAULT_OPENAI_MAX_OUTPUT_TOKENS = 10000;
+export const DEFAULT_OUTPUT_DIRECTORY = 'output/kilde';
+
+/**
+ * Buffer size for git commands that may produce large output
+ */
+export const DEFAULT_GIT_COMMAND_MAX_BUFFER = 50 * 1024 * 1024; // 50MB
+
+/**
+ * Configuration directories
+ */
+export const DEFAULT_CONFIG_DIR = '.kilde';
+export const DEFAULT_PREFERENCES_DIRECTORY = path.join(os.homedir(), '.kilde');
+
+/**
+ * Git commit aliases
+ */
+export const DEFAULT_FROM_COMMIT_ALIAS = 'main';
+export const DEFAULT_TO_COMMIT_ALIAS = 'HEAD';
+
+/**
+ * Commit command defaults
+ */
+export const DEFAULT_ADD = false;
+export const DEFAULT_CACHED = false;
+export const DEFAULT_SENDIT_MODE = false;
+export const DEFAULT_INTERACTIVE_MODE = false;
+export const DEFAULT_AMEND_MODE = false;
+// CRITICAL: Keep this low (3-5) to prevent log context contamination.
+// The LLM tends to pattern-match against recent commits instead of describing
+// the actual diff when it sees too much commit history. Set to 0 to disable.
+export const DEFAULT_MESSAGE_LIMIT = 3;
+export const DEFAULT_MAX_DIFF_BYTES = 20480; // 20KB limit per file
+
+/**
+ * Excluded patterns for git operations
+ */
+export const DEFAULT_EXCLUDED_PATTERNS = [
+    'node_modules', 'package-lock.json', 'yarn.lock', 'bun.lockb',
+    'composer.lock', 'Cargo.lock', 'Gemfile.lock',
+    'dist', 'build', 'out', '.next', '.nuxt', 'coverage',
+    '.vscode', '.idea', '.DS_Store', '.git', '.gitignore',
+    'logs', 'tmp', '.cache', '*.log', '.env', '.env.*',
+    '*.pem', '*.crt', '*.key', '*.sqlite', '*.db',
+    '*.zip', '*.tar', '*.gz', '*.exe', '*.bin'
+];
+
+/**
+ * Available commands
+ */
+export const COMMAND_COMMIT = 'commit';
+export const COMMAND_RELEASE = 'release';
+
+export const ALLOWED_COMMANDS = [
+    COMMAND_COMMIT,
+    COMMAND_RELEASE,
+];
+
+export const DEFAULT_COMMAND = COMMAND_COMMIT;
+
+/**
+ * Default ignore patterns for file operations
+ */
+export const DEFAULT_IGNORE_PATTERNS = [
+    'node_modules/**',
+    '**/*.log',
+    '.git/**',
+    'dist/**',
+    'build/**',
+    'coverage/**',
+    'output/**',
+    '.DS_Store',
+    '*.tmp',
+    '*.cache',
+    '**/.kilde-*.json',
+];
+
+/**
+ * Directory prefix for kilde internal files
+ */
+export const DEFAULT_DIRECTORY_PREFIX = '.kilde';
+
+/**
+ * Date formats
+ */
+export const DATE_FORMAT_YEAR_MONTH_DAY = 'YYYY-MM-DD';
+export const DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS = 'YYYY-MM-DD-HHmmss';
+export const INTERNAL_DATETIME_FORMAT = 'YYYY-MM-DD_HH-mm-ss';
+
+/**
+ * Kilde defaults configuration object
+ */
+export const KILDE_DEFAULTS = {
+    dryRun: DEFAULT_DRY_RUN,
+    verbose: DEFAULT_VERBOSE,
+    debug: DEFAULT_DEBUG,
+    model: DEFAULT_MODEL,
+    openaiReasoning: DEFAULT_OPENAI_REASONING as 'low' | 'medium' | 'high',
+    openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS,
+    outputDirectory: DEFAULT_OUTPUT_DIRECTORY,
+    configDirectory: DEFAULT_CONFIG_DIR,
+    discoveredConfigDirs: [] as string[],
+    resolvedConfigDirs: [] as string[],
+    excludedPatterns: DEFAULT_EXCLUDED_PATTERNS,
+    contextDirectories: [] as string[],
+    overrides: false,
+
+    commit: {
+        add: DEFAULT_ADD,
+        cached: DEFAULT_CACHED,
+        sendit: DEFAULT_SENDIT_MODE,
+        interactive: DEFAULT_INTERACTIVE_MODE,
+        amend: DEFAULT_AMEND_MODE,
+        messageLimit: DEFAULT_MESSAGE_LIMIT,
+        skipFileCheck: false,
+        maxDiffBytes: DEFAULT_MAX_DIFF_BYTES,
+        contextFiles: undefined,
+        openaiReasoning: DEFAULT_OPENAI_REASONING as 'low' | 'medium' | 'high',
+        openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS,
+    },
+
+    release: {
+        fromTag: undefined,
+        toTag: 'HEAD',
+        messageLimit: DEFAULT_MESSAGE_LIMIT,
+        interactive: DEFAULT_INTERACTIVE_MODE,
+        maxDiffBytes: DEFAULT_MAX_DIFF_BYTES,
+        contextFiles: undefined,
+        openaiReasoning: DEFAULT_OPENAI_REASONING as 'low' | 'medium' | 'high',
+        openaiMaxOutputTokens: DEFAULT_OPENAI_MAX_OUTPUT_TOKENS,
+    },
+};

package/src/logging.ts

@@ -0,0 +1,210 @@
+import winston from 'winston';
+// eslint-disable-next-line no-restricted-imports
+import * as fs from 'fs';
+import path from 'path';
+import { DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS, PROGRAM_NAME, DEFAULT_OUTPUT_DIRECTORY } from './constants';
+
+export interface LogContext {
+    [key: string]: any;
+}
+
+// Track if debug directory has been ensured for this session
+let debugDirectoryEnsured = false;
+
+const ensureDebugDirectory = () => {
+    if (debugDirectoryEnsured) return;
+
+    const debugDir = path.join(DEFAULT_OUTPUT_DIRECTORY, 'debug');
+
+    try {
+        fs.mkdirSync(debugDir, { recursive: true });
+        debugDirectoryEnsured = true;
+    } catch (error) {
+        // eslint-disable-next-line no-console
+        console.error(`Failed to create debug directory ${debugDir}:`, error);
+    }
+};
+
+const generateDebugLogFilename = () => {
+    const now = new Date();
+    const timestamp = now.toISOString()
+        .replace(/[-:]/g, '')
+        .replace(/\./g, '')
+        .replace('T', '-')
+        .replace('Z', '');
+
+    return `${timestamp}-debug.log`;
+};
+
+const createTransports = (level: string) => {
+    const transports: winston.transport[] = [];
+
+    // When running as MCP server, NEVER add console transports as they interfere with the protocol
+    // All output must go through log capture mechanism instead
+    const isMcpServer = process.env.KILDE_MCP_SERVER === 'true';
+
+    if (!isMcpServer) {
+        // Always add console transport for info level and above (only when NOT in MCP mode)
+        if (level === 'info') {
+            transports.push(
+                new winston.transports.Console({
+                    format: winston.format.combine(
+                        winston.format.colorize(),
+                        winston.format.printf(({ level, message, dryRun }): string => {
+                            const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                            // For info level messages, don't show the level prefix
+                            if (level.includes('info')) {
+                                return `${dryRunPrefix}${String(message)}`;
+                            }
+                            // For warn, error, etc., show the level prefix
+                            return `${level}: ${dryRunPrefix}${String(message)}`;
+                        })
+                    )
+                })
+            );
+        } else {
+            // For debug/verbose levels, add console transport that shows info and above
+            transports.push(
+                new winston.transports.Console({
+                    level: 'info', // Show info, warn, and error on console
+                    format: winston.format.combine(
+                        winston.format.colorize(),
+                        winston.format.printf(({ timestamp, level, message, dryRun, ...meta }): string => {
+                            // For info level messages, use simpler format without timestamp
+                            if (level.includes('info')) {
+                                const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                                return `${dryRunPrefix}${String(message)}`;
+                            }
+
+                            // Filter out winston internal metadata
+                            const filteredMeta = Object.keys(meta).reduce((acc, key) => {
+                                if (!['level', 'message', 'timestamp', 'dryRun', 'service', 'splat', 'Symbol(level)', 'Symbol(message)'].includes(key)) {
+                                    acc[key] = meta[key];
+                                }
+                                return acc;
+                            }, {} as Record<string, any>);
+
+                            const metaStr = Object.keys(filteredMeta).length ? ` ${JSON.stringify(filteredMeta, null, 2)}` : '';
+                            const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+                            return `${timestamp} ${level}: ${dryRunPrefix}${String(message)}${metaStr}`;
+                        })
+                    )
+                })
+            );
+        }
+    }
+
+    // Add file transport for debug levels (debug and silly)
+    if (level === 'debug' || level === 'silly') {
+        ensureDebugDirectory();
+
+        const debugLogPath = path.join(DEFAULT_OUTPUT_DIRECTORY, 'debug', generateDebugLogFilename());
+
+        transports.push(
+            new winston.transports.File({
+                filename: debugLogPath,
+                level: 'debug', // Capture debug and above in the file
+                format: winston.format.combine(
+                    winston.format.timestamp({ format: DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS }),
+                    winston.format.errors({ stack: true }),
+                    winston.format.splat(),
+                    winston.format.printf(({ timestamp, level, message, service, ...meta }) => {
+                        // Filter out winston internal metadata and properly format remaining meta
+                        const filteredMeta = Object.keys(meta).reduce((acc, key) => {
+                            // Skip internal winston fields
+                            if (!['level', 'message', 'timestamp', 'splat', 'Symbol(level)', 'Symbol(message)'].includes(key)) {
+                                acc[key] = meta[key];
+                            }
+                            return acc;
+                        }, {} as Record<string, any>);
+
+                        const metaStr = Object.keys(filteredMeta).length
+                            ? ` ${JSON.stringify(filteredMeta, null, 2)}`
+                            : '';
+                        const serviceStr = service ? ` [${service}]` : '';
+                        return `${timestamp}${serviceStr} ${level}: ${message}${metaStr}`;
+                    })
+                )
+            })
+        );
+    }
+
+    return transports;
+};
+
+const createFormat = (level: string) => {
+    const baseFormats = [
+        winston.format.errors({ stack: true }),
+        winston.format.splat(),
+    ];
+
+    if (level === 'info') {
+        return winston.format.combine(
+            ...baseFormats,
+            winston.format.printf(({ message, dryRun, ..._meta }): string => {
+                // Auto-format dry-run messages
+                if (dryRun) {
+                    return `🔍 DRY RUN: ${message}`;
+                }
+                return String(message);
+            })
+        );
+    }
+
+    return winston.format.combine(
+        winston.format.timestamp({ format: DATE_FORMAT_YEAR_MONTH_DAY_HOURS_MINUTES_SECONDS }),
+        ...baseFormats,
+        winston.format.printf(({ timestamp, level, message, dryRun, ...meta }): string => {
+            // Filter out winston internal metadata
+            const filteredMeta = Object.keys(meta).reduce((acc, key) => {
+                if (!['level', 'message', 'timestamp', 'dryRun', 'service', 'splat', 'Symbol(level)', 'Symbol(message)'].includes(key)) {
+                    acc[key] = meta[key];
+                }
+                return acc;
+            }, {} as Record<string, any>);
+
+            const metaStr = Object.keys(filteredMeta).length ? ` ${JSON.stringify(filteredMeta, null, 2)}` : '';
+            const dryRunPrefix = dryRun ? '🔍 DRY RUN: ' : '';
+            return `${timestamp} ${level}: ${dryRunPrefix}${String(message)}${metaStr}`;
+        })
+    );
+};
+
+// Create the logger instance once
+const logger = winston.createLogger({
+    level: 'info',
+    format: createFormat('info'),
+    defaultMeta: { service: PROGRAM_NAME },
+    transports: createTransports('info'),
+});
+
+export const setLogLevel = (level: string) => {
+    // Reconfigure the existing logger instead of creating a new one
+    logger.configure({
+        level,
+        format: createFormat(level),
+        defaultMeta: { service: PROGRAM_NAME },
+        transports: createTransports(level),
+    });
+};
+
+export const getLogger = () => logger;
+
+/**
+ * Get a logger that automatically formats messages for dry-run mode
+ */
+export const getDryRunLogger = (isDryRun: boolean) => {
+    if (!isDryRun) {
+        return logger;
+    }
+
+    // Return a wrapper that adds dry-run context to all log calls
+    return {
+        info: (message: string, ...args: any[]) => logger.info(message, { dryRun: true }, ...args),
+        warn: (message: string, ...args: any[]) => logger.warn(message, { dryRun: true }, ...args),
+        error: (message: string, ...args: any[]) => logger.error(message, { dryRun: true }, ...args),
+        debug: (message: string, ...args: any[]) => logger.debug(message, { dryRun: true }, ...args),
+        verbose: (message: string, ...args: any[]) => logger.verbose(message, { dryRun: true }, ...args),
+        silly: (message: string, ...args: any[]) => logger.silly(message, { dryRun: true }, ...args),
+    };
+};

package/src/main.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { runApplication } from './application';
+import { getLogger } from './logging';
+
+/**
+ * Main entry point for Kilde
+ */
+async function main(): Promise<void> {
+    try {
+        await runApplication();
+    } catch (error: any) {
+        const logger = getLogger();
+        logger.error('MAIN_ERROR_EXIT: Exiting due to error | Error: %s | Stack: %s | Status: terminating', error.message, error.stack);
+        process.exit(1);
+    }
+}
+
+// Properly handle the main function with error handling and explicit process exit
+main().then(() => {
+    process.exit(0);
+}).catch((error) => {
+    const logger = getLogger();
+    logger.error('MAIN_UNHANDLED_ERROR: Unhandled error in main process | Error: %s | Type: unhandled', error.message || error);
+    process.exit(1);
+});

package/src/mcp/prompts/index.ts

@@ -0,0 +1,98 @@
+/**
+ * MCP Prompts for Kilde
+ *
+ * Provides workflow templates for common operations
+ */
+
+/**
+ * Get list of available prompts
+ */
+export function getPrompts() {
+    return [
+        {
+            name: 'commit-workflow',
+            description: 'Complete workflow for generating and creating a commit',
+            arguments: [
+                {
+                    name: 'context',
+                    description: 'Additional context for the commit message',
+                    required: false,
+                },
+            ],
+        },
+        {
+            name: 'release-workflow',
+            description: 'Complete workflow for generating release notes',
+            arguments: [
+                {
+                    name: 'version',
+                    description: 'Version number for the release',
+                    required: false,
+                },
+                {
+                    name: 'fromTag',
+                    description: 'Start tag for release notes',
+                    required: false,
+                },
+            ],
+        },
+    ];
+}
+
+/**
+ * Get a specific prompt by name
+ */
+export async function getPrompt(
+    name: string,
+    args?: Record<string, string>
+): Promise<{ description?: string; messages: Array<{ role: 'user' | 'assistant'; content: { type: 'text'; text: string } }> }> {
+    if (name === 'commit-workflow') {
+        const context = args?.context || '';
+        const contextPart = context ? `\n\nAdditional context: ${context}` : '';
+
+        return {
+            description: 'Workflow for generating AI-powered commit messages',
+            messages: [
+                {
+                    role: 'user' as const,
+                    content: {
+                        type: 'text' as const,
+                        text: `I need to create a commit. Please help me generate a good commit message based on my staged changes.${contextPart}
+
+Steps:
+1. First, use kilde_commit with cached=true and dryRun=true to preview the commit message
+2. Review the generated message
+3. If it looks good, use kilde_commit with sendit=true to create the commit
+4. If adjustments are needed, provide feedback and regenerate`
+                    }
+                }
+            ]
+        };
+    } else if (name === 'release-workflow') {
+        const version = args?.version || '';
+        const fromTag = args?.fromTag || '';
+        const versionPart = version ? `\n- version: "${version}"` : '';
+        const fromTagPart = fromTag ? `\n- fromTag: "${fromTag}"` : '';
+
+        return {
+            description: 'Workflow for generating release notes from git history',
+            messages: [
+                {
+                    role: 'user' as const,
+                    content: {
+                        type: 'text' as const,
+                        text: `I need to generate release notes for a new release.${versionPart}${fromTagPart}
+
+Steps:
+1. Use kilde_release with dryRun=true to preview the release notes
+2. Review the generated notes
+3. If they look good, use kilde_release with output="RELEASE_NOTES.md" to save them
+4. If adjustments are needed, use the focus parameter to guide the generation`
+                    }
+                }
+            ]
+        };
+    } else {
+        throw new Error(`Unknown prompt: ${name}`);
+    }
+}

package/src/mcp/resources.ts

@@ -0,0 +1,121 @@
+/**
+ * MCP Resources for Kilde
+ *
+ * Provides access to configuration and status information
+ */
+
+import { createStorage } from '@grunnverk/shared';
+import { getEffectiveConfig } from '../utils/config';
+import { execSync } from 'child_process';
+
+/**
+ * Get list of available resources
+ */
+export function getResources() {
+    return [
+        {
+            uri: 'kilde://config',
+            name: 'Current configuration',
+            description: 'Current kilde configuration (merged from defaults, config file, and CLI args)',
+            mimeType: 'application/json',
+        },
+        {
+            uri: 'kilde://status',
+            name: 'Git repository status',
+            description: 'Current git repository status and branch information',
+            mimeType: 'text/plain',
+        },
+        {
+            uri: 'kilde://workspace',
+            name: 'Workspace information',
+            description: 'Information about the current workspace (working directory, files, etc.)',
+            mimeType: 'application/json',
+        },
+    ];
+}
+
+/**
+ * Read a resource by URI
+ */
+export async function readResource(uri: string): Promise<{ contents: Array<{ uri: string; mimeType?: string; text: string }> }> {
+    const storage = createStorage();
+
+    if (uri === 'kilde://config') {
+        // Return current configuration
+        const config = await getEffectiveConfig();
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(config, null, 2),
+                },
+            ],
+        };
+    } else if (uri === 'kilde://status') {
+        // Return git status
+        try {
+            const status = execSync('git status', { encoding: 'utf-8', cwd: process.cwd() });
+            const branch = execSync('git branch --show-current', { encoding: 'utf-8', cwd: process.cwd() }).trim();
+            const lastCommit = execSync('git log -1 --oneline', { encoding: 'utf-8', cwd: process.cwd() }).trim();
+
+            const statusText = `Current Branch: ${branch}\nLast Commit: ${lastCommit}\n\n${status}`;
+
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'text/plain',
+                        text: statusText,
+                    },
+                ],
+            };
+        } catch (error: any) {
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'text/plain',
+                        text: `Error reading git status: ${error.message}`,
+                    },
+                ],
+            };
+        }
+    } else if (uri === 'kilde://workspace') {
+        // Return workspace information
+        try {
+            const workingDir = process.cwd();
+            const isGitRepo = execSync('git rev-parse --is-inside-work-tree', { encoding: 'utf-8', cwd: workingDir }).trim() === 'true';
+            const gitRoot = isGitRepo ? execSync('git rev-parse --show-toplevel', { encoding: 'utf-8', cwd: workingDir }).trim() : null;
+
+            const workspace = {
+                workingDirectory: workingDir,
+                isGitRepository: isGitRepo,
+                gitRoot: gitRoot,
+                configExists: await storage.exists('.kilde/config.yaml') || await storage.exists('.kilderc.yaml'),
+            };
+
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify(workspace, null, 2),
+                    },
+                ],
+            };
+        } catch (error: any) {
+            return {
+                contents: [
+                    {
+                        uri,
+                        mimeType: 'application/json',
+                        text: JSON.stringify({ error: error.message }, null, 2),
+                    },
+                ],
+            };
+        }
+    } else {
+        throw new Error(`Unknown resource URI: ${uri}`);
+    }
+}