kernelbot 1.0.22 → 1.0.24

package/.agents/skills/interface-design/references/principles.md

@@ -0,0 +1,235 @@
+# Core Craft Principles
+
+These apply regardless of design direction. This is the quality floor.
+
+---
+
+## Surface & Token Architecture
+
+Professional interfaces don't pick colors randomly — they build systems. Understanding this architecture is the difference between "looks okay" and "feels like a real product."
+
+### The Primitive Foundation
+
+Every color in your interface should trace back to a small set of primitives:
+
+- **Foreground** — text colors (primary, secondary, muted)
+- **Background** — surface colors (base, elevated, overlay)
+- **Border** — edge colors (default, subtle, strong)
+- **Brand** — your primary accent
+- **Semantic** — functional colors (destructive, warning, success)
+
+Don't invent new colors. Map everything to these primitives.
+
+### Surface Elevation Hierarchy
+
+Surfaces stack. A dropdown sits above a card which sits above the page. Build a numbered system:
+
+```
+Level 0: Base background (the app canvas)
+Level 1: Cards, panels (same visual plane as base)
+Level 2: Dropdowns, popovers (floating above)
+Level 3: Nested dropdowns, stacked overlays
+Level 4: Highest elevation (rare)
+```
+
+In dark mode, higher elevation = slightly lighter. In light mode, higher elevation = slightly lighter or uses shadow. The principle: **elevated surfaces need visual distinction from what's beneath them.**
+
+### The Subtlety Principle
+
+This is where most interfaces fail. Study Vercel, Supabase, Linear — their surfaces are **barely different** but still distinguishable. Their borders are **light but not invisible**.
+
+**For surfaces:** The difference between elevation levels should be subtle — a few percentage points of lightness, not dramatic jumps. In dark mode, surface-100 might be 7% lighter than base, surface-200 might be 9%, surface-300 might be 12%. You can barely see it, but you feel it.
+
+**For borders:** Borders should define regions without demanding attention. Use low opacity (0.05-0.12 alpha for dark mode, slightly higher for light). The border should disappear when you're not looking for it, but be findable when you need to understand the structure.
+
+**The test:** Squint at your interface. You should still perceive the hierarchy — what's above what, where regions begin and end. But no single border or surface should jump out at you. If borders are the first thing you notice, they're too strong. If you can't find where one region ends and another begins, they're too subtle.
+
+**Common AI mistakes to avoid:**
+- Borders that are too visible (1px solid gray instead of subtle rgba)
+- Surface jumps that are too dramatic (going from dark to light instead of dark to slightly-less-dark)
+- Using different hues for different surfaces (gray card on blue background)
+- Harsh dividers where subtle borders would do
+
+### Text Hierarchy via Tokens
+
+Don't just have "text" and "gray text." Build four levels:
+
+- **Primary** — default text, highest contrast
+- **Secondary** — supporting text, slightly muted
+- **Tertiary** — metadata, timestamps, less important
+- **Muted** — disabled, placeholder, lowest contrast
+
+Use all four consistently. If you're only using two, your hierarchy is too flat.
+
+### Border Progression
+
+Borders aren't binary. Build a scale:
+
+- **Default** — standard borders
+- **Subtle/Muted** — softer separation
+- **Strong** — emphasis, hover states
+- **Stronger** — maximum emphasis, focus rings
+
+Match border intensity to the importance of the boundary.
+
+### Dedicated Control Tokens
+
+Form controls (inputs, checkboxes, selects) have specific needs. Don't just reuse surface tokens — create dedicated ones:
+
+- **Control background** — often different from surface backgrounds
+- **Control border** — needs to feel interactive
+- **Control focus** — clear focus indication
+
+This separation lets you tune controls independently from layout surfaces.
+
+### Context-Aware Bases
+
+Different areas of your app might need different base surfaces:
+
+- **Marketing pages** — might use darker/richer backgrounds
+- **Dashboard/app** — might use neutral working backgrounds
+- **Sidebar** — might differ from main canvas
+
+The surface hierarchy works the same way — it just starts from a different base.
+
+### Alternative Backgrounds for Depth
+
+Beyond shadows, use contrasting backgrounds to create depth. An "alternative" or "inset" background makes content feel recessed. Useful for:
+
+- Empty states in data grids
+- Code blocks
+- Inset panels
+- Visual grouping without borders
+
+---
+
+## Spacing System
+
+Pick a base unit (4px and 8px are common) and use multiples throughout. The specific number matters less than consistency — every spacing value should be explainable as "X times the base unit."
+
+Build a scale for different contexts:
+- Micro spacing (icon gaps, tight element pairs)
+- Component spacing (within buttons, inputs, cards)
+- Section spacing (between related groups)
+- Major separation (between distinct sections)
+
+## Symmetrical Padding
+
+TLBR must match. If top padding is 16px, left/bottom/right must also be 16px. Exception: when content naturally creates visual balance.
+
+```css
+/* Good */
+padding: 16px;
+padding: 12px 16px; /* Only when horizontal needs more room */
+
+/* Bad */
+padding: 24px 16px 12px 16px;
+```
+
+## Border Radius Consistency
+
+Sharper corners feel technical, rounder corners feel friendly. Pick a scale that fits your product's personality and use it consistently.
+
+The key is having a system: small radius for inputs and buttons, medium for cards, large for modals or containers. Don't mix sharp and soft randomly — inconsistent radius is as jarring as inconsistent spacing.
+
+## Depth & Elevation Strategy
+
+Match your depth approach to your design direction. Choose ONE and commit:
+
+**Borders-only (flat)** — Clean, technical, dense. Works for utility-focused tools where information density matters more than visual lift. Linear, Raycast, and many developer tools use almost no shadows — just subtle borders to define regions.
+
+**Subtle single shadows** — Soft lift without complexity. A simple `0 1px 3px rgba(0,0,0,0.08)` can be enough. Works for approachable products that want gentle depth.
+
+**Layered shadows** — Rich, premium, dimensional. Multiple shadow layers create realistic depth. Stripe and Mercury use this approach. Best for cards that need to feel like physical objects.
+
+**Surface color shifts** — Background tints establish hierarchy without any shadows. A card at `#fff` on a `#f8fafc` background already feels elevated.
+
+```css
+/* Borders-only approach */
+--border: rgba(0, 0, 0, 0.08);
+--border-subtle: rgba(0, 0, 0, 0.05);
+border: 0.5px solid var(--border);
+
+/* Single shadow approach */
+--shadow: 0 1px 3px rgba(0, 0, 0, 0.08);
+
+/* Layered shadow approach */
+--shadow-layered:
+  0 0 0 0.5px rgba(0, 0, 0, 0.05),
+  0 1px 2px rgba(0, 0, 0, 0.04),
+  0 2px 4px rgba(0, 0, 0, 0.03),
+  0 4px 8px rgba(0, 0, 0, 0.02);
+```
+
+## Card Layouts
+
+Monotonous card layouts are lazy design. A metric card doesn't have to look like a plan card doesn't have to look like a settings card.
+
+Design each card's internal structure for its specific content — but keep the surface treatment consistent: same border weight, shadow depth, corner radius, padding scale, typography.
+
+## Isolated Controls
+
+UI controls deserve container treatment. Date pickers, filters, dropdowns — these should feel like crafted objects.
+
+**Never use native form elements for styled UI.** Native `<select>`, `<input type="date">`, and similar elements render OS-native dropdowns that cannot be styled. Build custom components instead:
+
+- Custom select: trigger button + positioned dropdown menu
+- Custom date picker: input + calendar popover
+- Custom checkbox/radio: styled div with state management
+
+Custom select triggers must use `display: inline-flex` with `white-space: nowrap` to keep text and chevron icons on the same row.
+
+## Typography Hierarchy
+
+Build distinct levels that are visually distinguishable at a glance:
+
+- **Headlines** — heavier weight, tighter letter-spacing for presence
+- **Body** — comfortable weight for readability
+- **Labels/UI** — medium weight, works at smaller sizes
+- **Data** — often monospace, needs `tabular-nums` for alignment
+
+Don't rely on size alone. Combine size, weight, and letter-spacing to create clear hierarchy. If you squint and can't tell headline from body, the hierarchy is too weak.
+
+## Monospace for Data
+
+Numbers, IDs, codes, timestamps belong in monospace. Use `tabular-nums` for columnar alignment. Mono signals "this is data."
+
+## Iconography
+
+Icons clarify, not decorate — if removing an icon loses no meaning, remove it. Choose a consistent icon set and stick with it throughout the product.
+
+Give standalone icons presence with subtle background containers. Icons next to text should align optically, not mathematically.
+
+## Animation
+
+Keep it fast and functional. Micro-interactions (hover, focus) should feel instant — around 150ms. Larger transitions (modals, panels) can be slightly longer — 200-250ms.
+
+Use smooth deceleration easing (ease-out variants). Avoid spring/bounce effects in professional interfaces — they feel playful, not serious.
+
+## Contrast Hierarchy
+
+Build a four-level system: foreground (primary) → secondary → muted → faint. Use all four consistently.
+
+## Color Carries Meaning
+
+Gray builds structure. Color communicates — status, action, emphasis, identity. Unmotivated color is noise. Color that reinforces the product's world is character.
+
+## Navigation Context
+
+Screens need grounding. A data table floating in space feels like a component demo, not a product. Consider including:
+
+- **Navigation** — sidebar or top nav showing where you are in the app
+- **Location indicator** — breadcrumbs, page title, or active nav state
+- **User context** — who's logged in, what workspace/org
+
+When building sidebars, consider using the same background as the main content area. Rely on a subtle border for separation rather than different background colors.
+
+## Dark Mode
+
+Dark interfaces have different needs:
+
+**Borders over shadows** — Shadows are less visible on dark backgrounds. Lean more on borders for definition.
+
+**Adjust semantic colors** — Status colors (success, warning, error) often need to be slightly desaturated for dark backgrounds.
+
+**Same structure, different values** — The hierarchy system still applies, just with inverted values.

package/.agents/skills/interface-design/references/validation.md

@@ -0,0 +1,48 @@
+# Memory Management
+
+When and how to update `.interface-design/system.md`.
+
+## When to Add Patterns
+
+Add to system.md when:
+- Component used 2+ times
+- Pattern is reusable across the project
+- Has specific measurements worth remembering
+
+## Pattern Format
+
+```markdown
+### Button Primary
+- Height: 36px
+- Padding: 12px 16px
+- Radius: 6px
+- Font: 14px, 500 weight
+```
+
+## Don't Document
+
+- One-off components
+- Temporary experiments
+- Variations better handled with props
+
+## Pattern Reuse
+
+Before creating a component, check system.md:
+- Pattern exists? Use it.
+- Need variation? Extend, don't create new.
+
+Memory compounds: each pattern saved makes future work faster and more consistent.
+
+---
+
+# Validation Checks
+
+If system.md defines specific values, check consistency:
+
+**Spacing** — All values multiples of the defined base?
+
+**Depth** — Using the declared strategy throughout? (borders-only means no shadows)
+
+**Colors** — Using defined palette, not random hex codes?
+
+**Patterns** — Reusing documented patterns instead of creating new?

package/.env.example

@@ -1,3 +1,6 @@
 ANTHROPIC_API_KEY=sk-ant-...
 TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
 GITHUB_TOKEN=ghp_...
+JIRA_BASE_URL=https://yourcompany.atlassian.net
+JIRA_EMAIL=you@company.com
+JIRA_API_TOKEN=your-jira-api-token

package/README.md

@@ -1,31 +1,134 @@
 # KernelBot
 
-AI engineering agent — a Telegram bot backed by Claude Sonnet with full OS control via tool use.
-
-Send a message in Telegram, and KernelBot will read files, write code, run commands, and respond with the results. It's your personal engineering assistant with direct access to your machine.
+[kernelbot.io](https://kernelbot.io) | [npm](https://www.npmjs.com/package/kernelbot) | [GitHub](https://github.com/KernelCode/KERNEL)
+
+AI engineering agent — a Telegram bot backed by Claude with full OS control via tool use.
+
+Send a message in Telegram, and KernelBot will read files, write code, run commands, browse the web, manage infrastructure, and respond with the results. It's your personal engineering assistant with direct access to your machine.
+
+## Features
+
+- **Autonomous agent loop** — send one message and KernelBot chains tool calls until the task is done, no hand-holding needed
+- **Full shell access** — run any command, install packages, build projects, run tests
+- **File management** — read, write, and create files with automatic directory creation
+- **Web browsing** — navigate pages, extract content, take screenshots, interact with forms and buttons (Puppeteer)
+- **Git workflow** — clone repos, create branches, commit, push, and view diffs
+- **GitHub integration** — create repos, open PRs, post code reviews, list and inspect pull requests
+- **JIRA integration** — read tickets, search with JQL, list assigned/project tickets (Cloud + Server)
+- **Claude Code sub-agent** — spawn a dedicated Claude Code CLI session for complex coding tasks (write, edit, debug, refactor)
+- **Docker management** — list containers, read logs, exec into containers, run compose commands
+- **Process control** — list, kill, and manage system processes and systemd services
+- **System monitoring** — check CPU, RAM, disk usage, and read system logs
+- **Networking** — make HTTP requests, check ports, test and reload nginx
+- **Send images** — share screenshots and files directly in the Telegram chat
+- **Conversation memory** — per-chat history that persists across restarts
+- **Live status updates** — Claude Code activity consolidated into a single updating message instead of spam
+- **Security built-in** — user allowlist, blocked paths, dangerous operation confirmation, audit logging, secret redaction
+- **Zero config setup** — auto-detects config, prompts for missing credentials on first run
+- **Credential management** — auto-prompts for missing API keys (GitHub, Anthropic, Telegram, JIRA) and saves them
 
 ## How It Works
 
 ```text
-You (Telegram) → KernelBot → Claude Sonnet (Anthropic API)
+You (Telegram) → KernelBot → Claude (Anthropic API)
+                                   ↕
+                      Tools (shell, files, git, docker, browser, etc.)
                                    ↕
-                             OS Tools (shell, files, directories)
+                      Claude Code CLI (coding tasks)
 ```
 
 KernelBot runs a **tool-use loop**: Claude decides which tools to call, KernelBot executes them on your OS, feeds results back, and Claude continues until the task is done. One message can trigger dozens of tool calls autonomously.
 
+For complex coding tasks, KernelBot can spawn **Claude Code CLI** as a sub-agent — giving it a dedicated coding environment with its own tool loop for writing, editing, and debugging code.
+
 ## Tools
 
-| Tool              | Description                                         |
-| ----------------- | --------------------------------------------------- |
-| `execute_command` | Run any shell command (git, npm, python, etc.)      |
-| `read_file`       | Read file contents with optional line limits        |
-| `write_file`      | Write/create files, auto-creates parent directories |
-| `list_directory`  | List directory contents, optionally recursive       |
+### File System & Shell
+
+| Tool | Description |
+| --- | --- |
+| `execute_command` | Run any shell command (git, npm, python, etc.) |
+| `read_file` | Read file contents with optional line limits |
+| `write_file` | Write/create files, auto-creates parent directories |
+| `list_directory` | List directory contents, optionally recursive |
+
+### Git & GitHub
+
+| Tool | Description |
+| --- | --- |
+| `git_clone` | Clone a repo (`org/repo` shorthand or full URL) |
+| `git_checkout` | Checkout or create branches |
+| `git_commit` | Stage all changes and commit |
+| `git_push` | Push current branch to remote |
+| `git_diff` | Show uncommitted changes |
+| `github_create_pr` | Create a pull request |
+| `github_get_pr_diff` | Get the diff of a PR |
+| `github_post_review` | Post a review on a PR |
+| `github_create_repo` | Create a new GitHub repository |
+| `github_list_prs` | List pull requests for a repo |
+
+### Web Browsing
+
+| Tool | Description |
+| --- | --- |
+| `browse_website` | Navigate to a URL and extract page content (title, headings, text, links) |
+| `screenshot_website` | Take a screenshot of a website, supports full-page and element capture |
+| `extract_content` | Extract specific content using CSS selectors |
+| `interact_with_page` | Click, type, scroll, and run JS on a webpage |
+| `send_image` | Send an image/screenshot directly to the Telegram chat |
+
+### JIRA
+
+| Tool | Description |
+| --- | --- |
+| `jira_get_ticket` | Get details of a specific JIRA ticket |
+| `jira_search_tickets` | Search tickets using JQL queries |
+| `jira_list_my_tickets` | List tickets assigned to the current user |
+| `jira_get_project_tickets` | Get tickets from a specific JIRA project |
+
+### Docker
+
+| Tool | Description |
+| --- | --- |
+| `docker_ps` | List containers |
+| `docker_logs` | Get container logs |
+| `docker_exec` | Execute a command inside a running container |
+| `docker_compose` | Run docker compose commands |
+
+### Process & System
+
+| Tool | Description |
+| --- | --- |
+| `process_list` | List running processes, optionally filter by name |
+| `kill_process` | Kill a process by PID or name |
+| `service_control` | Manage systemd services (start, stop, restart, status) |
+
+### Monitoring
+
+| Tool | Description |
+| --- | --- |
+| `disk_usage` | Show disk space usage |
+| `memory_usage` | Show RAM usage |
+| `cpu_usage` | Show CPU load |
+| `system_logs` | Read system or application logs |
+
+### Networking
+
+| Tool | Description |
+| --- | --- |
+| `check_port` | Check if a port is open and listening |
+| `curl_url` | Make HTTP requests and return the response |
+| `nginx_reload` | Test nginx config and reload if valid |
+
+### Coding
+
+| Tool | Description |
+| --- | --- |
+| `spawn_claude_code` | Spawn Claude Code CLI for coding tasks — writing, fixing, reviewing, and scaffolding code |
 
 ## Disclaimer
 
-> **WARNING:** KernelBot has full access to your operating system. It can execute shell commands, read/write files, manage processes, control Docker containers, and interact with external services (GitHub, Telegram) on your behalf. Only run KernelBot on machines you own and control. Always configure `allowed_users` in production to restrict who can interact with the bot. The authors are not responsible for any damage caused by misuse.
+> **WARNING:** KernelBot has full access to your operating system. It can execute shell commands, read/write files, manage processes, control Docker containers, browse the web, and interact with external services (GitHub, Telegram) on your behalf. Only run KernelBot on machines you own and control. Always configure `allowed_users` in production to restrict who can interact with the bot. The authors are not responsible for any damage caused by misuse.
 
 ## Installation
 
@@ -57,6 +160,10 @@ Set these in `.env` or as system environment variables:
 ```text
 ANTHROPIC_API_KEY=sk-ant-...
 TELEGRAM_BOT_TOKEN=123456:ABC-DEF...
+GITHUB_TOKEN=ghp_...                           # optional, for GitHub tools
+JIRA_BASE_URL=https://yourcompany.atlassian.net # optional, for JIRA tools
+JIRA_EMAIL=you@company.com
+JIRA_API_TOKEN=your-jira-api-token
 ```
 
 ### `config.yaml` (optional)
@@ -77,11 +184,21 @@ telegram:
   allowed_users: [] # empty = allow all (dev mode)
   # allowed_users: [123456789]  # lock to specific Telegram user IDs
 
+jira:
+  base_url: https://yourcompany.atlassian.net
+  email: you@company.com
+  api_token: your-api-token
+
 security:
   blocked_paths: # paths the agent cannot touch
     - /etc/shadow
     - /etc/passwd
 
+claude_code:
+  max_turns: 50
+  timeout_seconds: 600
+  # model: claude-sonnet-4-20250514  # optional model override
+
 logging:
   level: info
   max_file_size: 5242880 # 5 MB
@@ -90,35 +207,81 @@ conversation:
   max_history: 50 # messages per chat
 ```
 
+## Telegram Commands
+
+| Command | Description |
+| --- | --- |
+| `/clean` | Clear conversation and start fresh |
+| `/history` | Show message count in memory |
+| `/help` | Show help message |
+
 ## Security
 
 - **User allowlist** — restrict bot access to specific Telegram user IDs. Empty list = dev mode (anyone can use it).
 - **Blocked paths** — files/directories the agent is forbidden from reading or writing (e.g., `/etc/shadow`, SSH keys).
+- **Dangerous operation confirmation** — destructive actions require user confirmation before execution.
+- **Browser URL blocklist** — internal/private network addresses are blocked from browsing.
 - **Audit logging** — every tool call is logged to `kernel-audit.log` with user, tool, params, result, and duration. Secrets in params are automatically redacted.
 - **Command timeout** — shell commands are killed after 30 seconds by default.
 
+## JIRA Integration
+
+KernelBot can read and search JIRA tickets. Supports both Atlassian Cloud (`*.atlassian.net`) and self-hosted JIRA Server instances.
+
+### Setup
+
+1. **Get an API token** — for Atlassian Cloud, generate one at [id.atlassian.net/manage-profile/security/api-tokens](https://id.atlassian.net/manage-profile/security/api-tokens). For JIRA Server, use your password or a personal access token.
+
+2. **Configure** via environment variables or `config.yaml`:
+
+```text
+JIRA_BASE_URL=https://yourcompany.atlassian.net
+JIRA_EMAIL=you@company.com
+JIRA_API_TOKEN=your-api-token
+```
+
+If credentials are missing when a JIRA tool is called, KernelBot will prompt for them via Telegram.
+
+### Available Tools
+
+- **`jira_get_ticket`** — Fetch a single ticket by key (e.g. `PROJ-123`). Returns summary, description, status, assignee, priority, and dates.
+- **`jira_search_tickets`** — Search using JQL (e.g. `project = PROJ AND status = "In Progress"`). Returns up to `max_results` tickets.
+- **`jira_list_my_tickets`** — List tickets assigned to the current user (or a specified assignee).
+- **`jira_get_project_tickets`** — List all tickets in a project, ordered by last update.
+
 ## Project Structure
 
 ```text
 KernelBot/
 ├── bin/
-│   └── kernel.js           # Entry point
+│   └── kernel.js              # Entry point + CLI menu
 ├── src/
-│   ├── agent.js            # Sonnet tool-use loop
-│   ├── bot.js              # Telegram bot (polling, auth, message handling)
-│   ├── conversation.js     # Per-chat conversation history
+│   ├── agent.js               # Claude tool-use loop
+│   ├── bot.js                 # Telegram bot (polling, auth, message handling)
+│   ├── coder.js               # Claude Code CLI spawner + smart output
+│   ├── conversation.js        # Per-chat conversation history
 │   ├── prompts/
-│   │   └── system.js       # System prompt
+│   │   └── system.js          # System prompt
 │   ├── security/
-│   │   ├── auth.js         # User allowlist
-│   │   └── audit.js        # Tool call audit logging
+│   │   ├── auth.js            # User allowlist
+│   │   ├── audit.js           # Tool call audit logging
+│   │   └── confirm.js         # Dangerous operation detection
 │   ├── tools/
-│   │   ├── os.js           # OS tool definitions + handlers
-│   │   └── index.js        # Tool registry + dispatcher
+│   │   ├── os.js              # File system + shell tools
+│   │   ├── git.js             # Git operations
+│   │   ├── github.js          # GitHub API (PRs, repos, reviews)
+│   │   ├── browser.js         # Web browsing (Puppeteer)
+│   │   ├── docker.js          # Docker management
+│   │   ├── process.js         # Process management
+│   │   ├── monitor.js         # System monitoring (CPU, RAM, disk)
+│   │   ├── network.js         # Network tools (HTTP, ports, nginx)
+│   │   ├── coding.js          # Claude Code CLI handler
+│   │   ├── jira.js            # JIRA ticket reading + search
+│   │   └── index.js           # Tool registry + dispatcher
 │   └── utils/
-│       ├── config.js       # Config loading (auto-detect + prompt)
-│       ├── display.js      # CLI display (logo, spinners, banners)
-│       └── logger.js       # Winston logger
+│       ├── config.js          # Config loading (auto-detect + prompt)
+│       ├── display.js         # CLI display (logo, spinners, banners)
+│       └── logger.js          # Winston logger
 ├── config.example.yaml
 ├── .env.example
 └── package.json
@@ -129,6 +292,14 @@ KernelBot/
 - Node.js 18+
 - [Anthropic API key](https://console.anthropic.com/)
 - [Telegram Bot Token](https://t.me/BotFather)
+- Chromium/Chrome (for browser tools — installed automatically by Puppeteer)
+- [GitHub Token](https://github.com/settings/tokens) (optional, for GitHub tools)
+- [JIRA API Token](https://id.atlassian.net/manage-profile/security/api-tokens) (optional, for JIRA integration)
+- [Claude Code CLI](https://www.npmjs.com/package/@anthropic-ai/claude-code) (optional, for coding tasks)
+
+## License
+
+MIT
 
 ## Author
 

package/config.example.yaml

@@ -20,6 +20,11 @@ github:
   default_branch: main
   # default_org: my-org
 
+jira:
+  # base_url: https://yourcompany.atlassian.net  # or self-hosted JIRA server URL
+  # email: you@company.com                       # JIRA account email (Cloud) or username (Server)
+  # api_token: your-api-token                    # API token from https://id.atlassian.net/manage-profile/security/api-tokens
+
 telegram:
   # List Telegram user IDs allowed to interact. Empty = allow all (dev mode).
   allowed_users: []

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kernelbot",
-  "version": "1.0.22",
+  "version": "1.0.24",
   "description": "KernelBot — AI engineering agent with full OS control",
   "type": "module",
   "author": "Abdullah Al-Taheri <abdullah@altaheri.me>",
@@ -24,7 +24,7 @@
   "bugs": {
     "url": "https://github.com/KernelCode/KernelBot/issues"
   },
-  "homepage": "https://github.com/KernelCode/KernelBot#readme",
+  "homepage": "https://kernelbot.io",
   "license": "MIT",
   "dependencies": {
     "@anthropic-ai/sdk": "^0.39.0",

package/src/tools/index.js

@@ -7,6 +7,7 @@ import { definitions as gitDefinitions, handlers as gitHandlers } from './git.js
 import { definitions as githubDefinitions, handlers as githubHandlers } from './github.js';
 import { definitions as codingDefinitions, handlers as codingHandlers } from './coding.js';
 import { definitions as browserDefinitions, handlers as browserHandlers } from './browser.js';
+import { definitions as jiraDefinitions, handlers as jiraHandlers } from './jira.js';
 import { logToolCall } from '../security/audit.js';
 import { requiresConfirmation } from '../security/confirm.js';
 
@@ -20,6 +21,7 @@ export const toolDefinitions = [
   ...githubDefinitions,
   ...codingDefinitions,
   ...browserDefinitions,
+  ...jiraDefinitions,
 ];
 
 const handlerMap = {
@@ -32,6 +34,7 @@ const handlerMap = {
   ...githubHandlers,
   ...codingHandlers,
   ...browserHandlers,
+  ...jiraHandlers,
 };
 
 export function checkConfirmation(name, params, config) {