pi-obsidian-memory 0.0.1 → 0.1.1

package/src/services/search-index/storage.ts

@@ -0,0 +1,207 @@
+import type { DatabaseSync } from "node:sqlite"
+
+import type { CatalogChanges, VectorReplacement } from "#src/domain"
+import { readCatalogHits } from "./catalog-query.ts"
+import { prepareCatalogStatements } from "./catalog-statements.ts"
+import { closeFailedIndex } from "./cleanup.ts"
+import { prepareFolderIndexStatements } from "./folder-index-statements.ts"
+import { readStoredFolderIndexes, writeFolderIndexStates } from "./folder-index-storage.ts"
+import { readInventory } from "./inventory.ts"
+import { putLegacyEntry, removeLegacyEntry } from "./legacy.ts"
+import { readSearchHits } from "./query.ts"
+import { writeCatalog } from "./reconcile.ts"
+import { closedIndex, indexFailure } from "./refusals.ts"
+import { prepareStatements } from "./statements.ts"
+import type {
+  CatalogQuery,
+  CatalogSearchResult,
+  FolderIndexState,
+  FolderIndexStatesResult,
+  IndexEntry,
+  IndexWork,
+  IndexWriteResult,
+  InventoryResult,
+  SearchIndex,
+  SearchIndexRefusal,
+  SearchOptions,
+  SearchResult,
+  VectorCacheResult,
+  VectorCoverageResult,
+  VectorUpdate,
+} from "./types.ts"
+import { prepareVectorStatements } from "./vector-statements.ts"
+import { readVectorCoverage, readVectors, updateVectors, writeVectors } from "./vector-storage.ts"
+
+export class SqliteSearchIndex implements SearchIndex {
+  readonly #database: DatabaseSync
+  readonly #statements: ReturnType<typeof prepareStatements>
+  readonly #catalog: ReturnType<typeof prepareCatalogStatements>
+  readonly #vectors: ReturnType<typeof prepareVectorStatements>
+  readonly #folderIndexes: ReturnType<typeof prepareFolderIndexStatements>
+  #usable = true
+
+  constructor(database: DatabaseSync) {
+    this.#database = database
+    this.#statements = prepareStatements(database)
+    this.#catalog = prepareCatalogStatements(database)
+    this.#vectors = prepareVectorStatements(database)
+    this.#folderIndexes = prepareFolderIndexStatements(database)
+  }
+
+  put(entry: IndexEntry): IndexWriteResult {
+    return this.#write(() => putLegacyEntry(this.#statements, this.#catalog, entry))
+  }
+
+  remove(id: string): IndexWriteResult {
+    return this.#write(() => removeLegacyEntry(this.#statements, this.#catalog, id))
+  }
+
+  apply(changes: CatalogChanges): IndexWriteResult {
+    return this.#write(() => writeCatalog(this.#catalog, changes))
+  }
+
+  replaceVectors(request: VectorReplacement): IndexWriteResult {
+    return this.#write(() => writeVectors(this.#vectors, this.#catalog, request))
+  }
+
+  updateVectors(request: VectorUpdate): IndexWriteResult {
+    return this.#write(() => updateVectors(this.#vectors, this.#catalog, request))
+  }
+
+  vectorCoverage(): VectorCoverageResult {
+    if (!this.#usable || !this.#database.isOpen) return closedIndex()
+
+    try {
+      this.#database.exec("BEGIN")
+      const result = readVectorCoverage(this.#vectors)
+      this.#database.exec("COMMIT")
+      return result
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      return this.#rollBack(indexFailure(error))
+    }
+  }
+
+  recordFolderIndexes(states: FolderIndexState[], keepFolders: string[]): IndexWriteResult {
+    return this.#write(() => writeFolderIndexStates(this.#folderIndexes, states, keepFolders))
+  }
+
+  folderIndexes(): FolderIndexStatesResult {
+    if (!this.#usable || !this.#database.isOpen) return closedIndex()
+
+    try {
+      this.#database.exec("BEGIN")
+      const result = readStoredFolderIndexes(this.#folderIndexes)
+      this.#database.exec("COMMIT")
+      return result
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      return this.#rollBack(indexFailure(error))
+    }
+  }
+
+  inventory(): InventoryResult {
+    if (!this.#usable || !this.#database.isOpen) return closedIndex()
+
+    try {
+      this.#database.exec("BEGIN")
+      const result = readInventory(this.#catalog)
+      this.#database.exec("COMMIT")
+      return result
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      return this.#rollBack(indexFailure(error))
+    }
+  }
+
+  vectors(): VectorCacheResult {
+    if (!this.#usable || !this.#database.isOpen) return closedIndex()
+
+    try {
+      this.#database.exec("BEGIN")
+      const result = readVectors(this.#vectors)
+      this.#database.exec("COMMIT")
+      return result
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      if (error instanceof SyntaxError) {
+        return this.#rollBack({ succeeded: false, reason: "corrupted", problems: ["invalid cached vector JSON"] })
+      }
+      return this.#rollBack(indexFailure(error))
+    }
+  }
+
+  searchCatalog(request: CatalogQuery): CatalogSearchResult {
+    if (!this.#usable || !this.#database.isOpen) return closedIndex()
+
+    try {
+      return readCatalogHits(this.#catalog.search, request)
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      return indexFailure(error)
+    }
+  }
+
+  search(query: string, options: SearchOptions): SearchResult {
+    if (!this.#usable || !this.#database.isOpen) return closedIndex()
+
+    try {
+      return readSearchHits(this.#statements.search, query, options)
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      return indexFailure(error)
+    }
+  }
+
+  close(): IndexWriteResult {
+    if (!this.#database.isOpen) return { succeeded: true }
+
+    try {
+      this.#database.close()
+      return { succeeded: true }
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      return indexFailure(error)
+    }
+  }
+
+  #write(work: IndexWork): IndexWriteResult {
+    if (!this.#usable || !this.#database.isOpen) return closedIndex()
+
+    try {
+      this.#database.exec("BEGIN IMMEDIATE")
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      return indexFailure(error)
+    }
+
+    return this.#commit(work)
+  }
+
+  #commit(work: IndexWork): IndexWriteResult {
+    try {
+      const result = work()
+      if (!result.succeeded) return this.#rollBack(result)
+
+      this.#database.exec("COMMIT")
+      return result
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      return this.#rollBack(indexFailure(error))
+    }
+  }
+
+  #rollBack(failure: SearchIndexRefusal): SearchIndexRefusal {
+    if (!this.#database.isTransaction) return failure
+
+    try {
+      this.#database.exec("ROLLBACK")
+    } catch (error) {
+      if (!(error instanceof Error)) throw error
+      this.#usable = false
+      failure.problems.push(`write rollback failed: ${error.message}`)
+      return closeFailedIndex(this.#database, failure)
+    }
+    return failure
+  }
+}

package/src/services/search-index/types.ts

@@ -0,0 +1,113 @@
+import type { Static } from "typebox"
+
+import type {
+  CatalogChanges,
+  CatalogSnapshot,
+  VectorCache,
+  VectorChunk,
+  VectorGeneration,
+  VectorReplacement,
+} from "#src/domain"
+import type { Done, Failed, Succeeded } from "#src/shared"
+import type {
+  CatalogHitSchema,
+  CatalogRowSchema,
+  FolderIndexRowSchema,
+  FolderIndexStateSchema,
+  IndexEntrySchema,
+  SearchHitSchema,
+  SearchOptionsSchema,
+} from "./schemas.ts"
+
+export type {
+  AliasFailureClassification,
+  CatalogChanges,
+  CatalogEntry,
+  CatalogPlan,
+  CatalogScan,
+  CatalogSnapshot,
+  SemanticContent,
+  VectorCache,
+  VectorChunk,
+  VectorGeneration,
+  VectorReplacement,
+} from "#src/domain"
+export type CatalogHit = Static<typeof CatalogHitSchema>
+export type CatalogRow = Static<typeof CatalogRowSchema>
+export type FolderIndexState = Static<typeof FolderIndexStateSchema>
+export type FolderIndexRow = Static<typeof FolderIndexRowSchema>
+export type FolderIndexStatesResult = Succeeded<FolderIndexState[]> | SearchIndexRefusal
+export type InventoryResult = Succeeded<CatalogSnapshot> | SearchIndexRefusal
+export type CatalogSearchResult = Succeeded<CatalogHit[]> | SearchIndexRefusal
+export type VectorCacheResult = Succeeded<VectorCache> | SearchIndexRefusal
+export type VectorCoverageResult = Succeeded<VectorCoverage> | SearchIndexRefusal
+
+export interface VectorUpdate {
+  expectedRevision: number
+  generation: VectorGeneration
+  add: VectorChunk[]
+  remove: string[]
+}
+
+export interface VectorCoverage {
+  generation: VectorGeneration | null
+  embedded: number
+  current: number
+}
+
+export interface IndexLocation {
+  path: string
+}
+
+export interface IndexReplacement {
+  path: string
+  temporaryPath: string
+}
+
+export interface CatalogQuery {
+  query: string
+}
+
+export interface CatalogWriteRow extends CatalogRow {
+  folder: string
+}
+
+export interface SearchIndex {
+  put(entry: IndexEntry): IndexWriteResult
+  remove(id: string): IndexWriteResult
+  search(query: string, options: SearchOptions): SearchResult
+  inventory(): InventoryResult
+  apply(changes: CatalogChanges): IndexWriteResult
+  searchCatalog(request: CatalogQuery): CatalogSearchResult
+  vectors(): VectorCacheResult
+  replaceVectors(request: VectorReplacement): IndexWriteResult
+  updateVectors(request: VectorUpdate): IndexWriteResult
+  vectorCoverage(): VectorCoverageResult
+  folderIndexes(): FolderIndexStatesResult
+  recordFolderIndexes(states: FolderIndexState[], keepFolders: string[]): IndexWriteResult
+  close(): IndexWriteResult
+}
+
+export type SearchHit = Static<typeof SearchHitSchema>
+
+export type IndexEntry = Static<typeof IndexEntrySchema>
+
+export type SearchOptions = Static<typeof SearchOptionsSchema>
+
+export interface SearchIndexRefusal extends Failed {
+  reason: "corrupted" | "unavailable" | "closed" | "invalid" | "conflict"
+}
+
+export interface OpenedIndex extends Succeeded<SearchIndex> {
+  rebuilt: boolean
+}
+
+export type OpenIndexResult = OpenedIndex | SearchIndexRefusal
+
+export type SearchResult = Succeeded<SearchHit[]> | SearchIndexRefusal
+
+export type IndexWriteResult = Done | SearchIndexRefusal
+
+export type SchemaResult = Succeeded<boolean> | SearchIndexRefusal
+
+export type IndexWork = () => IndexWriteResult

package/src/services/search-index/vector-statements.ts

@@ -0,0 +1,18 @@
+import type { DatabaseSync } from "node:sqlite"
+
+export function prepareVectorStatements(database: DatabaseSync) {
+  return {
+    generation: database.prepare("SELECT fingerprint, dimensions FROM vector_generation WHERE singleton = 1"),
+    chunks: database.prepare(
+      "SELECT content_fingerprint, chunk, vector FROM vector_chunks ORDER BY content_fingerprint, chunk",
+    ),
+    clearChunks: database.prepare("DELETE FROM vector_chunks"),
+    clearGeneration: database.prepare("DELETE FROM vector_generation"),
+    putGeneration: database.prepare("INSERT INTO vector_generation VALUES (1, ?, ?)"),
+    putChunk: database.prepare("INSERT INTO vector_chunks VALUES (?, ?, ?)"),
+    removeChunks: database.prepare("DELETE FROM vector_chunks WHERE content_fingerprint = ?"),
+    currentContent: database.prepare(`SELECT DISTINCT content_fingerprint FROM notes
+      WHERE id IS NOT NULL AND archived = 0 AND content_fingerprint IS NOT NULL`),
+    embeddedContent: database.prepare("SELECT COUNT(DISTINCT content_fingerprint) AS embedded FROM vector_chunks"),
+  }
+}

package/src/services/search-index/vector-storage.ts

@@ -0,0 +1,169 @@
+import { Value } from "typebox/value"
+
+import { type VectorChunk, type VectorGeneration, VectorGenerationSchema, type VectorReplacement } from "#src/domain"
+import type { Succeeded } from "#src/shared"
+import type { prepareCatalogStatements } from "./catalog-statements.ts"
+import { corruptCatalog } from "./inventory.ts"
+import { invalidCatalog, staleCatalog } from "./reconcile.ts"
+import {
+  CatalogStateSchema,
+  VectorChunkSchema,
+  VectorReplacementSchema,
+  VectorRowSchema,
+  VectorUpdateSchema,
+  VectorValuesSchema,
+} from "./schemas.ts"
+import type {
+  IndexWriteResult,
+  SearchIndexRefusal,
+  VectorCacheResult,
+  VectorCoverageResult,
+  VectorUpdate,
+} from "./types.ts"
+import type { prepareVectorStatements } from "./vector-statements.ts"
+
+export function readVectors(statements: ReturnType<typeof prepareVectorStatements>): VectorCacheResult {
+  const generation = statements.generation.get()
+  const rows = statements.chunks.all()
+  if (!generation) {
+    if (rows.length > 0) return corruptCatalog()
+    return { succeeded: true, output: { generation: null, chunks: [] } }
+  }
+  if (!Value.Check(VectorGenerationSchema, generation)) return corruptCatalog()
+  const chunks: VectorChunk[] = []
+  for (const row of rows) {
+    if (!Value.Check(VectorRowSchema, row)) return corruptCatalog()
+    const vector = JSON.parse(row.vector)
+    if (!Value.Check(VectorValuesSchema, vector)) return corruptCatalog()
+    const chunk = { contentFingerprint: row.content_fingerprint, chunk: row.chunk, vector }
+    if (!Value.Check(VectorChunkSchema, chunk) || !validVector(chunk.vector, generation.dimensions)) {
+      return corruptCatalog()
+    }
+    chunks.push(chunk)
+  }
+  if (!contiguousChunks(chunks)) return corruptCatalog()
+  return { succeeded: true, output: { generation, chunks } }
+}
+
+export function writeVectors(
+  statements: ReturnType<typeof prepareVectorStatements>,
+  catalog: ReturnType<typeof prepareCatalogStatements>,
+  request: VectorReplacement,
+): IndexWriteResult {
+  if (!Value.Check(VectorReplacementSchema, request)) return invalidCatalog("invalid vector generation")
+  const current = readCurrentContent(statements, catalog, request.expectedRevision)
+  if (!current.succeeded) return current
+  if (!usableChunks(request.chunks, request.generation, current.output)) {
+    return invalidCatalog("vectors must belong to current content with finite nonzero vectors of one dimension")
+  }
+
+  statements.clearChunks.run()
+  statements.clearGeneration.run()
+  statements.putGeneration.run(request.generation.fingerprint, request.generation.dimensions)
+  for (const chunk of request.chunks) putChunk(statements, chunk)
+  return { succeeded: true }
+}
+
+export function updateVectors(
+  statements: ReturnType<typeof prepareVectorStatements>,
+  catalog: ReturnType<typeof prepareCatalogStatements>,
+  request: VectorUpdate,
+): IndexWriteResult {
+  if (!Value.Check(VectorUpdateSchema, request)) return invalidCatalog("invalid vector update")
+  const current = readCurrentContent(statements, catalog, request.expectedRevision)
+  if (!current.succeeded) return current
+  const added = new Set(request.add.map((chunk) => chunk.contentFingerprint))
+  if (
+    !usableChunks(request.add, request.generation, current.output) ||
+    request.remove.some((entry) => added.has(entry))
+  ) {
+    return invalidCatalog("added vectors must belong to current content, be finite, nonzero and not also removed")
+  }
+  const stored = readGeneration(statements)
+  if (!stored.succeeded) return stored
+  if (!sameGeneration(stored.output, request.generation)) {
+    statements.clearChunks.run()
+    statements.clearGeneration.run()
+    statements.putGeneration.run(request.generation.fingerprint, request.generation.dimensions)
+  }
+
+  for (const fingerprint of [...request.remove, ...added]) statements.removeChunks.run(fingerprint)
+  for (const chunk of request.add) putChunk(statements, chunk)
+  return { succeeded: true }
+}
+
+export function readVectorCoverage(statements: ReturnType<typeof prepareVectorStatements>): VectorCoverageResult {
+  const generation = readGeneration(statements)
+  if (!generation.succeeded) return generation
+  const embedded = statements.embeddedContent.get()
+  if (!embedded || typeof embedded.embedded !== "number") return corruptCatalog()
+  const current = readFingerprints(statements)
+  if (!current.succeeded) return current
+  return {
+    succeeded: true,
+    output: { generation: generation.output, embedded: embedded.embedded, current: current.output.size },
+  }
+}
+
+function readGeneration(
+  statements: ReturnType<typeof prepareVectorStatements>,
+): Succeeded<VectorGeneration | null> | SearchIndexRefusal {
+  const row = statements.generation.get()
+  if (!row) return { succeeded: true, output: null }
+  if (!Value.Check(VectorGenerationSchema, row)) return corruptCatalog()
+  return { succeeded: true, output: row }
+}
+
+function readCurrentContent(
+  statements: ReturnType<typeof prepareVectorStatements>,
+  catalog: ReturnType<typeof prepareCatalogStatements>,
+  expectedRevision: number,
+): Succeeded<Set<string>> | SearchIndexRefusal {
+  const state = catalog.state.get()
+  if (!Value.Check(CatalogStateSchema, state)) return corruptCatalog()
+  if (state.revision !== expectedRevision) return staleCatalog()
+  return readFingerprints(statements)
+}
+
+function readFingerprints(
+  statements: ReturnType<typeof prepareVectorStatements>,
+): Succeeded<Set<string>> | SearchIndexRefusal {
+  const fingerprints = new Set<string>()
+  for (const row of statements.currentContent.all()) {
+    if (typeof row.content_fingerprint !== "string") return corruptCatalog()
+    fingerprints.add(row.content_fingerprint)
+  }
+  return { succeeded: true, output: fingerprints }
+}
+
+function sameGeneration(stored: VectorGeneration | null, requested: VectorGeneration): boolean {
+  return stored?.fingerprint === requested.fingerprint && stored.dimensions === requested.dimensions
+}
+
+function putChunk(statements: ReturnType<typeof prepareVectorStatements>, chunk: VectorChunk): void {
+  statements.putChunk.run(chunk.contentFingerprint, chunk.chunk, JSON.stringify(chunk.vector))
+}
+
+function usableChunks(chunks: VectorChunk[], generation: VectorGeneration, current: Set<string>): boolean {
+  return (
+    chunks.every(
+      (chunk) => current.has(chunk.contentFingerprint) && validVector(chunk.vector, generation.dimensions),
+    ) && contiguousChunks(chunks)
+  )
+}
+
+function contiguousChunks(chunks: VectorChunk[]): boolean {
+  const groups = new Map<string, number[]>()
+  for (const chunk of chunks) {
+    const group = groups.get(chunk.contentFingerprint)
+    if (group) group.push(chunk.chunk)
+    else groups.set(chunk.contentFingerprint, [chunk.chunk])
+  }
+  return [...groups.values()].every((group) =>
+    group.sort((left, right) => left - right).every((chunk, index) => chunk === index),
+  )
+}
+
+function validVector(vector: number[], dimensions: number): boolean {
+  return vector.length === dimensions && vector.every(Number.isFinite) && vector.some((value) => value !== 0)
+}

package/src/services/search-index/vectors.ts

@@ -0,0 +1,18 @@
+import type { VectorReplacement } from "#src/domain"
+import type { IndexWriteResult, SearchIndex, VectorCacheResult, VectorCoverageResult, VectorUpdate } from "./types.ts"
+
+export function readVectorCache(index: SearchIndex): VectorCacheResult {
+  return index.vectors()
+}
+
+export function replaceVectorCache(index: SearchIndex, request: VectorReplacement): IndexWriteResult {
+  return index.replaceVectors(request)
+}
+
+export function updateVectorCache(index: SearchIndex, request: VectorUpdate): IndexWriteResult {
+  return index.updateVectors(request)
+}
+
+export function readVectorCoverage(index: SearchIndex): VectorCoverageResult {
+  return index.vectorCoverage()
+}

package/src/services/search-index/write.ts

@@ -0,0 +1,9 @@
+import type { IndexEntry, IndexWriteResult, SearchIndex } from "./types.ts"
+
+export function putNote(index: SearchIndex, entry: IndexEntry): IndexWriteResult {
+  return index.put(entry)
+}
+
+export function removeNote(index: SearchIndex, id: string): IndexWriteResult {
+  return index.remove(id)
+}

package/src/services/shell-edit/ask.ts

@@ -0,0 +1,53 @@
+import { Value } from "typebox/value"
+
+import { SHELL_EDIT_QUESTIONS } from "#src/domain"
+import { answeredByRequestedModel, defaultJevModel } from "#src/services/decision-model"
+import { JevOutcomeSchema, ShellEditAnswersSchema } from "./schemas.ts"
+import type { ShellEditAskCall, ShellEditAskResult, ShellEditClassifierResult } from "./types.ts"
+
+export async function askShellEdit(call: ShellEditAskCall): Promise<ShellEditAskResult> {
+  if (call.signal.aborted) return failed("cancelled")
+  const outcome = await classified(call)
+  if (typeof outcome === "string") return failed(outcome)
+  if (call.signal.aborted) return failed("cancelled")
+  if (!Value.Check(JevOutcomeSchema, outcome)) return failed("Jev returned an answer of another shape")
+  if (outcome.stopReason === "aborted") return failed("cancelled")
+  if (outcome.stopReason === "error") return failed(errorText(outcome.errorMessage))
+  if (!answeredByRequestedModel(defaultJevModel, outcome.model)) {
+    return failed(`answered by ${outcome.model}, not ${defaultJevModel}`)
+  }
+  if (!Value.Check(ShellEditAnswersSchema, outcome)) {
+    return failed("Jev did not answer every question with a yes/no probability")
+  }
+  const { answers } = outcome
+  const scores = {
+    redirection: answers.redirection.probability,
+    in_place: answers.in_place.probability,
+    inline_code: answers.inline_code.probability,
+    script_writes: answers.script_writes.probability,
+    copy_download: answers.copy_download.probability,
+    hardlink: answers.hardlink.probability,
+  }
+  return { succeeded: true, output: { scores, reportedModel: outcome.model } }
+}
+
+async function classified(call: ShellEditAskCall): Promise<ShellEditClassifierResult | string> {
+  try {
+    return await call.classifier.classify({
+      model: { provider: "typesafe", id: defaultJevModel },
+      context: { state: call.state, questions: SHELL_EDIT_QUESTIONS },
+      options: { signal: call.signal, maxRetries: 0 },
+    })
+  } catch (error) {
+    return `the call to Jev failed: ${String(error)}`
+  }
+}
+
+function errorText(message: string | undefined): string {
+  if (typeof message === "string") return `Jev reported an error: ${message}`
+  return "Jev reported an error"
+}
+
+function failed(cause: string): ShellEditAskResult {
+  return { succeeded: false, problems: [cause] }
+}

package/src/services/shell-edit/domain-rules.ts

@@ -0,0 +1,2 @@
+export type { ShellEditQuestion } from "#src/domain"
+export { executedFiles, firedQuestions, SHELL_EDIT_CUTOFFS, shellEditRefusal, shellEditUncheckable } from "#src/domain"

package/src/services/shell-edit/index.ts

@@ -0,0 +1,4 @@
+export * from "./ask.ts"
+export * from "./domain-rules.ts"
+export * from "./schemas.ts"
+export * from "./types.ts"

package/src/services/shell-edit/schemas.ts

@@ -0,0 +1,23 @@
+import Type from "typebox"
+
+const BoolAnswerSchema = Type.Object({
+  type: Type.Literal("bool"),
+  probability: Type.Number({ minimum: 0, maximum: 1 }),
+})
+
+export const JevOutcomeSchema = Type.Object({
+  stopReason: Type.Union([Type.Literal("stop"), Type.Literal("error"), Type.Literal("aborted")]),
+  model: Type.String(),
+  errorMessage: Type.Optional(Type.String()),
+})
+
+export const ShellEditAnswersSchema = Type.Object({
+  answers: Type.Object({
+    redirection: BoolAnswerSchema,
+    in_place: BoolAnswerSchema,
+    inline_code: BoolAnswerSchema,
+    script_writes: BoolAnswerSchema,
+    copy_download: BoolAnswerSchema,
+    hardlink: BoolAnswerSchema,
+  }),
+})

package/src/services/shell-edit/types.ts

@@ -0,0 +1,61 @@
+import type { ShellEditQuestions, ShellEditScores, ShellEditState } from "#src/domain"
+import type { Failed, Succeeded } from "#src/shared"
+
+export interface ShellEditPrompt {
+  state: ShellEditState
+  questions: ShellEditQuestions
+}
+
+export interface ShellEditModelReference {
+  provider: "typesafe"
+  id: string
+}
+
+export interface ShellEditClassifyOptions {
+  signal: AbortSignal
+  maxRetries: 0
+}
+
+export interface ShellEditClassifyRequest {
+  model: ShellEditModelReference
+  context: ShellEditPrompt
+  options: ShellEditClassifyOptions
+}
+
+export interface ShellEditJevAnswer {
+  type: string
+  probability?: number
+}
+
+export interface ShellEditJevAnswers {
+  redirection?: ShellEditJevAnswer
+  in_place?: ShellEditJevAnswer
+  inline_code?: ShellEditJevAnswer
+  script_writes?: ShellEditJevAnswer
+  copy_download?: ShellEditJevAnswer
+  hardlink?: ShellEditJevAnswer
+}
+
+export interface ShellEditClassifierResult {
+  model: string
+  answers: ShellEditJevAnswers
+  stopReason: "stop" | "error" | "aborted"
+  errorMessage?: string
+}
+
+export interface ShellEditClassifierPort {
+  classify(request: ShellEditClassifyRequest): Promise<ShellEditClassifierResult>
+}
+
+export interface ShellEditAskCall {
+  classifier: ShellEditClassifierPort
+  state: ShellEditState
+  signal: AbortSignal
+}
+
+export interface ShellEditClassification {
+  scores: ShellEditScores
+  reportedModel: string
+}
+
+export type ShellEditAskResult = Succeeded<ShellEditClassification> | Failed

package/src/services/shell-scripts/constants.ts

@@ -0,0 +1 @@
+export const PACKAGE_SCRIPT_PREFIX = "package.json#scripts."