@eldrforge/ai-service 0.1.1 → 0.1.3

package/src/prompts/personas/you.md

@@ -1,55 +0,0 @@
-# You
-
-You are an intelligent assistant acting as the **default persona** for most KodrDriv commands (commit, review, audio-commit, audio-review).  You combine the responsibilities of a GitHub project committer and a software project reviewer.
-
----
-
-## 🧑‍💻 Role
-
-*Role Title*: Project Contributor / Committer & Reviewer  
-*Scope*: Regular contributor with write access who submits meaningful commits **and** reviews feedback to file actionable issues.
-
----
-
-## 🔑 Responsibilities
-
-### Submit Meaningful Commits
-* Generate clear, purposeful, and well-scoped commit messages that align with project standards.
-* Respect linked issues, project priorities, and any provided *User Context*.
-
-### Extract & File Actionable Issues
-* Analyse review notes (text or audio transcripts).
-* Convert spoken or written observations into structured GitHub issues.
-* Categorise issues (UI, content, functionality, etc.) and assign sensible priority.
-
-### Maintain Focus & Quality
-* Filter out non-actionable commentary and subjective opinions.
-* Provide concrete suggestions that developers can implement.
-* Treat documentation changes with the same diligence as code edits.
-
----
-
-## 🛠 Technical Proficiencies
-
-* Proficient in project languages & tooling (TypeScript, Node.js, etc.).
-* Comfortable with Git workflows: feature branching, squash-and-merge, rebase.
-* Runs pre-commit hooks, linting, and tests before pushing changes.
-
----
-
-## 🧭 Operating Principles
-
-* **Clarity > Brevity > Cleverness** – commit messages and issues are communication tools.
-* Consider the future reader: teammates, open-source collaborators, or even your future self.
-* Focus on user experience and practical functionality when filing issues.
-
----
-
-## ✏️ Customisation
-
-Users can customise this persona by creating either of the following optional files in their configuration directory (`.kodrdriv/personas/`):
-
-* **`you-pre.md`** – Content that will be *prepended* to this default persona.
-* **`you-post.md`** – Content that will be *appended* to this default persona.
-
-If present, KodrDriv will automatically merge these custom snippets, allowing you to fine-tune the behaviour of the default persona without editing this file directly.

package/src/prompts/release.ts

@@ -1,118 +0,0 @@
-import { ContentItem, Prompt, recipe } from '@riotprompt/riotprompt';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// Types for the release prompt
-export type ReleaseConfig = {
-    overridePaths?: string[];
-    overrides?: boolean;
-}
-
-export type ReleaseContent = {
-    releaseFocus?: string;
-    logContent: string;
-    diffContent: string;
-    milestoneIssues?: string;
-};
-
-export type ReleaseContext = {
-    context?: string;
-    directories?: string[];
-};
-
-export type ReleasePromptResult = {
-    prompt: Prompt;
-    maxTokens: number;
-    isLargeRelease: boolean;
-};
-
-/**
- * Analyzes release content to determine if it's a large release
- * and calculates appropriate token limits
- */
-const analyzeReleaseSize = (logContent: string, diffContent?: string, milestoneIssues?: string): { isLarge: boolean; maxTokens: number } => {
-    const logLines = logContent.split('\n').length;
-    const diffLines = diffContent ? diffContent.split('\n').length : 0;
-    const milestoneLines = milestoneIssues ? milestoneIssues.split('\n').length : 0;
-    const totalContentLength = logContent.length + (diffContent?.length || 0) + (milestoneIssues?.length || 0);
-
-    // Consider it a large release if:
-    // - More than 20 commits (log lines typically ~3-5 per commit)
-    // - More than 500 diff lines
-    // - Milestone issues present (indicates significant work)
-    // - Total content length > 50KB
-    const isLarge = logLines > 60 || diffLines > 500 || milestoneLines > 50 || totalContentLength > 50000;
-
-    if (isLarge) {
-        // For large releases, significantly increase token limit
-        return { isLarge: true, maxTokens: 25000 };
-    } else {
-        // Standard token limit for normal releases
-        return { isLarge: false, maxTokens: 10000 };
-    }
-};
-
-/**
- * Build a release prompt using RiotPrompt Recipes.
- */
-export const createReleasePrompt = async (
-    { overrides: _overrides, overridePaths: _overridePaths }: ReleaseConfig,
-    { releaseFocus, logContent, diffContent, milestoneIssues }: ReleaseContent,
-    { context, directories }: ReleaseContext = {}
-): Promise<ReleasePromptResult> => {
-    const basePath = __dirname;
-
-    // Analyze release size to determine token requirements
-    const { isLarge: isLargeRelease, maxTokens } = analyzeReleaseSize(logContent, diffContent, milestoneIssues);
-
-    // Build content items for the prompt
-    const contentItems: ContentItem[] = [];
-    const contextItems: ContentItem[] = [];
-
-    if (diffContent) {
-        contentItems.push({ content: diffContent, title: 'Diff' });
-    }
-    if (logContent) {
-        contentItems.push({ content: logContent, title: 'Log Context' });
-    }
-    if (milestoneIssues) {
-        contentItems.push({ content: milestoneIssues, title: 'Resolved Issues from Milestone' });
-    }
-    if (releaseFocus) {
-        contentItems.push({ content: releaseFocus, title: 'Release Focus' });
-    }
-
-    // Add release size context to help guide the AI
-    if (isLargeRelease) {
-        contextItems.push({
-            content: `This appears to be a LARGE RELEASE with significant changes. Please provide comprehensive, detailed release notes that thoroughly document all major changes, improvements, and fixes. Don't summarize - dive deep into the details.`,
-            title: 'Release Size Context'
-        });
-    }
-
-    if (context) {
-        contextItems.push({ content: context, title: 'User Context' });
-    }
-    if (directories && directories.length > 0) {
-        contextItems.push({ directories, title: 'Directories' });
-    }
-
-    const prompt = await recipe(basePath)
-        .persona({ path: 'personas/releaser.md' })
-        .instructions({ path: 'instructions/release.md' })
-        .overridePaths(_overridePaths ?? [])
-        .overrides(_overrides ?? true)
-        .content(...contentItems)
-        .context(...contextItems)
-        .cook();
-
-    return {
-        prompt,
-        maxTokens,
-        isLargeRelease
-    };
-};
-

package/src/prompts/review.ts

@@ -1,72 +0,0 @@
-import { ContentItem, Prompt, recipe } from '@riotprompt/riotprompt';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-export type ReviewConfig = {
-    overridePaths?: string[];
-    overrides?: boolean;
-}
-
-export type ReviewContent = {
-    notes: string;
-};
-
-export type ReviewContext = {
-    logContext?: string;
-    diffContext?: string;
-    releaseNotesContext?: string;
-    issuesContext?: string;
-    context?: string;
-    directories?: string[];
-};
-
-/**
- * Build a review prompt using RiotPrompt Recipes.
- */
-export const createReviewPrompt = async (
-    { overridePaths: _overridePaths, overrides: _overrides }: ReviewConfig,
-    { notes }: ReviewContent,
-    { logContext, diffContext, releaseNotesContext, issuesContext, context, directories }: ReviewContext = {}
-): Promise<Prompt> => {
-    const basePath = __dirname;
-
-    // Build content items for the prompt
-    const contentItems: ContentItem[] = [];
-    const contextItems: ContentItem[] = [];
-
-    if (notes) {
-        contentItems.push({ content: notes, title: 'Review Notes' });
-    }
-
-    if (logContext) {
-        contextItems.push({ content: logContext, title: 'Log Context' });
-    }
-    if (diffContext) {
-        contextItems.push({ content: diffContext, title: 'Diff Context' });
-    }
-    if (releaseNotesContext) {
-        contextItems.push({ content: releaseNotesContext, title: 'Release Notes Context' });
-    }
-    if (issuesContext) {
-        contextItems.push({ content: issuesContext, title: 'Issues Context' });
-    }
-    if (context) {
-        contextItems.push({ content: context, title: 'User Context' });
-    }
-    if (directories && directories.length > 0) {
-        contextItems.push({ directories, title: 'Directories' });
-    }
-
-    return recipe(basePath)
-        .persona({ path: 'personas/you.md' })
-        .instructions({ path: 'instructions/review.md' })
-        .overridePaths(_overridePaths ?? [])
-        .overrides(_overrides ?? true)
-        .content(...contentItems)
-        .context(...contextItems)
-        .cook();
-};
-

package/src/types.ts

@@ -1,112 +0,0 @@
-/**
- * Type definitions for AI service
- */
-
-/**
- * AI model reasoning effort levels
- */
-export type ReasoningLevel = 'low' | 'medium' | 'high';
-
-/**
- * Configuration for AI operations
- */
-export interface AIConfig {
-  /** OpenAI API key */
-  apiKey?: string;
-
-  /** Model to use (e.g., 'gpt-4o-mini', 'gpt-4o') */
-  model?: string;
-
-  /** Reasoning effort level */
-  reasoning?: ReasoningLevel;
-
-  /** Command-specific configurations */
-  commands?: {
-    commit?: {
-      model?: string;
-      reasoning?: ReasoningLevel;
-    };
-    release?: {
-      model?: string;
-      reasoning?: ReasoningLevel;
-    };
-    review?: {
-      model?: string;
-      reasoning?: ReasoningLevel;
-    };
-  };
-}
-
-/**
- * Result from AI transcription
- */
-export interface Transcription {
-  text: string;
-}
-
-/**
- * Storage interface for file operations
- * Consumers can provide their own implementation
- */
-export interface StorageAdapter {
-  writeOutput(fileName: string, content: string): Promise<void>;
-  readTemp(fileName: string): Promise<string>;
-  writeTemp(fileName: string, content: string): Promise<void>;
-}
-
-/**
- * Logger interface for optional logging
- * Compatible with winston but not required
- */
-export interface Logger {
-  info(message: string, ...meta: unknown[]): void;
-  error(message: string, ...meta: unknown[]): void;
-  warn(message: string, ...meta: unknown[]): void;
-  debug(message: string, ...meta: unknown[]): void;
-}
-
-/**
- * Choice for interactive prompts
- */
-export interface Choice {
-  key: string;
-  label: string;
-}
-
-/**
- * Options for interactive prompts
- */
-export interface InteractiveOptions {
-  nonTtyErrorSuggestions?: string[];
-  logger?: Logger;
-}
-
-/**
- * Options for editor integration
- */
-export interface EditorOptions {
-  editor?: string;
-  tempDir?: string;
-  extension?: string;
-  logger?: Logger;
-}
-
-/**
- * Options for LLM feedback loop
- */
-export interface FeedbackOptions {
-  initialContent: string;
-  systemMessage: string;
-  aiConfig: AIConfig;
-  commandName: string;
-  storage?: StorageAdapter;
-  outputPrefix?: string;
-  editor?: EditorOptions;
-  logger?: Logger;
-}
-
-/**
- * Re-export Prompt type from riotprompt for convenience
- */
-export type { Prompt, ContentItem } from '@riotprompt/riotprompt';
-

package/tests/ai-complete-coverage.test.ts

@@ -1,241 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { createCompletion, transcribeAudio } from '../src/ai';
-import type { StorageAdapter } from '../src/types';
-
-// Mock OpenAI
-const mockChatCreate = vi.fn();
-const mockTranscriptionsCreate = vi.fn();
-
-vi.mock('openai', () => ({
-    OpenAI: vi.fn().mockImplementation(() => ({
-        chat: {
-            completions: {
-                create: mockChatCreate,
-            },
-        },
-        audio: {
-            transcriptions: {
-                create: mockTranscriptionsCreate,
-            },
-        },
-    })),
-}));
-
-// Mock logger
-const mockLoggerInstance = {
-    info: vi.fn(),
-    error: vi.fn(),
-    warn: vi.fn(),
-    debug: vi.fn(),
-};
-
-vi.mock('../src/logger', () => ({
-    getLogger: vi.fn(() => mockLoggerInstance),
-}));
-
-// Mock fs
-const mockReadStreamDestroy = vi.fn();
-const mockReadStreamOn = vi.fn((event: string, callback: any) => {
-    // Store callbacks but don't call them
-    return {};
-});
-
-vi.mock('fs', () => ({
-    default: {
-        createReadStream: vi.fn(() => ({
-            destroy: mockReadStreamDestroy,
-            destroyed: false,
-            on: mockReadStreamOn,
-        })),
-    },
-    createReadStream: vi.fn(() => ({
-        destroy: mockReadStreamDestroy,
-        destroyed: false,
-        on: mockReadStreamOn,
-    })),
-}));
-
-// Mock safeJsonParse
-vi.mock('@eldrforge/git-tools', () => ({
-    safeJsonParse: vi.fn((json: string) => JSON.parse(json)),
-}));
-
-describe('Complete Coverage Tests', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        process.env.OPENAI_API_KEY = 'test-key';
-        mockReadStreamDestroy.mockClear();
-        mockReadStreamOn.mockClear();
-    });
-
-    describe('createCompletion - Complete Branch Coverage', () => {
-        it('should log response size without token usage', async () => {
-            mockChatCreate.mockResolvedValue({
-                choices: [{ message: { content: 'Response without usage' } }],
-                // No usage field
-            });
-
-            await createCompletion([{ role: 'user', content: 'test' }]);
-
-            // Should log response size even without usage
-            expect(mockLoggerInstance.info).toHaveBeenCalledWith(
-                expect.stringContaining('Response size'),
-                expect.any(String),
-                expect.any(String)
-            );
-        });
-
-        it('should handle reasoning_effort for o3 models', async () => {
-            mockChatCreate.mockResolvedValue({
-                choices: [{ message: { content: 'Response' } }],
-                usage: {},
-            });
-
-            await createCompletion(
-                [{ role: 'user', content: 'test' }],
-                { model: 'o3-mini', openaiReasoning: 'high' }
-            );
-
-            expect(mockChatCreate).toHaveBeenCalledWith(
-                expect.objectContaining({ reasoning_effort: 'high' })
-            );
-        });
-
-        it('should not add reasoning_effort for non-supported models', async () => {
-            mockChatCreate.mockResolvedValue({
-                choices: [{ message: { content: 'Response' } }],
-                usage: {},
-            });
-
-            await createCompletion(
-                [{ role: 'user', content: 'test' }],
-                { model: 'gpt-4o-mini', openaiReasoning: 'high' }
-            );
-
-            const callArgs = mockChatCreate.mock.calls[0][0];
-            expect(callArgs.reasoning_effort).toBeUndefined();
-        });
-
-        it('should handle debug without storage', async () => {
-            mockChatCreate.mockResolvedValue({
-                choices: [{ message: { content: 'Response' } }],
-                usage: {},
-            });
-
-            // Debug enabled but no storage - should not throw
-            await createCompletion(
-                [{ role: 'user', content: 'test' }],
-                {
-                    debug: true,
-                    debugFile: 'debug.json',
-                    // No storage provided
-                }
-            );
-
-            expect(mockChatCreate).toHaveBeenCalled();
-        });
-    });
-
-    describe('transcribeAudio - Complete Branch Coverage', () => {
-        it('should handle stream error event', async () => {
-            let errorCallback: any;
-            mockReadStreamOn.mockImplementation((event: string, callback: any) => {
-                if (event === 'error') {
-                    errorCallback = callback;
-                }
-                return {};
-            });
-
-            mockTranscriptionsCreate.mockImplementation(async () => {
-                // Trigger stream error before API call completes
-                if (errorCallback) {
-                    errorCallback(new Error('Stream error'));
-                }
-                return { text: 'Transcribed' };
-            });
-
-            const result = await transcribeAudio('/path/audio.mp3');
-
-            expect(result.text).toBe('Transcribed');
-            expect(mockLoggerInstance.error).toHaveBeenCalledWith(
-                expect.stringContaining('Audio stream error'),
-                expect.any(String)
-            );
-        });
-
-        it('should log debug for stream closure', async () => {
-            mockTranscriptionsCreate.mockResolvedValue({
-                text: 'Transcribed',
-            });
-
-            await transcribeAudio('/path/audio.mp3');
-
-            expect(mockLoggerInstance.debug).toHaveBeenCalledWith(
-                expect.stringContaining('Audio stream closed successfully')
-            );
-        });
-
-        it('should handle destroy failure on stream', async () => {
-            mockReadStreamDestroy.mockImplementation(() => {
-                throw new Error('Cannot destroy stream');
-            });
-
-            mockTranscriptionsCreate.mockResolvedValue({
-                text: 'Transcribed',
-            });
-
-            // Should not throw
-            const result = await transcribeAudio('/path/audio.mp3');
-
-            expect(result.text).toBe('Transcribed');
-            expect(mockLoggerInstance.debug).toHaveBeenCalled();
-        });
-
-        it('should write debug request file when storage provided', async () => {
-            const mockStorage: StorageAdapter = {
-                writeOutput: vi.fn(),
-                readTemp: vi.fn(),
-                writeTemp: vi.fn().mockResolvedValue(undefined),
-            };
-
-            mockTranscriptionsCreate.mockResolvedValue({
-                text: 'Transcribed',
-            });
-
-            await transcribeAudio('/path/audio.mp3', {
-                debug: true,
-                debugRequestFile: 'transcribe-request.json',
-                storage: mockStorage,
-            });
-
-            expect(mockStorage.writeTemp).toHaveBeenCalledWith(
-                'transcribe-request.json',
-                expect.stringContaining('whisper-1')
-            );
-        });
-
-        it('should write debug response file when storage provided', async () => {
-            const mockStorage: StorageAdapter = {
-                writeOutput: vi.fn(),
-                readTemp: vi.fn(),
-                writeTemp: vi.fn().mockResolvedValue(undefined),
-            };
-
-            mockTranscriptionsCreate.mockResolvedValue({
-                text: 'Transcribed text',
-            });
-
-            await transcribeAudio('/path/audio.mp3', {
-                debug: true,
-                debugResponseFile: 'transcribe-response.json',
-                storage: mockStorage,
-            });
-
-            expect(mockStorage.writeTemp).toHaveBeenCalledWith(
-                'transcribe-response.json',
-                expect.stringContaining('Transcribed text')
-            );
-        });
-    });
-});
-