import { analyze } from "research.actor"

const result = await analyze()

console.log(result.analysis)   // the full codebase analysis text
console.log(result.fromCache)  // true if served from cache
console.log(result.gitHash)    // the commit the analysis is keyed to
console.log(result.runner)     // name of the runner that produced it

const result = await analyze({
  prompt: "what does the authentication flow look like?",
})

import { analyze, FsStore } from "research.actor"

const result = await analyze({
  store: new FsStore(),
})

const store = new FsStore("/var/cache/myapp/research")
const result = await analyze({ store })

const store = new FsStore()

// first call — may hit disk or run the harness
await analyze({ store })

// second call in same process — hits the in-memory layer first
await analyze({ store })

import { analyze } from "research.actor"
import type { CacheStore, CacheKey, AnalysisCache } from "research.actor"

class PostgresStore implements CacheStore {
  async get(key: CacheKey): Promise<AnalysisCache | null> {
    const row = await db.query(
      "SELECT data FROM analyses WHERE project=$1 AND hash=$2 AND prompt_hash=$3",
      [key.projectKey, key.gitHash, key.systemPromptHash ?? null],
    )
    return row ?? null
  }

  async set(key: CacheKey, entry: AnalysisCache): Promise<void> {
    await db.query(
      "INSERT INTO analyses (project, hash, prompt_hash, data) VALUES ($1,$2,$3,$4) ON CONFLICT DO UPDATE SET data=$4",
      [key.projectKey, key.gitHash, key.systemPromptHash ?? null, entry],
    )
  }

  async delete(key: CacheKey): Promise<void> {
    await db.query(
      "DELETE FROM analyses WHERE project=$1 AND hash=$2 AND prompt_hash=$3",
      [key.projectKey, key.gitHash, key.systemPromptHash ?? null],
    )
  }
}

const result = await analyze({ store: new PostgresStore() })

import { analyze } from "research.actor"
import type { HarnessRunner, RunRequest, RunResult } from "research.actor"

// Example: in-process agent (e.g. pi, or your own)
class MyAgentRunner implements HarnessRunner {
  readonly name = "my-agent"

  async run(req: RunRequest): Promise<RunResult> {
    const output = await myAgent.query(req.prompt, {
      workingDir: req.cwd,
      model: req.model,
    })
    return { output }
  }
}

const result = await analyze({
  runner: new MyAgentRunner(),
  store: new FsStore(),
})

class MockRunner implements HarnessRunner {
  readonly name = "mock"
  async run(_req: RunRequest): Promise<RunResult> {
    return { output: "src/ contains the main app. index.ts is the entry point." }
  }
}

const result = await analyze({ runner: new MockRunner() })
// result.fromCache === false, result.runner === "mock"

import { SubprocessRunner, resolveHarness } from "research.actor"
import type { HarnessRunner, RunRequest, RunResult } from "research.actor"

class LoggingRunner implements HarnessRunner {
  private readonly inner: SubprocessRunner

  constructor(inner: SubprocessRunner) {
    this.inner = inner
  }

  get name() { return this.inner.name }

  async run(req: RunRequest): Promise<RunResult> {
    console.log(`[research] running ${this.name} in ${req.cwd}`)
    const result = await this.inner.run(req)
    console.log(`[research] got ${result.output.length} chars`)
    return result
  }
}

const harness = await resolveHarness("claude")
const runner = new LoggingRunner(new SubprocessRunner(harness))
await analyze({ runner, store: new FsStore() })

import { analyze, FsStore } from "research.actor"

// Re-run if cached analysis is older than 24 hours
await analyze({
  store: new FsStore(),
  maxAge: 24 * 60 * 60 * 1000,
})

// Re-run if older than 30 minutes
await analyze({
  store: new FsStore(),
  maxAge: 30 * 60 * 1000,
})

import { analyze, FsStore, CachelyzError, HarnessNotFoundError, GitError } from "research.actor"

try {
  await analyze({ store: new FsStore() })
} catch (err) {
  if (err instanceof HarnessNotFoundError) {
    // No supported harness binary found in PATH
    console.error("Install a harness: opencode, claude, codex, aider, or gemini")
  } else if (err instanceof GitError) {
    // Not a git repo, or git is not installed
    console.error("research must be run inside a git repository")
  } else if (err instanceof CachelyzError) {
    // Any other research error
    console.error(err.message, err.cause)
  } else {
    throw err
  }
}

interface AnalyzeOptions {
  harness?:      HarnessName      // subprocess harness to use (auto-detected if omitted)
  model?:        string           // model name forwarded to the runner
  systemPrompt?: string           // appended to the cached analysis prompt
  prompt?:       string           // passed only to the working-changes agent, never cached
  cwd?:          string           // working directory (defaults to process.cwd())
  force?:        boolean          // bypass cache entirely
  maxAge?:       number           // ms — treat cache entries older than this as stale
  store?:        CacheStore       // storage backend (defaults to MemoryStore)
  runner?:       HarnessRunner    // execution backend (defaults to SubprocessRunner)
}

interface AnalyzeResult {
  analysis:   string   // full analysis text
  fromCache:  boolean  // true if base analysis was served from cache
  gitHash:    string   // commit hash the analysis is keyed to
  projectKey: string   // stable repo identifier used in cache keys
  runner:     string   // name of the runner that produced the base analysis
}

new FsStore(baseDir?: string)

const store = new MemoryStore()
store.size   // number of entries currently held
store.clear() // remove all entries

import { SubprocessRunner, resolveHarness } from "research.actor"

const harness = await resolveHarness("claude")
const runner = new SubprocessRunner(harness)

import { FsStore, deriveProjectKey, getRepoRoot } from "research.actor"

const repoRoot = await getRepoRoot(process.cwd())
const projectKey = deriveProjectKey(repoRoot)
const store = new FsStore()
const deleted = await store.clearProject(projectKey)
console.log(`Deleted ${deleted} cache entries`)

interface HarnessRunner {
  name: string
  run(req: RunRequest): Promise<RunResult>
}

interface RunRequest {
  prompt: string
  cwd:    string
  model?: string
}

interface RunResult {
  output: string
}

interface CacheStore {
  get(key: CacheKey):                       Promise<AnalysisCache | null>
  set(key: CacheKey, entry: AnalysisCache): Promise<void>
  delete(key: CacheKey):                    Promise<void>
}

interface CacheKey {
  projectKey:       string
  gitHash:          string
  systemPromptHash?: string
}