codeep 1.0.0

package/dist/utils/diffPreview.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Diff Preview - show changes before applying them
+ */
+export interface FileDiff {
+    path: string;
+    type: 'create' | 'modify' | 'delete';
+    oldContent?: string;
+    newContent?: string;
+    hunks: DiffHunk[];
+}
+export interface DiffHunk {
+    oldStart: number;
+    oldLines: number;
+    newStart: number;
+    newLines: number;
+    lines: DiffLine[];
+}
+export interface DiffLine {
+    type: 'context' | 'add' | 'remove';
+    content: string;
+    oldLineNum?: number;
+    newLineNum?: number;
+}
+export interface DiffPreviewResult {
+    files: FileDiff[];
+    totalAdditions: number;
+    totalDeletions: number;
+    totalFiles: number;
+}
+/**
+ * Generate diff between old and new content
+ */
+export declare function generateDiff(oldContent: string, newContent: string, contextLines?: number): DiffHunk[];
+/**
+ * Create file diff for a write operation
+ */
+export declare function createFileDiff(path: string, newContent: string, projectRoot: string): FileDiff;
+/**
+ * Create file diff for an edit operation
+ */
+export declare function createEditDiff(path: string, oldText: string, newText: string, projectRoot: string): FileDiff | null;
+/**
+ * Create file diff for a delete operation
+ */
+export declare function createDeleteDiff(path: string, projectRoot: string): FileDiff | null;
+/**
+ * Format diff for terminal display
+ */
+export declare function formatDiffForDisplay(diff: FileDiff): string;
+/**
+ * Format multiple diffs
+ */
+export declare function formatDiffPreview(diffs: FileDiff[]): string;
+/**
+ * Calculate diff statistics
+ */
+export declare function getDiffStats(diffs: FileDiff[]): DiffPreviewResult;

package/dist/utils/diffPreview.js

@@ -0,0 +1,335 @@
+/**
+ * Diff Preview - show changes before applying them
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+/**
+ * Generate diff between old and new content
+ */
+export function generateDiff(oldContent, newContent, contextLines = 3) {
+    const oldLines = oldContent.split('\n');
+    const newLines = newContent.split('\n');
+    const hunks = [];
+    // Simple diff algorithm (Myers-like)
+    const lcs = longestCommonSubsequence(oldLines, newLines);
+    let oldIdx = 0;
+    let newIdx = 0;
+    let currentHunk = null;
+    let pendingContext = [];
+    for (const [oldMatch, newMatch] of lcs) {
+        // Handle deletions
+        while (oldIdx < oldMatch) {
+            if (!currentHunk) {
+                currentHunk = createHunk(oldIdx, newIdx);
+                // Add leading context
+                for (let i = Math.max(0, oldIdx - contextLines); i < oldIdx; i++) {
+                    currentHunk.lines.push({
+                        type: 'context',
+                        content: oldLines[i],
+                        oldLineNum: i + 1,
+                        newLineNum: newIdx - (oldIdx - i) + 1,
+                    });
+                }
+            }
+            currentHunk.lines.push({
+                type: 'remove',
+                content: oldLines[oldIdx],
+                oldLineNum: oldIdx + 1,
+            });
+            oldIdx++;
+        }
+        // Handle additions
+        while (newIdx < newMatch) {
+            if (!currentHunk) {
+                currentHunk = createHunk(oldIdx, newIdx);
+                // Add leading context
+                for (let i = Math.max(0, oldIdx - contextLines); i < oldIdx; i++) {
+                    currentHunk.lines.push({
+                        type: 'context',
+                        content: oldLines[i],
+                        oldLineNum: i + 1,
+                        newLineNum: newIdx - (oldIdx - i) + 1,
+                    });
+                }
+            }
+            currentHunk.lines.push({
+                type: 'add',
+                content: newLines[newIdx],
+                newLineNum: newIdx + 1,
+            });
+            newIdx++;
+        }
+        // Handle match
+        if (oldIdx < oldLines.length && newIdx < newLines.length) {
+            if (currentHunk) {
+                // Add trailing context
+                for (let i = 0; i < contextLines && oldIdx + i < oldLines.length; i++) {
+                    currentHunk.lines.push({
+                        type: 'context',
+                        content: oldLines[oldIdx + i],
+                        oldLineNum: oldIdx + i + 1,
+                        newLineNum: newIdx + i + 1,
+                    });
+                }
+                // Finalize hunk
+                finalizeHunk(currentHunk);
+                hunks.push(currentHunk);
+                currentHunk = null;
+            }
+            oldIdx++;
+            newIdx++;
+        }
+    }
+    // Handle remaining deletions
+    while (oldIdx < oldLines.length) {
+        if (!currentHunk) {
+            currentHunk = createHunk(oldIdx, newIdx);
+        }
+        currentHunk.lines.push({
+            type: 'remove',
+            content: oldLines[oldIdx],
+            oldLineNum: oldIdx + 1,
+        });
+        oldIdx++;
+    }
+    // Handle remaining additions
+    while (newIdx < newLines.length) {
+        if (!currentHunk) {
+            currentHunk = createHunk(oldIdx, newIdx);
+        }
+        currentHunk.lines.push({
+            type: 'add',
+            content: newLines[newIdx],
+            newLineNum: newIdx + 1,
+        });
+        newIdx++;
+    }
+    // Finalize last hunk
+    if (currentHunk) {
+        finalizeHunk(currentHunk);
+        hunks.push(currentHunk);
+    }
+    return hunks;
+}
+/**
+ * Create a new hunk
+ */
+function createHunk(oldStart, newStart) {
+    return {
+        oldStart: oldStart + 1,
+        oldLines: 0,
+        newStart: newStart + 1,
+        newLines: 0,
+        lines: [],
+    };
+}
+/**
+ * Finalize hunk by counting lines
+ */
+function finalizeHunk(hunk) {
+    hunk.oldLines = hunk.lines.filter(l => l.type !== 'add').length;
+    hunk.newLines = hunk.lines.filter(l => l.type !== 'remove').length;
+}
+/**
+ * Simple LCS algorithm for diff
+ */
+function longestCommonSubsequence(old, newArr) {
+    const result = [];
+    let oldIdx = 0;
+    let newIdx = 0;
+    while (oldIdx < old.length && newIdx < newArr.length) {
+        if (old[oldIdx] === newArr[newIdx]) {
+            result.push([oldIdx, newIdx]);
+            oldIdx++;
+            newIdx++;
+        }
+        else {
+            // Try to find match
+            let foundOld = -1;
+            let foundNew = -1;
+            // Look ahead in new array
+            for (let i = newIdx + 1; i < Math.min(newIdx + 10, newArr.length); i++) {
+                if (old[oldIdx] === newArr[i]) {
+                    foundNew = i;
+                    break;
+                }
+            }
+            // Look ahead in old array
+            for (let i = oldIdx + 1; i < Math.min(oldIdx + 10, old.length); i++) {
+                if (old[i] === newArr[newIdx]) {
+                    foundOld = i;
+                    break;
+                }
+            }
+            if (foundNew !== -1 && (foundOld === -1 || foundNew - newIdx < foundOld - oldIdx)) {
+                newIdx = foundNew;
+            }
+            else if (foundOld !== -1) {
+                oldIdx = foundOld;
+            }
+            else {
+                oldIdx++;
+                newIdx++;
+            }
+        }
+    }
+    // Add end markers
+    result.push([old.length, newArr.length]);
+    return result;
+}
+/**
+ * Create file diff for a write operation
+ */
+export function createFileDiff(path, newContent, projectRoot) {
+    const fullPath = join(projectRoot, path);
+    const exists = existsSync(fullPath);
+    let oldContent = '';
+    let type = 'create';
+    if (exists) {
+        try {
+            oldContent = readFileSync(fullPath, 'utf-8');
+            type = 'modify';
+        }
+        catch { }
+    }
+    const hunks = generateDiff(oldContent, newContent);
+    return {
+        path,
+        type,
+        oldContent: exists ? oldContent : undefined,
+        newContent,
+        hunks,
+    };
+}
+/**
+ * Create file diff for an edit operation
+ */
+export function createEditDiff(path, oldText, newText, projectRoot) {
+    const fullPath = join(projectRoot, path);
+    if (!existsSync(fullPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(fullPath, 'utf-8');
+        if (!content.includes(oldText)) {
+            return null;
+        }
+        const newContent = content.replace(oldText, newText);
+        const hunks = generateDiff(content, newContent);
+        return {
+            path,
+            type: 'modify',
+            oldContent: content,
+            newContent,
+            hunks,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create file diff for a delete operation
+ */
+export function createDeleteDiff(path, projectRoot) {
+    const fullPath = join(projectRoot, path);
+    if (!existsSync(fullPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(fullPath, 'utf-8');
+        const hunks = generateDiff(content, '');
+        return {
+            path,
+            type: 'delete',
+            oldContent: content,
+            hunks,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Format diff for terminal display
+ */
+export function formatDiffForDisplay(diff) {
+    const lines = [];
+    // Header
+    if (diff.type === 'create') {
+        lines.push(`+++ NEW FILE: ${diff.path}`);
+    }
+    else if (diff.type === 'delete') {
+        lines.push(`--- DELETE FILE: ${diff.path}`);
+    }
+    else {
+        lines.push(`--- a/${diff.path}`);
+        lines.push(`+++ b/${diff.path}`);
+    }
+    // Hunks
+    for (const hunk of diff.hunks) {
+        lines.push(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`);
+        for (const line of hunk.lines) {
+            if (line.type === 'add') {
+                lines.push(`+ ${line.content}`);
+            }
+            else if (line.type === 'remove') {
+                lines.push(`- ${line.content}`);
+            }
+            else {
+                lines.push(`  ${line.content}`);
+            }
+        }
+    }
+    return lines.join('\n');
+}
+/**
+ * Format multiple diffs
+ */
+export function formatDiffPreview(diffs) {
+    const lines = ['## Diff Preview', ''];
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    for (const diff of diffs) {
+        for (const hunk of diff.hunks) {
+            for (const line of hunk.lines) {
+                if (line.type === 'add')
+                    totalAdditions++;
+                if (line.type === 'remove')
+                    totalDeletions++;
+            }
+        }
+    }
+    lines.push(`Files: ${diffs.length} | +${totalAdditions} -${totalDeletions}`);
+    lines.push('');
+    for (const diff of diffs) {
+        lines.push('```diff');
+        lines.push(formatDiffForDisplay(diff));
+        lines.push('```');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+/**
+ * Calculate diff statistics
+ */
+export function getDiffStats(diffs) {
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    for (const diff of diffs) {
+        for (const hunk of diff.hunks) {
+            for (const line of hunk.lines) {
+                if (line.type === 'add')
+                    totalAdditions++;
+                if (line.type === 'remove')
+                    totalDeletions++;
+            }
+        }
+    }
+    return {
+        files: diffs,
+        totalAdditions,
+        totalDeletions,
+        totalFiles: diffs.length,
+    };
+}

package/dist/utils/export.d.ts

@@ -0,0 +1,19 @@
+import { Message } from '../config';
+export type ExportFormat = 'md' | 'json' | 'txt';
+export interface ExportOptions {
+    format: ExportFormat;
+    sessionName?: string;
+    timestamp?: string;
+}
+/**
+ * Export messages to specified format
+ */
+export declare function exportMessages(messages: Message[], options: ExportOptions): string;
+/**
+ * Save exported content to file
+ */
+export declare function saveExport(content: string, format: ExportFormat, outputPath: string, sessionName?: string): {
+    success: boolean;
+    filePath: string;
+    error?: string;
+};

package/dist/utils/export.js

@@ -0,0 +1,94 @@
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+/**
+ * Export messages to Markdown format
+ */
+function exportToMarkdown(messages, sessionName) {
+    const timestamp = new Date().toLocaleString('hr-HR');
+    let markdown = `# Codeep Chat Export\n\n`;
+    if (sessionName) {
+        markdown += `**Session:** ${sessionName}\n`;
+    }
+    markdown += `**Exported:** ${timestamp}\n\n`;
+    markdown += `---\n\n`;
+    messages.forEach((message, index) => {
+        const role = message.role === 'user' ? '👤 User' : '🤖 Assistant';
+        markdown += `## ${role}\n\n`;
+        markdown += `${message.content}\n\n`;
+        if (index < messages.length - 1) {
+            markdown += `---\n\n`;
+        }
+    });
+    return markdown;
+}
+/**
+ * Export messages to JSON format
+ */
+function exportToJson(messages, sessionName) {
+    const exportData = {
+        session: sessionName || 'Unnamed',
+        exportedAt: new Date().toISOString(),
+        messageCount: messages.length,
+        messages: messages,
+    };
+    return JSON.stringify(exportData, null, 2);
+}
+/**
+ * Export messages to plain text format
+ */
+function exportToText(messages, sessionName) {
+    const timestamp = new Date().toLocaleString('hr-HR');
+    let text = `Codeep Chat Export\n`;
+    text += `===================\n\n`;
+    if (sessionName) {
+        text += `Session: ${sessionName}\n`;
+    }
+    text += `Exported: ${timestamp}\n`;
+    text += `Messages: ${messages.length}\n\n`;
+    text += `===================\n\n`;
+    messages.forEach((message, index) => {
+        const role = message.role === 'user' ? 'USER' : 'ASSISTANT';
+        text += `[${role}]\n`;
+        text += `${message.content}\n\n`;
+        if (index < messages.length - 1) {
+            text += `---\n\n`;
+        }
+    });
+    return text;
+}
+/**
+ * Export messages to specified format
+ */
+export function exportMessages(messages, options) {
+    switch (options.format) {
+        case 'md':
+            return exportToMarkdown(messages, options.sessionName);
+        case 'json':
+            return exportToJson(messages, options.sessionName);
+        case 'txt':
+            return exportToText(messages, options.sessionName);
+        default:
+            throw new Error(`Unknown export format: ${options.format}`);
+    }
+}
+/**
+ * Save exported content to file
+ */
+export function saveExport(content, format, outputPath, sessionName) {
+    try {
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+        const fileName = sessionName
+            ? `${sessionName}-${timestamp}.${format}`
+            : `chat-export-${timestamp}.${format}`;
+        const filePath = join(outputPath, fileName);
+        writeFileSync(filePath, content, 'utf-8');
+        return { success: true, filePath };
+    }
+    catch (error) {
+        return {
+            success: false,
+            filePath: '',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        };
+    }
+}

package/dist/utils/git.d.ts

@@ -0,0 +1,85 @@
+import { ActionLog } from './tools';
+export interface GitStatus {
+    isRepo: boolean;
+    branch?: string;
+    hasChanges?: boolean;
+    ahead?: number;
+    behind?: number;
+}
+export interface GitDiffResult {
+    success: boolean;
+    diff: string;
+    error?: string;
+}
+export interface GitCommitResult {
+    success: boolean;
+    hash?: string;
+    error?: string;
+}
+/**
+ * Check if current directory is a git repository
+ */
+export declare function isGitRepository(cwd?: string): boolean;
+/**
+ * Get current git status
+ */
+export declare function getGitStatus(cwd?: string): GitStatus;
+/**
+ * Get git diff (staged or unstaged)
+ */
+export declare function getGitDiff(staged?: boolean, cwd?: string): GitDiffResult;
+/**
+ * Get list of changed files
+ */
+export declare function getChangedFiles(cwd?: string): string[];
+/**
+ * Generate commit message suggestion based on diff
+ */
+export declare function suggestCommitMessage(diff: string): string;
+/**
+ * Create a commit with the given message
+ */
+export declare function createCommit(message: string, cwd?: string): GitCommitResult;
+/**
+ * Stage all changes
+ */
+export declare function stageAll(cwd?: string): boolean;
+/**
+ * Format git diff for display
+ */
+export declare function formatDiffForDisplay(diff: string, maxLines?: number): string;
+/**
+ * Create a new branch
+ */
+export declare function createBranch(branchName: string, cwd?: string): {
+    success: boolean;
+    error?: string;
+};
+/**
+ * Switch to a branch
+ */
+export declare function switchBranch(branchName: string, cwd?: string): {
+    success: boolean;
+    error?: string;
+};
+/**
+ * Generate a commit message based on agent actions
+ */
+export declare function generateCommitMessage(prompt: string, actions: ActionLog[]): string;
+/**
+ * Auto-commit agent changes
+ */
+export declare function autoCommitAgentChanges(prompt: string, actions: ActionLog[], cwd?: string): GitCommitResult;
+/**
+ * Generate branch name from prompt
+ */
+export declare function generateBranchName(prompt: string): string;
+/**
+ * Create branch and commit agent changes
+ */
+export declare function createBranchAndCommit(prompt: string, actions: ActionLog[], cwd?: string): {
+    success: boolean;
+    branch?: string;
+    hash?: string;
+    error?: string;
+};