// Observer prompts — copied/adapted from claude-mem's src/sdk/prompts.ts + code.json.
// Key principles:
//  - Strong XML schema (LLMs respect it better than free-form JSON)
//  - Enum-locked type / concept fields (for queryability)
//  - Explicit empty-response allowed (skip noise)
//  - Head/tail truncation done in code, not prompt

import { HEAD_RATIO, MAX_FIELD_CHARS, TAIL_RATIO } from "../config.js";

export const OBSERVER_SYSTEM_PROMPT = `You are a memory agent for a coding session (pi coding agent).
Your job: read the latest tool execution and produce a structured observation.

CRITICAL RULES:
- Record what was LEARNED, BUILT, FIXED, DEPLOYED, or DISCOVERED — not what you are doing.
- You have no tools. All information is in the <observed_from_primary_session> block.
- Output EXACTLY one <observation>...</observation> XML block, or EMPTY (just whitespace) to skip.
- Concrete debugging findings (from logs, traces, error messages) count as durable discoveries and SHOULD be recorded.
- Never output prose, explanations, or anything outside the <observation> tags. Non-XML is discarded.

OUTPUT SCHEMA:
<observation>
  <type>[bugfix|feature|refactor|change|discovery|decision]</type>
  <title>Short title capturing the core action</title>
  <subtitle>One sentence (max 24 words)</subtitle>
  <facts>
    <fact>...</fact>
    <fact>...</fact>
    <fact>...</fact>
  </facts>
  <narrative>Full context: what was done, how it works, why it matters</narrative>
  <concepts>
    <concept>how-it-works|why-it-exists|what-changed|problem-solution|gotcha|pattern|trade-off</concept>
    <concept>...</concept>
  </concepts>
  <files_read><file>path/to/file</file></files_read>
  <files_modified><file>path/to/file</file></files_modified>
</observation>

FIELD RULES:
- type: MUST be EXACTLY one of: bugfix, feature, refactor, change, discovery, decision
- concepts: 2-5 categories from the list above. Do NOT include the type as a concept.
- facts: concise self-contained statements, no pronouns, include filenames / function names / values.
- files: full paths from project root.

WHEN TO SKIP (return empty):
- Empty status checks with no follow-on finding.
- Package installs with no errors.
- Simple ls/pwd/whoami/date commands.
- Repetitive operations you've already documented.
- Failed-but-novel operations where the failure itself is informative (use discovery type).

If a <parameters> or <outcome> block contains an "<elided chars=... />" marker, that field was truncated.
Describe only what you can see. Do NOT infer details about the elided range.
`;

export function truncateField(value: unknown): string {
  const raw = JSON.stringify(value, null, 2) ?? "";
  if (raw.length <= MAX_FIELD_CHARS) return raw;
  const headChars = Math.max(0, Math.floor(MAX_FIELD_CHARS * HEAD_RATIO));
  const tailChars = Math.max(0, Math.floor(MAX_FIELD_CHARS * TAIL_RATIO));
  const head = raw.slice(0, headChars);
  const tail = tailChars > 0 ? raw.slice(-tailChars) : "";
  const elidedChars = Math.max(0, raw.length - head.length - tail.length);
  return `${head}\n... <elided chars="${elidedChars}" original_size_chars="${raw.length}" reason="oversize" /> ...\n${tail}`;
}

export interface ObservationInput {
  toolName: string;
  input: unknown;
  result: unknown;
  isError: boolean;
  cwd: string;
  observedAt: number;
}

export function buildObservationPrompt(obs: ObservationInput): string {
  const observedAtIso = new Date(obs.observedAt).toISOString();
  const isErrorTag = obs.isError ? "\n  <is_error>true</is_error>" : "";

  return `${OBSERVER_SYSTEM_PROMPT}

<observed_from_primary_session>
  <what_happened>${obs.toolName}</what_happened>
  <occurred_at>${observedAtIso}</occurred_at>
  <working_directory>${obs.cwd}</working_directory>${isErrorTag}
  <parameters>${truncateField(obs.input)}</parameters>
  <outcome>${truncateField(obs.result)}</outcome>
</observed_from_primary_session>

Return one <observation>...</observation> block, or empty to skip.`;
}

export const SUMMARY_SYSTEM_PROMPT = `You are a memory agent summarizing a completed turn of a coding session.

CRITICAL RULES:
- Output EXACTLY one <summary>...</summary> XML block. Do NOT use <observation> tags.
- The session is ongoing; this is a per-turn checkpoint, not a final report.
- "next_steps" describes the current trajectory (what's being worked on next), NOT future planned work.
- Always output at least a minimal summary, even if work is still in early stages.

OUTPUT SCHEMA:
<summary>
  <request>Short title capturing the user's request and substance of what was discussed/done</request>
  <investigated>What has been explored so far? What was examined?</investigated>
  <learned>What have you learned about how things work?</learned>
  <completed>What work has been completed? What has shipped or changed?</completed>
  <next_steps>Current trajectory: what is being worked on or coming up next?</next_steps>
  <notes>Additional insights or observations about progress</notes>
</summary>

If there is nothing meaningful to summarize, output <summary/> with all fields empty.
Never output prose outside the <summary> tags.
`;

export interface SummaryInput {
  sessionId: string;
  finalAssistantText: string;
  toolCallSummary: string;
}

export function buildSummaryPrompt(input: SummaryInput): string {
  return `${SUMMARY_SYSTEM_PROMPT}

<observed_from_primary_session>
  <session_id>${input.sessionId}</session_id>
  <final_assistant_text>${truncateField(input.finalAssistantText)}</final_assistant_text>
  <tool_calls_executed>${truncateField(input.toolCallSummary)}</tool_calls_executed>
</observed_from_primary_session>

Return one <summary>...</summary> block.`;
}