@zerwiz/ymir 0.1.34 → 0.1.35

package/apps/sessrumnir/src/main/ipc/council-handlers.ts

@@ -0,0 +1,126 @@
+import { ipcMain } from 'electron'
+import { WorkspaceManager } from '../workspace-manager'
+import type {
+  CouncilRunResult,
+  CouncilDetectResult,
+  CouncilArbiterResult,
+} from '../../shared/ipc-contracts'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { COUNCIL_AGENT_IDS, clampTimeoutSeconds } from '../../shared/council-config'
+import type { CouncilAgentId, ConsensusMode, ConsultantResult } from '../../shared/council-config'
+import { detectAgents } from '../agent-detection'
+import { runConsultants, runArbiter, defaultSpawnConsultant, type ArbiterRequest } from '../council-manager'
+import { access } from 'fs/promises'
+import { isString, isObject } from './validation'
+import type { IpcContext } from './context'
+import { t } from '../../shared/i18n'
+
+/**
+ * Resolve the working directory for council runs: the active workspace, never
+ * the renderer's input, so agents plan against the real project tree. Falls back
+ * to the home directory if the workspace path is inaccessible.
+ */
+async function resolveCouncilCwd(workspaceManager: WorkspaceManager): Promise<string> {
+  const activeWs = workspaceManager.getActiveWorkspace()
+  if (!activeWs) throw new Error(t('errors.workspace.noneActive'))
+  try {
+    await access(activeWs.path)
+    return activeWs.path
+  } catch {
+    return process.env.HOME ?? process.env.USERPROFILE ?? process.cwd()
+  }
+}
+
+export function registerCouncilHandlers(ctx: IpcContext): void {
+  const { workspaceManager, broadcast } = ctx
+
+  ipcMain.handle(IPC_CHANNELS.COUNCIL_DETECT, async (): Promise<CouncilDetectResult> => {
+    const agents = detectAgents().map((a) => ({ id: a.id, found: a.found }))
+    return { agents }
+  })
+
+  ipcMain.handle(
+    IPC_CHANNELS.COUNCIL_RUN_CONSULTANTS,
+    async (_event, payload: unknown): Promise<CouncilRunResult> => {
+      // Validate the payload before spawning any child processes.
+      if (!isObject(payload)) throw new Error('Council run payload must be an object')
+      if (!isString(payload.request) || payload.request.trim().length === 0) {
+        throw new Error('Council run request must be a non-empty string')
+      }
+      if (
+        !Array.isArray(payload.members) ||
+        payload.members.length === 0 ||
+        !payload.members.every((m): m is CouncilAgentId => COUNCIL_AGENT_IDS.includes(m as CouncilAgentId))
+      ) {
+        throw new Error('Council run members must be a non-empty list of known agents')
+      }
+      if (payload.consensusMode !== 'arbiter' && payload.consensusMode !== 'debate') {
+        throw new Error('Council run consensusMode must be "arbiter" or "debate"')
+      }
+      const members = payload.members as CouncilAgentId[]
+      const consensusMode = payload.consensusMode as ConsensusMode
+      const timeoutSeconds = clampTimeoutSeconds(Number(payload.timeoutSeconds))
+
+      // The working directory is the active workspace, never the renderer's
+      // input — consultants must plan against the real project tree.
+      const cwd = await resolveCouncilCwd(workspaceManager)
+
+      const results = await runConsultants(
+        { request: payload.request, members, cwd, timeoutSeconds, consensusMode },
+        {
+          spawnConsultant: defaultSpawnConsultant,
+          onProgress: (id, chunk) => broadcast(IPC_CHANNELS.EVENT_COUNCIL_PROGRESS, { id, chunk }),
+        },
+      )
+      return { results }
+    },
+  )
+
+  ipcMain.handle(
+    IPC_CHANNELS.COUNCIL_ARBITER,
+    async (_event, payload: unknown): Promise<CouncilArbiterResult> => {
+      if (!isObject(payload)) throw new Error('Council arbiter payload must be an object')
+      if (!isString(payload.request) || payload.request.trim().length === 0) {
+        throw new Error('Council arbiter request must be a non-empty string')
+      }
+      const timeoutSeconds = clampTimeoutSeconds(Number(payload.timeoutSeconds))
+
+      let input: ArbiterRequest
+      if (payload.kind === 'merge') {
+        if (!Array.isArray(payload.results)) {
+          throw new Error('Council arbiter merge requires a results array')
+        }
+        input = {
+          kind: 'merge',
+          request: payload.request,
+          results: payload.results as ConsultantResult[],
+        }
+      } else if (payload.kind === 'revise') {
+        if (!isString(payload.plan) || payload.plan.trim().length === 0) {
+          throw new Error('Council arbiter revise requires a non-empty plan')
+        }
+        if (!isString(payload.feedback) || payload.feedback.trim().length === 0) {
+          throw new Error('Council arbiter revise requires non-empty feedback')
+        }
+        input = {
+          kind: 'revise',
+          request: payload.request,
+          plan: payload.plan,
+          feedback: payload.feedback,
+        }
+      } else {
+        throw new Error('Council arbiter kind must be "merge" or "revise"')
+      }
+
+      const cwd = await resolveCouncilCwd(workspaceManager)
+      const outcome = await runArbiter(input, cwd, timeoutSeconds, {
+        spawnConsultant: defaultSpawnConsultant,
+        onProgress: (chunk) => broadcast(IPC_CHANNELS.EVENT_COUNCIL_PROGRESS, { id: 'pi', chunk }),
+      })
+      if (!outcome.ok) {
+        throw new Error(outcome.timedOut ? t('errors.council.arbiterTimedOut') : outcome.error ?? t('errors.council.arbiterFailed'))
+      }
+      return { plan: outcome.output.trim() }
+    },
+  )
+}

package/apps/sessrumnir/src/main/ipc/diagnostics-handlers.ts

@@ -0,0 +1,8 @@
+import { ipcMain } from 'electron'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { collectDiagnostics } from '../diagnostics'
+import type { IpcContext } from './context'
+
+export function registerDiagnosticsHandlers(ctx: IpcContext): void {
+  ipcMain.handle(IPC_CHANNELS.DIAGNOSTICS_GET, async () => collectDiagnostics(ctx.workspaceManager))
+}

package/apps/sessrumnir/src/main/ipc/file-handlers.ts

@@ -0,0 +1,96 @@
+import { ipcMain } from 'electron'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { readAttachment } from '../attachment-reader'
+import { isAuthorizedAttachmentPath } from '../path-authorization'
+import { assertTrustedSender, isString } from './validation'
+import type { IpcContext } from './context'
+import { t } from '../../shared/i18n'
+
+export function registerFileHandlers(ctx: IpcContext): void {
+  const { workspaceManager, approvedAttachmentPaths } = ctx
+
+  // ─── File Operations ────────────────────────────────────────────────────
+
+  ipcMain.handle(IPC_CHANNELS.FILE_TREE, async (_event, maxDepth?: unknown) => {
+    const fs = workspaceManager.getActiveFileService()
+    if (!fs) throw new Error(t('errors.workspace.noneActive'))
+    return fs.getFileTree(typeof maxDepth === 'number' ? maxDepth : 4)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.FILE_SEARCH, async (_event, query: unknown) => {
+    if (!isString(query)) throw new Error('query must be a string')
+    const fs = workspaceManager.getActiveFileService()
+    if (!fs) throw new Error(t('errors.workspace.noneActive'))
+    return fs.searchFiles(query)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.FILE_SEARCH_CONTENT, async (_event, query: unknown) => {
+    if (!isString(query)) throw new Error('query must be a string')
+    const fs = workspaceManager.getActiveFileService()
+    if (!fs) throw new Error(t('errors.workspace.noneActive'))
+    return fs.searchContent(query)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.FILE_READ, async (_event, filePath: unknown) => {
+    if (!isString(filePath)) throw new Error('filePath must be a string')
+    const fs = workspaceManager.getActiveFileService()
+    if (!fs) throw new Error(t('errors.workspace.noneActive'))
+    return fs.readFileContent(filePath)
+  })
+
+  // Reads a user-selected attachment by absolute path (chosen via the native
+  // open dialog, so it may live outside the workspace).
+  ipcMain.handle(IPC_CHANNELS.FILE_READ_ATTACHMENT, async (_event, filePath: unknown) => {
+    if (!isString(filePath)) throw new Error('filePath must be a string')
+    const workspaceRoot = workspaceManager.getActiveWorkspace()?.path ?? null
+    if (!isAuthorizedAttachmentPath(filePath, { workspaceRoot, approvedPaths: approvedAttachmentPaths })) {
+      throw new Error(t('errors.attachments.pathNotPermitted'))
+    }
+    return readAttachment(filePath)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.FILE_WRITE, async (event, filePath: unknown, content: unknown) => {
+    assertTrustedSender(event)
+    if (!isString(filePath)) throw new Error('filePath must be a string')
+    if (!isString(content)) throw new Error('content must be a string')
+    const fs = workspaceManager.getActiveFileService()
+    if (!fs) throw new Error(t('errors.workspace.noneActive'))
+    await fs.writeFileContent(filePath, content)
+    return { ok: true }
+  })
+
+  ipcMain.handle(IPC_CHANNELS.FILE_DIFF, async (_event, filePath?: unknown) => {
+    const fs = workspaceManager.getActiveFileService()
+    if (!fs) throw new Error(t('errors.workspace.noneActive'))
+    return fs.getFileDiff(isString(filePath) ? filePath : undefined)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.FILE_STAGED_DIFF, async (_event, filePath?: unknown) => {
+    const fs = workspaceManager.getActiveFileService()
+    if (!fs) throw new Error(t('errors.workspace.noneActive'))
+    return fs.getStagedDiff(isString(filePath) ? filePath : undefined)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.GIT_STATUS, async () => {
+    const fs = workspaceManager.getActiveFileService()
+    // No active workspace (e.g. the home screen before any workspace is opened)
+    // is an expected state, not an error — report no changes rather than throwing
+    // (which Electron would log as an unhandled handler error every poll).
+    if (!fs) return {}
+    const statusMap = await fs.getGitStatus()
+    // Convert Map to plain object for IPC
+    const result: Record<string, unknown> = {}
+    for (const [key, value] of statusMap) {
+      result[key] = value
+    }
+    return result
+  })
+
+  ipcMain.handle(IPC_CHANNELS.GIT_BRANCH, async () => {
+    const fs = workspaceManager.getActiveFileService()
+    // No active workspace: report "no branch" rather than throwing (matches the
+    // Promise<string | null> contract; keeps the no-workspace state error-free).
+    if (!fs) return null
+    return fs.getGitBranch()
+  })
+}

package/apps/sessrumnir/src/main/ipc/git-conveyor-handlers.ts

@@ -0,0 +1,55 @@
+import { ipcMain } from 'electron'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import type {
+  GitConveyorCommitOptions,
+  GitConveyorPullRequestOptions,
+} from '../../shared/ipc-contracts'
+import { assertTrustedSender, isObject, isOptionalBoolean, isOptionalString, isString } from './validation'
+import { commitAll, createPullRequest, getGitConveyorStatus, pushBranch } from '../git-conveyor'
+import type { IpcContext } from './context'
+import { t } from '../../shared/i18n'
+
+function activeCwd(ctx: IpcContext): string {
+  const cwd = ctx.workspaceManager.getActiveWorkspace()?.path
+  if (!cwd) throw new Error(t('errors.workspace.noneActive'))
+  return cwd
+}
+
+export function registerGitConveyorHandlers(ctx: IpcContext): void {
+  ipcMain.handle(IPC_CHANNELS.GIT_CONVEYOR_STATUS, async (event) => {
+    assertTrustedSender(event)
+    return getGitConveyorStatus(activeCwd(ctx))
+  })
+
+  ipcMain.handle(IPC_CHANNELS.GIT_CONVEYOR_COMMIT, async (event, input: unknown) => {
+    assertTrustedSender(event)
+    if (!isObject(input) || !isString(input.message)) throw new Error('Commit message must be a string')
+    const options: GitConveyorCommitOptions = { message: input.message }
+    return commitAll(activeCwd(ctx), options)
+  })
+
+  ipcMain.handle(IPC_CHANNELS.GIT_CONVEYOR_PUSH, async (event) => {
+    assertTrustedSender(event)
+    return pushBranch(activeCwd(ctx))
+  })
+
+  ipcMain.handle(IPC_CHANNELS.GIT_CONVEYOR_CREATE_PR, async (event, input: unknown) => {
+    assertTrustedSender(event)
+    if (
+      !isObject(input) ||
+      !isString(input.title) ||
+      !isString(input.body) ||
+      !isOptionalString(input.base) ||
+      !isOptionalBoolean(input.draft)
+    ) {
+      throw new Error('Pull request title, body, optional base branch, and optional draft flag are required')
+    }
+    const options: GitConveyorPullRequestOptions = {
+      title: input.title,
+      body: input.body,
+      ...(typeof input.base === 'string' ? { base: input.base } : {}),
+      ...(typeof input.draft === 'boolean' ? { draft: input.draft } : {}),
+    }
+    return createPullRequest(activeCwd(ctx), options)
+  })
+}

package/apps/sessrumnir/src/main/ipc/model-handlers.ts

@@ -0,0 +1,33 @@
+import { ipcMain } from 'electron'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { isString } from './validation'
+import type { IpcContext } from './context'
+
+export function registerModelHandlers(ctx: IpcContext): void {
+  const { getActivePi } = ctx
+
+  // ─── Model Management ───────────────────────────────────────────────────
+
+  ipcMain.handle(IPC_CHANNELS.MODEL_SET, async (_event, provider: unknown, modelId: unknown) => {
+    if (!isString(provider)) throw new Error('provider must be a string')
+    if (!isString(modelId)) throw new Error('modelId must be a string')
+    return getActivePi().sendCommand({ type: 'set_model', provider, modelId })
+  })
+
+  ipcMain.handle(IPC_CHANNELS.MODEL_CYCLE, async () => {
+    return getActivePi().sendCommand({ type: 'cycle_model' })
+  })
+
+  ipcMain.handle(IPC_CHANNELS.MODEL_LIST_AVAILABLE, async () => {
+    return getActivePi().sendCommand({ type: 'get_available_models' })
+  })
+
+  ipcMain.handle(IPC_CHANNELS.THINKING_SET_LEVEL, async (_event, level: unknown) => {
+    if (!isString(level)) throw new Error('level must be a string')
+    return getActivePi().sendCommand({ type: 'set_thinking_level', level })
+  })
+
+  ipcMain.handle(IPC_CHANNELS.THINKING_CYCLE_LEVEL, async () => {
+    return getActivePi().sendCommand({ type: 'cycle_thinking_level' })
+  })
+}

package/apps/sessrumnir/src/main/ipc/models-config-handlers.ts

@@ -0,0 +1,80 @@
+import { ipcMain } from 'electron'
+import type { AgentEngineKind, ModelsFileInfo, ModelsReadFailure, ModelsReadResult } from '../../shared/ipc-contracts'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import { existsSync } from 'fs'
+import {
+  describeModelsReadFailure,
+  isModelsConfig,
+  parseModelsFile,
+  resolveModelsFile,
+  serializeModelsFile,
+  type ModelsFileLocation,
+} from '../models-file'
+import { activeEngineKind } from './active-engine'
+import type { IpcContext } from './context'
+
+function modelsFileLocation(engine: AgentEngineKind): ModelsFileLocation {
+  const homeDir = process.env.HOME ?? process.env.USERPROFILE ?? ''
+  return resolveModelsFile(engine, homeDir)
+}
+
+function fileInfo(engine: AgentEngineKind, location: ModelsFileLocation): ModelsFileInfo {
+  return { engine, file: location.file, name: location.name }
+}
+
+function failed(
+  location: ModelsFileLocation,
+  info: ModelsFileInfo,
+  failure: ModelsReadFailure,
+  raw: string,
+): ModelsReadResult {
+  return { error: describeModelsReadFailure(location.name, failure), failure, raw, location: info }
+}
+
+export async function readModelsConfigFile(engine: AgentEngineKind): Promise<ModelsReadResult> {
+  const location = modelsFileLocation(engine)
+  const info = fileInfo(engine, location)
+  if (!existsSync(location.file)) return { config: { providers: {} }, location: info }
+  let raw: string
+  try {
+    raw = await readFile(location.file, 'utf-8')
+  } catch (err) {
+    return failed(location, info, { kind: 'unreadable', detail: err instanceof Error ? err.message : String(err) }, '')
+  }
+  try {
+    const parsed = parseModelsFile(raw, location.format)
+    if (!isModelsConfig(parsed)) {
+      return failed(location, info, { kind: 'missing-providers' }, raw)
+    }
+    return { config: parsed, location: info }
+  } catch (err) {
+    return failed(location, info, {
+      kind: 'invalid-syntax',
+      format: location.format,
+      detail: err instanceof Error ? err.message : String(err),
+    }, raw)
+  }
+}
+
+export function registerModelsConfigHandlers(ctx: IpcContext): void {
+  const { workspaceManager } = ctx
+
+  ipcMain.handle(IPC_CHANNELS.MODELS_READ, async (): Promise<ModelsReadResult> => {
+    return readModelsConfigFile(activeEngineKind(workspaceManager))
+  })
+
+  ipcMain.handle(IPC_CHANNELS.MODELS_WRITE, async (_event, config: unknown): Promise<{ success: boolean; error?: string }> => {
+    if (!isModelsConfig(config)) {
+      return { success: false, error: 'Invalid models config' }
+    }
+    const location = modelsFileLocation(activeEngineKind(workspaceManager))
+    try {
+      if (!existsSync(location.dir)) await mkdir(location.dir, { recursive: true })
+      await writeFile(location.file, serializeModelsFile(config, location.format), 'utf-8')
+      return { success: true }
+    } catch (err) {
+      return { success: false, error: err instanceof Error ? err.message : String(err) }
+    }
+  })
+}

package/apps/sessrumnir/src/main/ipc/notes-handlers.ts

@@ -0,0 +1,65 @@
+import { ipcMain } from 'electron'
+import type { NoteInput, NoteUpdate, NoteScope } from '../../shared/ipc-contracts'
+import { IPC_CHANNELS } from '../../shared/ipc-contracts'
+import { isString, isObject, parseStringArray } from './validation'
+import type { IpcContext } from './context'
+
+/** Validate the shape of a NoteInput from the renderer (content checks happen in NotesManager). */
+function parseNoteInput(value: unknown): NoteInput {
+  if (!isObject(value)) throw new Error('note must be an object')
+  if (!isString(value.title)) throw new Error('note.title must be a string')
+  if (!isString(value.body)) throw new Error('note.body must be a string')
+  if (!isString(value.scope)) throw new Error('note.scope must be a string')
+  return {
+    title: value.title,
+    body: value.body,
+    scope: value.scope as NoteScope,
+    tags: parseStringArray(value.tags, 'note.tags'),
+  }
+}
+
+/** Validate a partial NoteUpdate; only supplied fields are carried through. */
+function parseNoteUpdate(value: unknown): NoteUpdate {
+  if (!isObject(value)) throw new Error('patch must be an object')
+  const patch: NoteUpdate = {}
+  if (value.title !== undefined) {
+    if (!isString(value.title)) throw new Error('note.title must be a string')
+    patch.title = value.title
+  }
+  if (value.body !== undefined) {
+    if (!isString(value.body)) throw new Error('note.body must be a string')
+    patch.body = value.body
+  }
+  if (value.scope !== undefined) {
+    if (!isString(value.scope)) throw new Error('note.scope must be a string')
+    patch.scope = value.scope as NoteScope
+  }
+  if (value.tags !== undefined) {
+    patch.tags = parseStringArray(value.tags, 'note.tags')
+  }
+  return patch
+}
+
+export function registerNotesHandlers(ctx: IpcContext): void {
+  const { notesManager } = ctx
+
+  // ─── Notes (reusable prompts / commands) ──────────────────────────────────
+
+  ipcMain.handle(IPC_CHANNELS.NOTES_LIST, async () => {
+    return notesManager.list()
+  })
+
+  ipcMain.handle(IPC_CHANNELS.NOTES_CREATE, async (_event, input: unknown) => {
+    return notesManager.create(parseNoteInput(input))
+  })
+
+  ipcMain.handle(IPC_CHANNELS.NOTES_UPDATE, async (_event, id: unknown, patch: unknown) => {
+    if (!isString(id)) throw new Error('id must be a string')
+    return notesManager.update(id, parseNoteUpdate(patch))
+  })
+
+  ipcMain.handle(IPC_CHANNELS.NOTES_REMOVE, async (_event, id: unknown) => {
+    if (!isString(id)) throw new Error('id must be a string')
+    await notesManager.remove(id)
+  })
+}