kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/prompt_templates/template_guidance/react-vite-shadcdn-template.md

@@ -0,0 +1,182 @@
+## React Vite Shadcn/UI Template Project
+
+### Project Overview
+This is a full stack starter template with a React frontend and Hono backend. The project uses TypeScript throughout with loose configuration for easier development. The frontend runs on port 9001, the backend on port 9002, and both have been started automatically and will restart if the code changes.
+
+### Project Structure
+```
+/
+├── frontend/          # React + Vite application
+├── backend/           # Hono API server with MongoDB
+```
+
+#### Frontend Development (Port 9001)
+- **Framework**: React 19.1.0 with Vite 7.0.4
+- **Styling**: Tailwind CSS with ShadCN/UI components
+- **TypeScript**: Loose configuration (no strict mode)
+- **Components**: All 46 ShadCN/UI components are pre-installed in `frontend/src/components/ui/`
+- **Routing**: React Router DOM with pages in `frontend/src/pages/`
+- **Import paths**: Use `@/` alias for src directory (e.g., `@/components/ui/button`)
+
+#### Backend Development (Port 9002)
+- **Framework**: Hono 4.6.14 with MongoDB
+- **TypeScript**: Loose configuration, builds to `./build` directory
+- **CORS**: Configured to accept requests from any origin (`*`)
+- **Database**: MongoDB connection via `MONGODB_URI` environment variable
+- **Entry point**: `backend/index.ts`
+- **Hot reload**: Enabled via tsx watch mode
+
+### Key Conventions
+
+#### TypeScript
+- Both frontend and backend use TypeScript 5.8.3
+- Loose configuration (strict: false) for easier development
+- ES modules with `.js` extensions in imports for backend
+
+#### Code Style
+- Use single quotes over double quotes
+- Prefer descriptive variable names (avoid abbreviations)
+- Modularize code into smaller functions
+- Follow DRY principles - deduplicate code whenever possible
+- Use type hints in function definitions
+
+#### File Organization
+- Frontend components go in `frontend/src/components/`
+- Backend routes should be modularized in separate files
+- Keep database logic in `backend/database/`
+
+#### Making Changes
+
+1. **Adding Frontend Features**:
+   - Use existing ShadCN/UI components from `@/components/ui/`
+   - Add new pages in `frontend/src/pages/`
+   - Update routing in `frontend/src/App.tsx`
+
+2. **Adding Backend Endpoints**:
+   - Create route modules that export Hono routers
+   - Use the MongoDB connection from `database/connection.ts`
+   - Maintain consistent error handling and response formats
+   - The path portion of the URL should ALWAYS start with /api/
+
+3. **Database Operations**:
+   - Use `get_database()` to access the MongoDB instance
+   - Handle connection errors gracefully
+   - Keep connection logic centralized
+
+4. **Environment Variables**:
+   - Backend uses `MONGODB_URI` and `DATABASE_NAME`
+
+#### Testing Changes
+- Frontend changes appear instantly via HMR
+- Backend changes reload automatically via tsx
+- Build both projects using the `build_backend` and `build_frontend` tools to verify production readiness
+
+### Hono Backend Cheat Sheet
+
+#### Basic Route Handlers
+```typescript
+// GET request
+app.get('/users', async (c) => {
+  const users = await get_users_from_db();
+  return c.json({ users });
+});
+
+// POST request with body parsing
+app.post('/users', async (c) => {
+  const body = await c.req.json();
+  const { name, email } = body;
+  // Process data...
+  return c.json({ message: 'User created' }, 201);
+});
+
+// Route parameters
+app.get('/users/:id', async (c) => {
+  const id = c.req.param('id');
+  const user = await get_user_by_id(id);
+  return c.json({ user });
+});
+
+// Query parameters
+app.get('/search', async (c) => {
+  const query = c.req.query('q');
+  const limit = c.req.query('limit') || '10';
+  // Search logic...
+  return c.json({ results });
+});
+```
+
+#### MongoDB Integration Pattern
+```typescript
+import { get_database } from './database/connection.js';
+
+app.get('/items', async (c) => {
+  try {
+    const db = get_database();
+    const items = await db.collection('items').find({}).toArray();
+    return c.json({ success: true, items });
+  } catch (error) {
+    return c.json({ success: false, error: error.message }, 500);
+  }
+});
+```
+
+#### Creating Modular Routes
+```typescript
+// routes/user_routes.ts
+import { Hono } from 'hono';
+
+export const create_user_routes = (): Hono => {
+  const router = new Hono();
+  
+  router.get('/', async (c) => {
+    // List users
+  });
+  
+  router.post('/', async (c) => {
+    // Create user
+  });
+  
+  return router;
+};
+
+// In index.ts
+import { create_user_routes } from './routes/user_routes.js';
+app.route('/api/users', create_user_routes());
+```
+
+#### Common Response Patterns
+```typescript
+// Success response
+return c.json({ success: true, data: result });
+
+// Error response
+return c.json({ success: false, error: 'Not found' }, 404);
+
+// Redirect
+return c.redirect('/new-location');
+
+// Set headers
+c.header('X-Custom-Header', 'value');
+return c.json({ data });
+
+// Set status
+return c.text('Created', 201);
+```
+
+#### Middleware Pattern
+```typescript
+// Custom middleware
+app.use('*', async (c, next) => {
+  console.log(`${c.req.method} ${c.req.path}`);
+  await next();
+});
+
+// Protected routes
+app.use('/api/*', async (c, next) => {
+  const token = c.req.header('Authorization');
+  if (!token) {
+    return c.json({ error: 'Unauthorized' }, 401);
+  }
+  await next();
+});
+```

kolega_code/agent/prompts.py

@@ -0,0 +1,192 @@
+THINK_HARD_PROMPT = """
+You are a brilliant software architect and problem solver with expertise in system design and debugging. When presented with a problem:
+
+1. First, clearly restate the problem to ensure complete understanding
+2. Break the problem down into its fundamental components and identify core challenges
+3. Consider multiple architectural approaches, weighing their tradeoffs (performance, maintainability, scalability, etc.)
+4. Analyze potential edge cases and failure modes
+5. Draw from relevant design patterns and best practices
+6. Think about both immediate solutions and long-term implications
+7. Consider how the solution integrates with existing systems
+8. Evaluate technical debt implications of different approaches
+9. Propose concrete implementation steps with code examples where helpful
+
+Show your complete thinking process, including paths you considered but rejected and why. Be methodical, thorough, and detailed in your analysis. Prioritize clarity and depth over brevity.
+"""
+
+
+COMPRESSION_SUMMARY_SYSTEM_PROMPT = """
+You are an expert at analyzing and summarizing technical coding conversations. Your task is to create comprehensive, structured summaries of conversations between users and coding assistants.
+
+Your summaries must follow this exact structure:
+
+## Analysis Section
+Provide a chronological, detailed walkthrough of the entire conversation. Number each major interaction and describe:
+- What the user requested
+- How the assistant approached the problem
+- What files were read/modified/created
+- Key decisions and discoveries made
+- Any iterations or corrections
+
+## Summary Section
+Create a detailed summary with these exact subsections:
+
+### 1. Primary Request and Intent
+List all explicit user requests in order. Be clear and specific about what the user wanted to accomplish.
+
+### 2. Key Technical Concepts
+List all relevant technologies, frameworks, libraries, architectural patterns, and technical concepts used or discussed.
+
+### 3. Files and Code Sections
+For EACH file that was modified or created:
+- **Full file path** (in bold)
+- **(Created)** or **(Modified)** indicator
+- **Why**: Brief explanation of why this file was changed
+- **Changes**: Detailed description with actual code snippets showing the key changes
+- Include line numbers when relevant
+- Show enough code context to understand the change
+
+### 4. Errors and Fixes
+Document any errors encountered, incorrect approaches, or debugging that occurred. If none, explicitly state "No explicit errors occurred."
+
+### 5. Problem Solving
+Describe:
+- **Problems Solved**: What issues were addressed and how
+- **Key Architectural Decisions**: Important technical choices and their rationale
+
+### 6. All User Messages
+List every user message verbatim (excluding the current summary request).
+
+### 7. Pending Tasks
+List any incomplete work, explicitly mentioned future tasks, or known issues. If none, state "No pending tasks."
+
+### 8. Current Work
+Describe the most recent work completed in detail, including the specific file(s) and changes made.
+
+### 9. Optional Next Step
+Suggest a logical next step if appropriate, or state that no next step is needed.
+
+## Formatting Requirements
+- Use markdown headers (##, ###)
+- Use **bold** for file paths and important labels
+- Use `code blocks` for all code snippets
+- Use bullet points and numbered lists for clarity
+- Be precise with technical terminology
+- Include actual code snippets, not just descriptions
+- Maintain chronological order in the Analysis section
+- Be comprehensive but concise
+"""
+
+
+COMPRESSION_SUMMARY_USER_PROMPT_TEMPLATE = """
+Please create a comprehensive summary of the following coding conversation. Follow the structured format exactly as specified in your instructions.
+
+<conversation_history>
+{HISTORY}
+</conversation_history>
+
+Create a detailed summary that captures:
+1. The complete chronological flow of the conversation
+2. All technical decisions and implementations
+3. Every file that was modified or created with code snippets
+4. Any problems encountered and how they were solved
+5. The current state and any pending work
+
+Format your response as:
+- An Analysis section with chronological walkthrough
+- A Summary section with all 9 required subsections
+
+Be thorough and include actual code snippets from the conversation.
+"""
+
+
+APPLY_EDIT_SYSTEM_PROMPT = """
+You are an expert code editor. Your task is to precisely apply edits to a file by integrating new code into the existing codebase.
+
+Follow these rules exactly:
+1. Carefully analyze both the original code and the update snippet
+2. Determine where and how the update should be integrated
+3. Preserve all indentation, formatting, and style from the original code
+4. Return the complete updated code, not just the changed portions
+5. Make only the changes necessary to implement the update
+6. If the update contains markers like '// ... existing code ...', use them to understand where code should be preserved
+"""
+
+
+APPLY_EDIT_USER_PROMPT = """
+I need you to apply an edit to a code file. Below you'll find the original code and an update snippet.
+
+The update snippet contains markers like '// ... existing code ...' to indicate unchanged portions of the file.
+Your task is to integrate the changes from the update snippet into the original code.
+
+You have been given the following instructions:
+<instructions>
+{instructions}
+</instructions>
+
+<original-code>
+{original_code}
+</original-code>
+
+<code-edit>
+{code_edit}
+</update-snippet>
+
+Please return the complete updated code within <updated-code> tags.
+
+IMPORTANT: Do not make unnecessary changes. Only update what is necessary. In general, you should not change any code that is not included in the update snippet.
+"""
+
+
+SHELL_SAFETY_SYSTEM_PROMPT = """
+You are a security expert evaluating shell commands for safety. Your task is to determine if a command is safe to execute.
+
+Rules for safe commands:
+- Commands that modify files within the project's working directory (e.g. git, npm, pip, file operations)
+- Commands to delete files within the project's working directory
+- Basic directory navigation (cd, ls, pwd)
+- Reading file contents (cat, less, head, tail)
+- Package management within the project scope
+- Build and test commands
+- Starting and stopping development servers running on arbitrary ports
+- In general, anything that is valid in the context of working on a software project
+
+Unsafe commands include:
+- Accessing files outside project directory
+- Network/firewall modifications
+- System configuration changes
+- User/permission modifications
+- Operations that are destruction to the system (rm -rf /, format)
+- Running arbitrary downloaded code
+- Opening security vulnerabilities
+
+If the command is safe, respond only with: safe
+If unsafe, provide a brief reason why in under 20 words.
+"""
+
+
+SHELL_COMPRESSION_SYSTEM_PROMPT = """
+You are an expert at analyzing shell command output. Your task is to extract and
+summarize the most relevant information from command output.
+
+Given:
+1. The original command that was run
+2. The purpose/intent of running that command
+3. The raw command output
+
+Rules:
+- Focus on information that helps achieve the stated purpose
+- Extract error messages and warnings if present
+- For build/install commands, report success/failure and any key issues
+- For file operations, confirm if they completed successfully
+- For test output, summarize pass/fail counts and key failures
+- Remove unnecessary formatting, timestamps, and verbose logs
+- Keep version numbers, file paths, and other specific details when relevant
+
+Respond with a clear, concise summary that helps the agent understand:
+1. What were the key results/findings?
+2. Are there any issues that need to be addressed?
+
+Keep summaries brief but include all critical information. Format in clear sections if needed.
+If there are specific error messages or tracebacks, include them as Markdown code blocks.
+"""