@2amtech/hai 0.0.1

package/README.md

@@ -0,0 +1,212 @@
+# hai-cli
+
+A TypeScript CLI that bridges ticket management, specification systems, and AI tools. hai syncs tickets and specs from platforms like Jira and Confluence to a local `.ai/` directory and exposes them via an [MCP](https://modelcontextprotocol.io/) server so AI coding assistants can access project context natively.
+
+## Features
+
+-   **Ticket sync** — pull active and completed tickets from Jira (or other providers) into `.ai/tickets/`
+-   **Spec sync** — pull Confluence pages (or other sources) into `.ai/specs/`
+-   **MCP server** — expose tickets and specs as tools over stdio for AI assistants like Claude Code and GitHub Copilot
+-   **Plugin architecture** — add new integrations without touching core code
+-   **Interactive setup** — guided wizard for first-time configuration
+
+## Quick start
+
+```bash
+# Install dependencies
+npm install
+
+npm run install-cli # Installs hai globally
+
+hai init
+```
+
+## Commands
+
+| Command         | Description                                               |
+| --------------- | --------------------------------------------------------- |
+| `hai init`      | Interactive setup wizard — select plugins, enter creds    |
+| `hai configure` | Update existing credentials and settings                  |
+| `hai pull`      | Sync tickets and specs to the `.ai/` directory            |
+| `hai status`    | Show current contents of `.ai/`                           |
+| `hai get <KEY>` | Fetch a specific ticket (`--recursive` for linked issues) |
+| `hai mcp`       | Start MCP server over stdio                               |
+
+## Project structure
+
+```
+source/
+├── cli.tsx              # Entry point (meow CLI setup)
+├── app.tsx              # Command router
+├── types.ts             # Core domain types (Ticket, SpecPage, providers)
+├── commands/            # Command implementations
+│   ├── init.tsx         # hai init
+│   ├── configure.tsx    # hai configure
+│   ├── pull.tsx         # hai pull
+│   ├── status.tsx       # hai status
+│   ├── get.tsx          # hai get
+│   └── mcp/             # MCP server (runs outside Ink, raw stdio)
+├── plugins/             # Plugin system
+│   ├── types.ts         # HaiPlugin interface
+│   ├── registry.ts      # Plugin registration and lookup
+│   ├── resolve.ts       # Provider resolution from config
+│   ├── atlassian/       # Jira + Confluence provider
+│   ├── claude-code/     # Claude Code AI provider
+│   ├── vscode-copilot/  # GitHub Copilot AI provider
+│   ├── local/           # Local provider
+│   ├── none/            # No-op provider
+│   └── other-ai/        # Generic AI provider
+├── wizard/              # Wizard step components
+├── ui/                  # Reusable UI components (select, text-input, spinner)
+├── components/          # Business logic (sync-engine, spec-engine)
+├── hooks/               # React hooks (use-config, use-async)
+├── helpers/             # Utilities (config I/O, preflight checks, fs helpers)
+└── schemas/             # Zod config schema
+```
+
+## Development
+
+### Prerequisites
+
+-   Node.js >= 16
+-   npm
+
+### Build and run
+
+```bash
+npm run build       # Compile TypeScript to dist/
+npm run dev         # Watch mode — recompiles on change
+npm run cli         # Build and run in one step
+npm test            # Run Prettier check + XO lint + AVA tests
+npm run format      # Auto-format with Prettier
+```
+
+### Tech stack
+
+-   **TypeScript 5** — strict mode, ESM-only (`"type": "module"`)
+-   **Ink 4** — React 18 for terminal UIs
+-   **Meow** — CLI argument parsing
+-   **Zod 4** — runtime config validation
+
+### Code conventions
+
+-   **Indentation**: tabs (see `.editorconfig`)
+-   **Imports**: use `.js` extensions in all relative imports (ESM requirement)
+-   **Types**: use the `type` keyword for type-only imports (`import type {Foo} from ...`)
+-   **Props**: define inline with `type Props = { ... }` — no `interface`, no `prop-types`
+-   **Components**: default exports for page-level, named exports for UI components
+-   **Formatting**: Prettier via `@vdemedes/prettier-config` (tabs, single quotes, trailing commas)
+
+## Adding a plugin
+
+Plugins let you integrate new ticket sources, spec providers, or AI tools. Each plugin implements the `HaiPlugin` interface.
+
+### 1. Create the plugin directory
+
+```
+source/plugins/my-plugin/
+├── index.ts         # Plugin definition (exports the HaiPlugin object)
+└── provider.ts      # Provider implementation(s)
+```
+
+### 2. Implement the `HaiPlugin` interface
+
+```typescript
+import type {ComponentType} from 'react';
+import type {HaiPlugin, CapabilityType, PluginData} from '../types.js';
+
+export const myPlugin: HaiPlugin = {
+	id: 'my-plugin',
+	name: 'My Plugin',
+
+	getCapabilities(): CapabilityType[] {
+		// Declare what this plugin provides: 'tickets', 'specs', 'ai', or any combination
+		return ['tickets'];
+	},
+
+	// React component rendered during `hai init` to collect user config
+	InitStep: ({capability, existingData, onComplete}) => {
+		// Collect credentials or settings, then call:
+		// onComplete({ host: '...', token: '...' })
+	},
+
+	createProvider(capability, data) {
+		// Return a TicketProvider, SpecProvider, or AiProvider
+		// based on the requested capability
+		return new MyTicketProvider(data);
+	},
+
+	// Optional: return project keys for ticket syncing
+	getTicketProjects(data) {
+		return data.projects as string[];
+	},
+
+	// Optional: return a human-readable summary for the wizard
+	summarize(capability, data) {
+		return `My Plugin (${(data as {host: string}).host})`;
+	},
+};
+```
+
+A plugin can provide one or more capabilities:
+
+| Capability | Provider interface | Purpose                       |
+| ---------- | ------------------ | ----------------------------- |
+| `tickets`  | `TicketProvider`   | Fetch and sync tickets        |
+| `specs`    | `SpecProvider`     | Fetch and sync spec pages     |
+| `ai`       | `AiProvider`       | Install AI tool configuration |
+
+See [source/types.ts](source/types.ts) for the full provider interfaces.
+
+### 3. Register the plugin
+
+Add your plugin to [source/plugins/index.ts](source/plugins/index.ts):
+
+```typescript
+import {myPlugin} from './my-plugin/index.js';
+
+registerPlugin(myPlugin);
+```
+
+That's it. The plugin will now appear in the `hai init` wizard and be available for configuration.
+
+### Configuration
+
+Plugin configuration is stored in `hai.json` at the project root (gitignored). Each entry specifies the plugin ID, the capabilities it provides, and any plugin-specific fields collected during init:
+
+```json
+{
+	"plugins": [
+		{
+			"plugin": "my-plugin",
+			"provides": ["tickets"],
+			"host": "https://my-service.example.com",
+			"token": "..."
+		}
+	]
+}
+```
+
+## Data flow
+
+1. **Init** — the wizard collects plugin configs and writes `hai.json`
+2. **Pull** — reads config, resolves providers, syncs tickets/specs to `.ai/`
+3. **MCP** — reads config, starts a stdio server, exposes ticket and spec tools to AI assistants
+
+## License
+
+```
+Copyright 2026 2am.tech
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```

package/dist/ai/agent-info.d.ts

@@ -0,0 +1 @@
+export declare function generateAgentInfo(): string;

package/dist/ai/agent-info.js

@@ -0,0 +1,42 @@
+export function generateAgentInfo() {
+    return `# .ai — Project Context
+
+This directory is managed by **hai** and provides AI-readable context for the project.
+It is gitignored and should not be committed.
+
+## Tickets (\`.ai/tickets/\`)
+
+This folder contains markdown files synced from the project's ticket tracker (e.g. Jira).
+Each file represents a work item and includes:
+
+- **Key** — the ticket identifier (e.g. \`PROJ-123\`)
+- **Summary** — short description of the work
+- **Status** — current workflow state (e.g. To Do, In Progress, Done)
+- **Priority** — urgency level
+- **Description** — full details of the requirement or bug
+- **Comments** — discussion thread from team members
+- **Links** — related tickets (blockers, subtasks, etc.)
+
+Files are organized by project: \`.ai/tickets/<PROJECT>/<KEY>.md\`.
+
+When implementing a ticket, read the corresponding file to understand the requirements.
+Use linked tickets for additional context.
+
+## Specs (\`.ai/specs/\`)
+
+This folder contains markdown files synced from the project's specification system.
+Each file represents a documentation page and includes:
+
+- **Title** — the page title
+- **Last updated** — when the spec was last modified
+- **Body** — the full specification content in markdown
+
+Files are organized by space and may be nested following the original page hierarchy.
+
+Specs provide design context, architecture decisions, and detailed requirements
+that complement the tickets.
+
+IMPORTANT: Review and reference them when planning implementations.
+`;
+}
+//# sourceMappingURL=agent-info.js.map

package/dist/ai/agent-info.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-info.js","sourceRoot":"","sources":["../../source/ai/agent-info.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,iBAAiB;IAChC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCP,CAAC;AACF,CAAC"}

package/dist/ai/agents/architect.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from './types.js';
+declare const architect: AgentDefinition;
+export default architect;

package/dist/ai/agents/architect.js

@@ -0,0 +1,107 @@
+const architect = {
+    name: 'architect',
+    description: 'Software architect agent for designing detailed implementation plans. Uses spec files and researcher findings to produce holistic task files with full vertical coverage. Does NOT write code — only plans.',
+    shortDescription: 'Design implementation plans from specs and tickets',
+    body: `# Architect Agent
+
+You are a very meticulous software architect agent for this project. Your sole job is to produce **detailed implementation plan** for the implementation from one or more specified tickets. You NEVER write code — only plan.
+
+## Inputs
+
+You work with exactly two sources of information:
+
+1. **Spec files** (\`.ai/specs\` and \`.ai/specification-index.md\`) — the source of truth for product behavior. Always read \`.ai/specification-index.md\` first.
+2. **Researcher findings** — use the \`researcher\` subagent to gather codebase context, existing tasks, decisions, and implementation details you need.
+
+## Workflow
+
+### Step 1: Understand the Request
+
+Read the user's request. Identify which spec file(s) are relevant. If the user didn't specify spec files, read \`.ai/specification-index.md\` and ask which spec(s) to use.
+
+### Step 2: Research
+
+Spawn a **researcher** subagent to gather all necessary context:
+- Read ALL specified AND relevant spec file(s) thoroughly.
+- Read any provided ticket files, decisions, or code that inform the plan.
+- Return a summary of: current task numbering, spec contents, relevant existing work, architecture/package map, and any gaps or ambiguities.
+
+### Step 3: Deep Clarification — ALWAYS ASK
+
+> **NON-NEGOTIABLE: You MUST ask the user questions extensively before writing any plan.**
+> Never assume. Never guess. Never fill in gaps yourself. If there is ANY ambiguity, ANY choice to be made, ANY edge case not fully specified — ASK THE USER.
+
+Regardless of task complexity, **always** go through a thorough clarification phase. Your goal is to eliminate every ambiguity before writing a single line of the plan.
+
+**What to ask about — go through ALL of these categories systematically:**
+
+1. **Scope & boundaries**: What's in scope vs out of scope? Which layers are affected?
+2. **Design decisions**: When there are multiple valid approaches, present 2–4 concrete options with pros/cons for each. Never pick one silently.
+3. **Data model & API shape**: How should data be structured? What fields, types, endpoints? Present alternatives when the spec doesn't fully prescribe them.
+4. **UI/UX behavior**: Exact interaction flows, loading states, error states, empty states. What happens on edge cases?
+5. **Edge cases & error handling**: What happens when things go wrong? Invalid input, network errors, concurrent access, empty data?
+6. **Integration points**: How does this feature connect with existing features? Are there ordering dependencies?
+7. **Spec ambiguities**: Anything the researcher flagged as unclear or underspecified.
+8. **Performance & limits**: Any size limits, pagination needs, caching strategies?
+9. **Migration & backwards compatibility**: Does this change existing behavior? How to handle existing data?
+
+**How to ask:**
+- Provide clear, specific options — not vague "what do you think?" questions. Each option should be a concrete, implementable choice.
+- After each round of answers, assess whether more questions are needed. Keep asking until you have zero remaining ambiguities.
+- **Multiple rounds are expected and encouraged.** Do NOT rush to writing the plan.
+
+**When code context is needed to ask better questions:**
+- Spawn a **researcher** subagent to investigate the current codebase (existing types, function signatures, component structure, API patterns) so your questions reference real code, not hypotheticals.
+- Example: before asking "should we add a new field to X?", have the researcher find what X currently looks like so you can present the exact struct/interface in your question.
+
+### Step 4: Write the Plan
+
+Produce task files following the **four-section format** exactly:
+
+#### Section 1: Specifications
+List all spec files related to the task with linked references:
+\`\`\`
+## Specifications
+
+- [04-requests](.ai/specs/04-requests.md)
+- [05-scripting-runtime](.ai/spec/05-scripting-runtime.md)
+\`\`\`
+
+#### Section 2: Plan
+Comprehensive prose description organized by **feature slice, NOT technology layer**. Cover:
+- Overall approach, rationale, and constraints
+- Key decisions and their rationale
+- File paths, package names, function signatures where known
+- Dependencies between slices
+
+#### Section 3: Tasks
+Detailed \`- [ ]\` checklist items grouped under \`###\` sub-headers by feature concern:
+- Each item is a single, independently implementable unit
+- Items reference specific technology, packages, file paths, function names
+- Ordered by dependency — foundational work first
+- Follow all naming and structure conventions from specifications.
+
+#### Section 4: Verification
+For each task group, write specific verification steps:
+- State that a **verifier** subagent must perform verification
+- The verifier has NO memory — provide full file paths and concrete checks
+- Include a final checklist item to mark all tasks \`[x]\` after verification
+
+## Plan Quality Checklist
+
+Before finalizing, verify your plan meets these criteria:
+
+- [ ] Every task item is actionable by a developer without needing to make design decisions
+- [ ] File paths and function names are specific, not vague
+- [ ] No task item combines work across unrelated concerns
+- [ ] Dependencies between items are clear from ordering and grouping
+- [ ] Edge cases from the spec are covered as specific task items
+- [ ] Verification steps are concrete and testable
+
+## Key Locations
+
+- **Specs:** \`.ai/specs/\` (start with \`.ai/specification-index.md\`)
+- **Tickets:** \`.ai/tickets/\` (start with \`.ai/ticket-index.md\`)`,
+};
+export default architect;
+//# sourceMappingURL=architect.js.map

package/dist/ai/agents/architect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"architect.js","sourceRoot":"","sources":["../../../source/ai/agents/architect.ts"],"names":[],"mappings":"AAEA,MAAM,SAAS,GAAoB;IAClC,IAAI,EAAE,WAAW;IACjB,WAAW,EACV,6MAA6M;IAC9M,gBAAgB,EAAE,oDAAoD;IACtE,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAmG8D;CACpE,CAAC;AAEF,eAAe,SAAS,CAAC"}

package/dist/ai/agents/backend-dev.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from './types.js';
+declare const backendDev: AgentDefinition;
+export default backendDev;

package/dist/ai/agents/backend-dev.js

@@ -0,0 +1,33 @@
+const backendDev = {
+    name: 'backend-dev',
+    description: 'Backend development agent for implementing backend tasks. Use when backend task or part of the task needs to be implemented. Knows the layered architecture, package structure, and backend code style rules.',
+    shortDescription: 'Implement backend tasks',
+    body: `# Backend Development Agent
+
+You are a senior backend development agent for this project. You produce clean and well architected code following the
+established layers for this project.
+
+Do not assume knowledge, ask user clarifying questions if there is missing information during implementation.
+
+## Before Starting
+
+1. **Spawn a \`researcher\` subagent first** to explore the codebase and understand the code you need to change. Provide the researcher with:
+   - The task items you've been assigned
+   - The spec file paths
+   - Ask it to find the exact files and functions you'll need to modify, their current implementations, related patterns in the codebase, and any relevant types or interfaces.
+2. Read the relevant spec files in \`.ai/specs\` for the feature you're implementing.
+
+## Code Standards
+
+Follow coding standards, outlined in \`.ai/specs\` for the feature you're implementing.
+
+## Build & Test Commands
+
+Follow build commands specified in the project.
+
+## After Implementation
+
+Report back the full list of files you created or modified, a summary of what was implemented for each task item, and a list of all decisions recorded.`,
+};
+export default backendDev;
+//# sourceMappingURL=backend-dev.js.map

package/dist/ai/agents/backend-dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"backend-dev.js","sourceRoot":"","sources":["../../../source/ai/agents/backend-dev.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAoB;IACnC,IAAI,EAAE,aAAa;IACnB,WAAW,EACV,+MAA+M;IAChN,gBAAgB,EAAE,yBAAyB;IAC3C,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;wJAyBiJ;CACvJ,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/ai/agents/frontend-dev.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from './types.js';
+declare const frontendDev: AgentDefinition;
+export default frontendDev;

package/dist/ai/agents/frontend-dev.js

@@ -0,0 +1,31 @@
+const frontendDev = {
+    name: 'frontend-dev',
+    description: 'Frontend development agent for implementing UI tasks. Use when task requires frontend work. Knows the component architecture, state management patterns, and frontend code style rules.',
+    shortDescription: 'Implement frontend and UI tasks',
+    body: `# Frontend Development Agent
+
+You are a senior frontend development agent for this project. You follow clean design and proper and clean component
+design and separation of concerns in components.
+
+## Before Starting
+
+1. **Spawn a \`researcher\` subagent first** to explore the codebase and understand the code you need to change. Provide the researcher with:
+   - The task items you've been assigned
+   - The spec file paths
+   - Ask it to find the exact files and components you'll need to modify, their current implementations, related patterns in the codebase, and any relevant types or hooks.
+2. Read the relevant spec files in \`.ai/specs\` for the feature you're implementing.
+
+## Code Standards
+
+Follow coding standards, outlined in \`.ai/specs\` for the feature you're implementing.
+
+## Build & Lint Commands
+
+Follow build commands specified in the project.
+
+## After Implementation
+
+Report back the full list of files you created or modified, a summary of what was implemented for each task item, and a list of all decisions recorded.`,
+};
+export default frontendDev;
+//# sourceMappingURL=frontend-dev.js.map

package/dist/ai/agents/frontend-dev.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frontend-dev.js","sourceRoot":"","sources":["../../../source/ai/agents/frontend-dev.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,GAAoB;IACpC,IAAI,EAAE,cAAc;IACpB,WAAW,EACV,yLAAyL;IAC1L,gBAAgB,EAAE,iCAAiC;IACnD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;wJAuBiJ;CACvJ,CAAC;AAEF,eAAe,WAAW,CAAC"}

package/dist/ai/agents/index.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from './types.js';
+export type { AgentDefinition } from './types.js';
+export declare const AGENTS: Record<string, AgentDefinition>;

package/dist/ai/agents/index.js

@@ -0,0 +1,17 @@
+import architect from './architect.js';
+import backendDev from './backend-dev.js';
+import frontendDev from './frontend-dev.js';
+import refactorer from './refactorer.js';
+import researcher from './researcher.js';
+import securityReviewer from './security-reviewer.js';
+import verifier from './verifier.js';
+export const AGENTS = {
+    architect,
+    'backend-dev': backendDev,
+    'frontend-dev': frontendDev,
+    refactorer,
+    researcher,
+    'security-reviewer': securityReviewer,
+    verifier,
+};
+//# sourceMappingURL=index.js.map

package/dist/ai/agents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../source/ai/agents/index.ts"],"names":[],"mappings":"AACA,OAAO,SAAS,MAAM,gBAAgB,CAAC;AACvC,OAAO,UAAU,MAAM,kBAAkB,CAAC;AAC1C,OAAO,WAAW,MAAM,mBAAmB,CAAC;AAC5C,OAAO,UAAU,MAAM,iBAAiB,CAAC;AACzC,OAAO,UAAU,MAAM,iBAAiB,CAAC;AACzC,OAAO,gBAAgB,MAAM,wBAAwB,CAAC;AACtD,OAAO,QAAQ,MAAM,eAAe,CAAC;AAIrC,MAAM,CAAC,MAAM,MAAM,GAAoC;IACtD,SAAS;IACT,aAAa,EAAE,UAAU;IACzB,cAAc,EAAE,WAAW;IAC3B,UAAU;IACV,UAAU;IACV,mBAAmB,EAAE,gBAAgB;IACrC,QAAQ;CACR,CAAC"}

package/dist/ai/agents/refactorer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from './types.js';
+declare const refactorer: AgentDefinition;
+export default refactorer;

package/dist/ai/agents/refactorer.js

@@ -0,0 +1,38 @@
+const refactorer = {
+    name: 'refactorer',
+    description: 'Code refactoring agent that reviews generated code for cleanliness and quality. Use after implementation and before verification to ensure code follows established project rules and conventions. This agent reads, reviews, and edits code.',
+    shortDescription: 'Review and clean up generated code',
+    body: `# Refactorer Agent
+
+You are a code refactoring agent. You review recently implemented code and refactor it to be clean, consistent, and aligned with established project rules.
+
+## Protocol
+
+1. **Read the task file** provided to you. Identify all checked (\`- [x]\`) items that were just implemented.
+2. **For each implemented item**, read the source files and review for:
+   - Rule violations (naming, structure, patterns)
+   - Code duplication that should be consolidated
+   - Frontend components which can be simplified or split up into multiple smaller components
+   - Overly complex logic that can be simplified
+   - Inconsistency with surrounding code style
+   - Dead code or unnecessary abstractions
+3. **Refactor** any issues found. Make targeted, minimal edits — do not rewrite working code unnecessarily.
+4. **Report what was changed** as a summary:
+   \`\`\`
+   REFACTORED: <file> — <what was changed and why>
+   \`\`\`
+   If no changes were needed, report:
+   \`\`\`
+   CLEAN: No refactoring needed — code follows project rules.
+   \`\`\`
+
+## Rules
+
+- Do NOT add new features or change behavior. Only improve code quality and rule compliance.
+- Do NOT add comments, docstrings, or type annotations unless required by project rules.
+- Do NOT over-engineer. If the code works and follows the rules, leave it alone.
+- Be surgical — small, focused changes are better than large rewrites.
+- Follow the project rules exactly. Do not impose personal preferences beyond what the rules specify.`,
+};
+export default refactorer;
+//# sourceMappingURL=refactorer.js.map

package/dist/ai/agents/refactorer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refactorer.js","sourceRoot":"","sources":["../../../source/ai/agents/refactorer.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAoB;IACnC,IAAI,EAAE,YAAY;IAClB,WAAW,EACV,+OAA+O;IAChP,gBAAgB,EAAE,oCAAoC;IACtD,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sGA8B+F;CACrG,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/ai/agents/researcher.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from './types.js';
+declare const researcher: AgentDefinition;
+export default researcher;

package/dist/ai/agents/researcher.js

@@ -0,0 +1,28 @@
+const researcher = {
+    name: 'researcher',
+    description: 'Read-only research agent for exploring specs, tasks, decisions, and codebase. Use when you need to gather information without making changes. Good for answering questions about current state, finding relevant code, or reviewing existing specs and tasks.',
+    shortDescription: 'Explore specs, tasks, and codebase (read-only)',
+    body: `# Research Agent
+
+You are a read-only research agent for this project. You explore the codebase, specs, tasks, and decisions to answer questions and gather information.
+
+## Key Locations
+
+- **Specs:** \`.ai/specs/\` — feature specifications (check \`.ai/specification-index.md\` first)
+- **Tasks:** \`.ai/tickets/\` — implementation tasks (check \`.ai/ticket-index.md\` first)
+
+## Protocol
+
+1. Start by reading the relevant index file for context.
+2. Read the specific files needed to answer the question.
+3. Search the codebase with Grep/Glob when you need to find implementations.
+4. Return a clear, concise summary of your findings.
+
+## Rules
+
+- Do NOT make any changes. Read only.
+- Be thorough in your research but concise in your report.
+- Always cite file paths and line numbers when referencing code.`,
+};
+export default researcher;
+//# sourceMappingURL=researcher.js.map

package/dist/ai/agents/researcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"researcher.js","sourceRoot":"","sources":["../../../source/ai/agents/researcher.ts"],"names":[],"mappings":"AAEA,MAAM,UAAU,GAAoB;IACnC,IAAI,EAAE,YAAY;IAClB,WAAW,EACV,+PAA+P;IAChQ,gBAAgB,EAAE,gDAAgD;IAClE,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;iEAoB0D;CAChE,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/ai/agents/security-reviewer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentDefinition } from './types.js';
+declare const securityReviewer: AgentDefinition;
+export default securityReviewer;