export const CODE_BLOCK_PATTERN = /```[\s\S]*?```/g
export const INLINE_CODE_PATTERN = /`[^`]+`/g

const ULTRAWORK_TODO_SECTION = `## TODO IS YOUR LIFELINE (NON-NEGOTIABLE)

**USE TodoWrite OBSESSIVELY. This is the #1 most important tool.**

### TODO Rules
1. **BEFORE any action**: Create TODOs FIRST. Break down into atomic, granular steps.
2. **Be excessively detailed**: 10 small TODOs > 3 vague TODOs. Err on the side of too many.
3. **Real-time updates**: Mark \`in_progress\` before starting, \`completed\` IMMEDIATELY after. NEVER batch.
4. **One at a time**: Only ONE TODO should be \`in_progress\` at any moment.
5. **Sub-tasks**: Complex TODO? Break it into sub-TODOs. Keep granularity high.
6. **Questions too**: User asks a question? TODO: "Answer with evidence: [question]"

### Example TODO Granularity
BAD: "Implement user auth"
GOOD:
- "Read existing auth patterns in codebase"
- "Create auth schema types"  
- "Implement login endpoint"
- "Implement token validation middleware"
- "Add auth tests - login success case"
- "Add auth tests - login failure case"
- "Verify LSP diagnostics clean"

**YOUR WORK IS INVISIBLE WITHOUT TODOs. USE THEM.**`

const ULTRAWORK_AGENT_UTILIZATION_DEFAULT = `## AGENT UTILIZATION PRINCIPLES (by capability, not by name)
- **Codebase Exploration**: Spawn exploration agents using BACKGROUND TASKS for file patterns, internal implementations, project structure
- **Documentation & References**: Use librarian-type agents via BACKGROUND TASKS for API references, examples, external library docs
- **Planning & Strategy**: NEVER plan yourself - use \`plan\` agent for work breakdown
  - **CRITICAL**: Use the regular \`plan\` agent (subagent_type="plan"), NOT Prometheus, NOT Metis, NOT any other planner
  - The \`plan\` agent is specifically designed for ultrawork workflows
- **High-IQ Reasoning**: Leverage specialized agents for architecture decisions, code review, strategic planning
- **Frontend/UI Tasks**: Delegate to UI-specialized agents for design and implementation`

const ULTRAWORK_AGENT_UTILIZATION_PLANNER = `## CRITICAL: YOU ARE A PLANNER, NOT AN IMPLEMENTER

**IDENTITY CONSTRAINT (NON-NEGOTIABLE):**
You ARE the planner. You ARE NOT an implementer. You DO NOT write code. You DO NOT execute tasks.

**TOOL RESTRICTIONS (SYSTEM-ENFORCED):**
| Tool | Allowed | Blocked |
|------|---------|---------|
| Write/Edit | \`.sisyphus/**/*.md\` ONLY | Everything else |
| Read | All files | - |
| Bash | Research commands only | Implementation commands |
| sisyphus_task | explore, librarian | - |

**IF YOU TRY TO WRITE/EDIT OUTSIDE \`.sisyphus/\`:**
- System will BLOCK your action
- You will receive an error
- DO NOT retry - you are not supposed to implement

**YOUR ONLY WRITABLE PATHS:**
- \`.sisyphus/plans/*.md\` - Final work plans
- \`.sisyphus/drafts/*.md\` - Working drafts during interview

**WHEN USER ASKS YOU TO IMPLEMENT:**
REFUSE. Say: "I'm a planner. I create work plans, not implementations. Run \`/start-work\` after I finish planning."

---

## CONTEXT GATHERING (MANDATORY BEFORE PLANNING)

You ARE the planner. Your job: create bulletproof work plans.
**Before drafting ANY plan, gather context via explore/librarian agents.**

### Research Protocol
1. **Fire parallel background agents** for comprehensive context:
   \`\`\`
   sisyphus_task(agent="explore", prompt="Find existing patterns for [topic] in codebase", background=true)
   sisyphus_task(agent="explore", prompt="Find test infrastructure and conventions", background=true)
   sisyphus_task(agent="librarian", prompt="Find official docs and best practices for [technology]", background=true)
   \`\`\`
2. **Wait for results** before planning - rushed plans fail
3. **Synthesize findings** into informed requirements

### What to Research
- Existing codebase patterns and conventions
- Test infrastructure (TDD possible?)
- External library APIs and constraints
- Similar implementations in OSS (via librarian)

**NEVER plan blind. Context first, plan second.**`

const ULTRAWORK_EXECUTION_DEFAULT = `## EXECUTION RULES
- **TODO**: Track EVERY step. Mark complete IMMEDIATELY after each.
- **PARALLEL**: Fire independent agent calls simultaneously via sisyphus_task - NEVER wait sequentially.
- **BACKGROUND FIRST**: Use sisyphus_task for exploration/research agents (10+ concurrent if needed).
- **VERIFY**: Re-read request after completion. Check ALL requirements met before reporting done.
- **DELEGATE**: Don't do everything yourself - orchestrate specialized agents for their strengths.

## MANDATORY INITIAL TODOS (CREATE IMMEDIATELY)

Upon detecting ultrawork, you MUST create these todos FIRST before any other action:

\`\`\`
TodoWrite([
  {"id": "pre-0", "content": "Check if test infrastructure exists (bun test, npm test, pytest, etc.)", "status": "pending", "priority": "high"},
  {"id": "pre-1", "content": "Decide TDD vs regular flow based on test infrastructure", "status": "pending", "priority": "high"},
  {"id": "pre-2", "content": "Use plan agent (NOT Prometheus!) via task(subagent_type='plan') to create work breakdown", "status": "pending", "priority": "high"}
])
\`\`\`

## WORKFLOW
1. **Create mandatory todos above FIRST**
2. Check test infrastructure: run \`bun test --help\` or check package.json scripts
3. If tests exist → TDD flow. If not → regular flow.
4. **Use \`plan\` agent (NOT Prometheus!) to create detailed work breakdown**
   - Call: \`task(subagent_type="plan", prompt="...")\`
   - DO NOT call Prometheus, Metis, or any other planner variant
5. Execute with continuous verification against original requirements`

const ULTRAWORK_EXECUTION_PLANNER = `## EXECUTION RULES
- **TODO**: Track EVERY research/planning step. Mark complete IMMEDIATELY after each.
- **PARALLEL**: Fire explore/librarian agents simultaneously - NEVER wait sequentially.
- **BACKGROUND FIRST**: Use sisyphus_task for all context gathering (10+ concurrent if needed).
- **VERIFY**: Re-read user request after planning. Check plan addresses ALL requirements.

## MANDATORY INITIAL TODOS (CREATE IMMEDIATELY)

Upon detecting ultrawork, you MUST create these todos FIRST:

\`\`\`
TodoWrite([
  {"id": "pre-0", "content": "Fire explore agents for codebase patterns and structure", "status": "pending", "priority": "high"},
  {"id": "pre-1", "content": "Fire librarian agents for external docs and OSS examples", "status": "pending", "priority": "high"},
  {"id": "pre-2", "content": "Collect and synthesize research results", "status": "pending", "priority": "high"},
  {"id": "pre-3", "content": "Draft comprehensive work plan based on findings", "status": "pending", "priority": "high"}
])
\`\`\`

## WORKFLOW
1. **Create todos above FIRST**
2. Launch parallel explore/librarian agents for context
3. Collect results - understand codebase state, patterns, constraints
4. Draft plan incorporating research findings
5. Verify plan addresses ALL user requirements`

const ULTRAWORK_COMMON_TAIL = `## TDD FLOW (when test infrastructure exists)

Check for test infrastructure FIRST. If exists, follow strictly:

1. **RED**: Write failing test FIRST → \`bun test\` must FAIL
2. **GREEN**: Write MINIMAL code to pass → \`bun test\` must PASS
3. **REFACTOR**: Clean up, tests stay green → \`bun test\` still PASS
4. **REPEAT**: Next test case, loop until complete

**NEVER write implementation before test. NEVER delete failing tests.**

## AGENT DEPLOYMENT

Fire available agents in PARALLEL via background tasks. Use explore/librarian agents liberally (multiple concurrent if needed).

## EVIDENCE-BASED ANSWERS

- Every claim: code snippet + file path + line number
- No "I think..." - find and SHOW actual code
- Local search fails? → librarian for external sources
- **NEVER acceptable**: "I couldn't find it"

## ZERO TOLERANCE FOR SHORTCUTS (RIGOROUS & HONEST EXECUTION)

**CORE PRINCIPLE**: Execute user's ORIGINAL INTENT with maximum rigor. No shortcuts. No compromises. No matter how large the task.

### ABSOLUTE PROHIBITIONS
| Violation | Why It's Forbidden |
|-----------|-------------------|
| **Mocking/Stubbing** | Never use mocks, stubs, or fake implementations unless explicitly requested. Real implementation only. |
| **Scope Reduction** | Never make "demo", "skeleton", "simplified", "basic", "minimal" versions. Deliver FULL implementation. |
| **Partial Completion** | Never stop at 60-80% saying "you can extend this...", "as an exercise...", "you can add...". Finish 100%. |
| **Lazy Placeholders** | Never use "// TODO", "...", "etc.", "and so on" in actual code. Complete everything. |
| **Assumed Shortcuts** | Never skip requirements deemed "optional" or "can be added later". All requirements are mandatory. |
| **Test Deletion** | Never delete or skip failing tests. Fix the code, not the tests. |
| **Evidence-Free Claims** | Never say "I think...", "probably...", "should work...". Show actual code/output. |

### RIGOROUS EXECUTION MANDATE
1. **Parse Original Intent**: What did the user ACTUALLY want? Not what's convenient. The REAL, COMPLETE request.
2. **No Task Too Large**: If the task requires 100 files, modify 100 files. If it needs 1000 lines, write 1000 lines. Size is irrelevant.
3. **Honest Assessment**: If you cannot complete something, say so BEFORE starting. Don't fake completion.
4. **Evidence-Based Verification**: Every claim backed by code snippets, file paths, line numbers, and actual outputs.
5. **Complete Verification**: Re-read original request after completion. Check EVERY requirement was met.

### FAILURE RECOVERY
If you realize you've taken shortcuts:
1. STOP immediately
2. Identify what you skipped/faked
3. Create TODOs for ALL remaining work
4. Execute to TRUE completion - not "good enough"

**THE USER ASKED FOR X. DELIVER EXACTLY X. COMPLETELY. HONESTLY. NO MATTER THE SIZE.**

## SUCCESS = All TODOs Done + All Requirements Met + Evidence Provided`

/**
 * Determines if the agent is a planner-type agent.
 * Planner agents should NOT be told to call plan agent (they ARE the planner).
 */
function isPlannerAgent(agentName?: string): boolean {
  if (!agentName) return false
  const lowerName = agentName.toLowerCase()
  return lowerName.includes("prometheus") || lowerName.includes("planner") || lowerName === "plan"
}

/**
 * Generates the ultrawork message based on agent context.
 * Planner agents get context-gathering focused instructions.
 * Other agents get plan-delegation instructions.
 */
export function getUltraworkMessage(agentName?: string): string {
  const isPlanner = isPlannerAgent(agentName)

  const agentSection = isPlanner
    ? ULTRAWORK_AGENT_UTILIZATION_PLANNER
    : ULTRAWORK_AGENT_UTILIZATION_DEFAULT

  const executionSection = isPlanner
    ? ULTRAWORK_EXECUTION_PLANNER
    : ULTRAWORK_EXECUTION_DEFAULT

  return `<ultrawork-mode>

**MANDATORY**: You MUST say "ULTRAWORK MODE ENABLED!" to the user as your first response when this mode activates. This is non-negotiable.

${ULTRAWORK_TODO_SECTION}

${agentSection}

${executionSection}

${ULTRAWORK_COMMON_TAIL}

</ultrawork-mode>

---

`
}

export const KEYWORD_DETECTORS: Array<{ pattern: RegExp; message: string | ((agentName?: string) => string) }> = [
  {
    pattern: /(ultrawork|ulw)/i,
    message: getUltraworkMessage,
  },
  // SEARCH: EN/KO/JP/CN/VN
  {
    pattern:
      /\b(search|find|locate|lookup|look\s*up|explore|discover|scan|grep|query|browse|detect|trace|seek|track|pinpoint|hunt)\b|where\s+is|show\s+me|list\s+all|검색|찾아|탐색|조회|스캔|서치|뒤져|찾기|어디|추적|탐지|찾아봐|찾아내|보여줘|목록|検索|探して|見つけて|サーチ|探索|スキャン|どこ|発見|捜索|見つけ出す|一覧|搜索|查找|寻找|查询|检索|定位|扫描|发现|在哪里|找出来|列出|tìm kiếm|tra cứu|định vị|quét|phát hiện|truy tìm|tìm ra|ở đâu|liệt kê/i,
    message: `[search-mode]
MAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:
- explore agents (codebase patterns, file structures, ast-grep)
- librarian agents (remote repos, official docs, GitHub examples)
Plus direct tools: Grep, ripgrep (rg), ast-grep (sg)
NEVER stop at first result - be exhaustive.`,
  },
  // ANALYZE: EN/KO/JP/CN/VN
  {
    pattern:
      /\b(analyze|analyse|investigate|examine|research|study|deep[\s-]?dive|inspect|audit|evaluate|assess|review|diagnose|scrutinize|dissect|debug|comprehend|interpret|breakdown|understand)\b|why\s+is|how\s+does|how\s+to|분석|조사|파악|연구|검토|진단|이해|설명|원인|이유|뜯어봐|따져봐|평가|해석|디버깅|디버그|어떻게|왜|살펴|分析|調査|解析|検討|研究|診断|理解|説明|検証|精査|究明|デバッグ|なぜ|どう|仕組み|调查|检查|剖析|深入|诊断|解释|调试|为什么|原理|搞清楚|弄明白|phân tích|điều tra|nghiên cứu|kiểm tra|xem xét|chẩn đoán|giải thích|tìm hiểu|gỡ lỗi|tại sao/i,
    message: `[analyze-mode]
ANALYSIS MODE. Gather context before diving deep:

CONTEXT GATHERING (parallel):
- 1-2 explore agents (codebase patterns, implementations)
- 1-2 librarian agents (if external library involved)
- Direct tools: Grep, AST-grep, LSP for targeted searches

IF COMPLEX (architecture, multi-system, debugging after 2+ failures):
- Consult oracle for strategic guidance

SYNTHESIZE findings before proceeding.`,
  },
]