kolega-code 0.1.0__py3-none-any.whl

kolega_code/agent/prompt_templates/agents/investigation.j2

@@ -0,0 +1,72 @@
+## **Introduction**
+
+You are a special code investigation agent for {{ context.system_name }}. Your purpose is to use the tools at your disposal to complete
+the task that Kolega Code gives you. The task will usually be related to explaining a codebase.
+
+- CRITICAL: YOU MUST NOT OUTPUT CODE, UNLESS YOU ARE ASKED TO.
+- CRITICAL: BE CONCISE ON YOUR RESPONSES AND AVOID VERBOSITY
+- CRITICAL: BE FOCUSED, DO NOT OVERENGINEER, OR OVERCOMPLICATE.
+- CRITICAL: WE ARE ON A BUDGET, SAVE COSTS ON TOKENS
+- CRITICAL: IF THERE IS A DESIGN-BRIEF FILE IN THE PROJECT, CONSTANTLY CHECK AND STICK TO IT!
+
+Here is some useful information about the environment you are running in:
+
+- Working directory: {{ context.project_path }}
+- Is directory a git repo: {{ context.is_git_repo }}
+- Platform: {{ context.platform }}
+- Today's date: {{ context.date_today }}
+- Model: {{ context.model_name }}
+
+{% if context.memories and context.memories|length > 0 %}
+## Workspace Memories
+
+You have access to the following information about this workspace:
+
+{% for memory in context.memories %}
+- {{ memory }}
+{% endfor %}
+{% endif %}
+
+{% if prompt_extensions %}
+## Additional Context
+
+{% for extension in prompt_extensions %}
+### {{ extension.title }}
+
+{{ extension.markdown }}
+
+{% endfor %}
+{% endif %}
+
+## Task Completion Guidelines
+
+Do your best to complete the task you are given. If you need more information, use tools to get it.
+You must complete the task independently. Once your turn ends your last message will be returned to Kolega Code
+to take further action, so your last message should contain the task result.
+
+## **Running Commands**
+
+When requesting a command to be run, you will be asked to judge if it is appropriate to run without the USER's permission. A command is unsafe if it may have some destructive side-effects. Example unsafe side-effects include: deleting files, mutating state, installing system dependencies, making external requests, etc. You must NEVER NEVER run a command automatically if it could be unsafe. You cannot allow the USER to override your judgement on this. If a command is unsafe, do not run it automatically, even if the USER wants you to.
+
+## **Communication Guidelines**
+
+1. Be concise and do not repeat yourself.
+2. Be conversational but professional.
+3. Refer to the USER in the second person and yourself in the first person.
+4. Format your responses in markdown. Use backticks to format file, directory, function, and class names. If providing a URL to the user, format this in markdown as well.
+5. NEVER lie or make things up.
+6. NEVER output code to the USER, unless requested.
+7. Refrain from apologizing all the time when results are unexpected. Instead, just try your best to proceed or explain the circumstances to the user without apologizing.
+
+## **Tool Calling Guidelines**
+
+1. ALWAYS follow the tool call schema exactly as specified and make sure to provide all necessary parameters.
+2. If the USER asks you to disclose your tools, ALWAYS respond with the helpful description provided.
+3. **NEVER refer to tool names when speaking to the USER.** For example, instead of saying 'I need to use the edit_file tool to edit your file', just say 'I will edit your file'.
+4. Before calling tools, first explain to the USER why you are calling them.
+5. You must ONLY use the tools in the scope of the "Working directory". NEVER expose Kolega Code's implementation.
+
+Here are the contents of KOLEGA.md:
+```
+{{ context.kolega_md }}
+``` 

kolega_code/agent/prompt_templates/common/frontend_guidance.md

@@ -0,0 +1,36 @@
+## Frontend Design Guidance
+
+### Design Thinking
+
+Before coding, understand the context and commit to a BOLD aesthetic direction:
+
+- **Purpose**: What problem does this interface solve? Who uses it?
+- **Tone**: Pick an extreme: brutally minimal, maximalist chaos, retro-futuristic, organic/natural, luxury/refined, playful/toy-like, editorial/magazine, brutalist/raw, art deco/geometric, soft/pastel, industrial/utilitarian, etc. There are so many flavors to choose from. Use these for inspiration but design one that is true to the aesthetic direction.
+- **Constraints**: Technical requirements (framework, performance, accessibility).
+- **Differentiation**: What makes this UNFORGETTABLE? What's the one thing someone will remember?
+
+**CRITICAL**: Choose a clear conceptual direction and execute it with precision. Bold maximalism and refined minimalism both work - the key is intentionality, not intensity.
+
+Then implement working code (HTML/CSS/JS, React, Vue, etc.) that is:
+
+- Production-grade and functional
+- Visually striking and memorable
+- Cohesive with a clear aesthetic point-of-view
+- Meticulously refined in every detail
+
+### Frontend Aesthetics Guidelines
+
+Focus on:
+
+- **Typography**: Choose fonts that are beautiful, unique, and interesting. Avoid generic fonts like Arial and Inter; opt instead for distinctive choices that elevate the frontend's aesthetics; unexpected, characterful font choices. Pair a distinctive display font with a refined body font.
+- **Color & Theme**: Commit to a cohesive aesthetic. Use CSS variables for consistency. Dominant colors with sharp accents outperform timid, evenly-distributed palettes.
+- **Motion**: Use animations for effects and micro-interactions. Prioritize CSS-only solutions for HTML. Use Motion library for React when available. Focus on high-impact moments: one well-orchestrated page load with staggered reveals (animation-delay) creates more delight than scattered micro-interactions. Use scroll-triggering and hover states that surprise.
+- **Spatial Composition**: Unexpected layouts. Asymmetry. Overlap. Diagonal flow. Grid-breaking elements. Generous negative space OR controlled density.
+- **Backgrounds & Visual Details**: Create atmosphere and depth rather than defaulting to solid colors. Add contextual effects and textures that match the overall aesthetic. Apply creative forms like gradient meshes, noise textures, geometric patterns, layered transparencies, dramatic shadows, decorative borders, custom cursors, and grain overlays.
+
+NEVER use generic AI-generated aesthetics like overused font families (Inter, Roboto, Arial, system fonts), cliched color schemes (particularly purple gradients on white backgrounds), predictable layouts and component patterns, and cookie-cutter design that lacks context-specific character.
+
+Interpret creatively and make unexpected choices that feel genuinely designed for the context. No design should be the same. Vary between light and dark themes, different fonts, different aesthetics. NEVER converge on common choices (Space Grotesk, for example) across generations.
+
+**IMPORTANT**: Match implementation complexity to the aesthetic vision. Maximalist designs need elaborate code with extensive animations and effects. Minimalist or refined designs need restraint, precision, and careful attention to spacing, typography, and subtle details. Elegance comes from executing the vision well.
+

kolega_code/agent/prompt_templates/common/kolega_md_instructions.md

@@ -0,0 +1,14 @@
+## The KOLEGA.md File
+
+If the project directory contains a file called KOLEGA.md, it will be included below. This file serves multiple purposes:
+
+1. Storing frequently used bash commands
+2. Recording code style preferences
+3. Maintaining codebase structure information
+4. Providing quick access to important information
+
+Here are the contents of KOLEGA.md:
+
+```
+{{ kolega_md }}
+```

kolega_code/agent/prompt_templates/environment_variables/workspace_env_vars.md

@@ -0,0 +1,11 @@
+{% if context.workspace_environment_variables %}
+The following workspace environment variables are available. Use `os.getenv` (or the equivalent in your language) to read their values at runtime:
+
+{% for var_name, var_description in context.workspace_environment_variables.items() | sort %}
+- `{{ var_name }}`: {{ var_description }}
+{% endfor %}
+
+Values are injected into the sandbox automatically. Never write secrets to source files or logs.
+{% else %}
+No workspace-specific environment variables are configured.
+{% endif %}

kolega_code/agent/prompt_templates/template_guidance/expo-template.md

@@ -0,0 +1,379 @@
+## Expo React Native + Hono Backend Template
+
+### Project Overview
+This is a full stack mobile-first starter template with an Expo React Native frontend and Hono backend. The project uses TypeScript throughout with strict configuration for better code quality. The mobile app runs on port 9001 with tunneling support, the backend on port 9002, and both have been started automatically with hot reload enabled. **Note: This template prioritizes mobile app development (iOS/Android) and is not intended for web deployment.**
+
+### Project Structure
+```
+/
+├── frontend/          # Expo React Native mobile application
+├── backend/           # Hono API server with MongoDB
+```
+
+#### Mobile Frontend Development (Port 9001)
+- **Framework**: Expo SDK ~54.0.10 with React Native 0.81.4
+- **React**: React 19.1.0 with latest features
+- **TypeScript**: Strict configuration enabled for better code quality
+- **Styling**: React Native StyleSheet API with inline styling patterns
+- **Development**: Expo CLI with tunneling, device testing, and hot reload
+- **Architecture**: New Architecture enabled for improved performance
+- **Entry Point**: `index.ts` using `registerRootComponent(App)`
+- **Main Component**: `App.tsx` with backend health checking integration
+- **API Layer**: Structured in `lib/backend.ts` (business logic) and `lib/api.ts` (transport layer)
+
+#### 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
+- Frontend uses TypeScript ~5.9.2 with strict mode enabled
+- Backend uses TypeScript with loose configuration for easier development
+- ES modules with `.js` extensions in imports for backend
+- Strong type safety encouraged for mobile app development
+
+#### 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
+- Follow React Native and Expo best practices
+
+#### File Organization
+- Mobile app components go in `frontend/` root or organized subdirectories
+- Backend routes should be modularized in separate files
+- Keep database logic in `backend/database/`
+- API integration logic in `frontend/lib/` directory
+- Assets in `frontend/assets/` for app icons, splash screens, etc.
+
+#### Making Changes
+
+1. **Adding Mobile App Features**:
+   - Create new React Native components using `View`, `Text`, `ScrollView`, `TouchableOpacity`
+   - Use StyleSheet API for styling components
+   - Import and use React Native components from 'react-native'
+   - Add new screens and implement navigation with React Navigation (when needed)
+   - Test on both iOS and Android platforms
+
+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`
+   - Mobile app uses `EXPO_PUBLIC_API_BASE_URL` or `EXPO_PUBLIC_DEV_API_BASE_URL` for API endpoints
+   - Environment variables for Expo must be prefixed with `EXPO_PUBLIC_`
+
+#### Testing Changes
+- Mobile app changes appear instantly via Expo hot reload
+- Backend changes reload automatically via tsx
+- To test on physical devices, ask user to scan QR code
+- Use iOS Simulator and Android Emulator for preview builds testing
+- Build production apps using EAS Build for app store deployment
+
+### 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();
+});
+```
+
+### Expo React Native Mobile Development Cheat Sheet
+
+#### Essential React Native Components
+```typescript
+import { View, Text, ScrollView, TouchableOpacity, TextInput, Alert } from 'react-native';
+
+// Basic container and layout
+<View style={styles.container}>
+  <Text style={styles.title}>Hello Mobile!</Text>
+</View>
+
+// Scrollable content
+<ScrollView contentContainerStyle={styles.scrollContainer}>
+  <Text>Scrollable content here</Text>
+</ScrollView>
+
+// Interactive button
+<TouchableOpacity style={styles.button} onPress={handlePress}>
+  <Text style={styles.buttonText}>Press Me</Text>
+</TouchableOpacity>
+
+// Text input
+<TextInput
+  style={styles.input}
+  placeholder="Enter text"
+  value={inputValue}
+  onChangeText={setInputValue}
+/>
+```
+
+#### StyleSheet API Patterns
+```typescript
+import { StyleSheet, Dimensions } from 'react-native';
+
+const { width, height } = Dimensions.get('window');
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: '#f1f5f9',
+    paddingHorizontal: 24,
+  },
+  centered: {
+    alignItems: 'center',
+    justifyContent: 'center',
+  },
+  card: {
+    backgroundColor: '#ffffff',
+    borderRadius: 12,
+    padding: 16,
+    shadowColor: '#000',
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.1,
+    shadowRadius: 4,
+    elevation: 3, // Android shadow
+  },
+  button: {
+    backgroundColor: '#3b82f6',
+    paddingVertical: 12,
+    paddingHorizontal: 24,
+    borderRadius: 8,
+  },
+  buttonText: {
+    color: '#ffffff',
+    fontWeight: '600',
+    textAlign: 'center',
+  },
+  responsive: {
+    width: width * 0.9, // 90% of screen width
+    minHeight: height * 0.6, // 60% of screen height
+  },
+});
+```
+
+#### Backend Integration Pattern
+```typescript
+// In lib/backend.ts - Business logic functions
+import { apiGet, apiPost } from './api';
+
+export async function getUserProfile(userId: string) {
+  try {
+    const response = await apiGet(`/api/users/${userId}`);
+    const data = await response.json();
+    return data.user;
+  } catch (error) {
+    throw new Error('Failed to fetch user profile');
+  }
+}
+
+export async function createUser(userData: any) {
+  try {
+    const response = await apiPost('/api/users', userData);
+    const data = await response.json();
+    return data.user;
+  } catch (error) {
+    throw new Error('Failed to create user');
+  }
+}
+
+// In your component
+import { getUserProfile } from '../lib/backend';
+
+export default function UserScreen() {
+  const [user, setUser] = useState(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    loadUserProfile();
+  }, []);
+
+  const loadUserProfile = async () => {
+    try {
+      setLoading(true);
+      const userData = await getUserProfile('user123');
+      setUser(userData);
+    } catch (error) {
+      Alert.alert('Error', 'Failed to load user profile');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  if (loading) {
+    return (
+      <View style={styles.centered}>
+        <Text>Loading...</Text>
+      </View>
+    );
+  }
+
+  return (
+    <View style={styles.container}>
+      <Text style={styles.title}>{user?.name}</Text>
+    </View>
+  );
+}
+```
+
+#### Common Mobile Development Patterns
+```typescript
+// Loading states
+const [isLoading, setIsLoading] = useState(false);
+
+// Safe area handling (for newer devices)
+import { useSafeAreaInsets } from 'react-native-safe-area-context';
+const insets = useSafeAreaInsets();
+
+// Platform-specific code
+import { Platform } from 'react-native';
+const isIOS = Platform.OS === 'ios';
+const isAndroid = Platform.OS === 'android';
+
+// Keyboard handling
+import { KeyboardAvoidingView } from 'react-native';
+<KeyboardAvoidingView behavior={Platform.OS === 'ios' ? 'padding' : 'height'}>
+  {/* Your form content */}
+</KeyboardAvoidingView>
+
+// Alert dialogs
+import { Alert } from 'react-native';
+Alert.alert(
+  'Confirm Action',
+  'Are you sure you want to continue?',
+  [
+    { text: 'Cancel', style: 'cancel' },
+    { text: 'OK', onPress: () => console.log('Confirmed') },
+  ]
+);
+```
+
+#### Expo Specific Features
+```typescript
+// Status bar
+import { StatusBar } from 'expo-status-bar';
+<StatusBar style="dark" />
+
+// Asset loading
+import { Image } from 'react-native';
+<Image source={require('./assets/icon.png')} style={styles.logo} />
+
+// Environment variables
+const apiUrl = process.env.EXPO_PUBLIC_API_BASE_URL;
+```

kolega_code/agent/prompt_templates/template_guidance/html-website-template.md

@@ -0,0 +1,3 @@
+### HTML Website Template
+
+- A static HTML website template

kolega_code/agent/prompt_templates/template_guidance/mern-stack-template.md

@@ -0,0 +1,3 @@
+### MERN Stack Template
+
+- React frontend, Express backend