saeeol 1.1.0 → 1.2.0

package/src/overlay/i18n/index.ts

@@ -0,0 +1,163 @@
+// Full translations live in packages/saeeol-i18n/src/*.ts but tsgo can't resolve workspace packages,
+// so we embed command-related keys here and keep saeeol-i18n as the source of truth for other packages.
+
+const en: Record<string, string> = {
+  "cmd.session.switch": "Switch session",
+  "cmd.session.new": "New session",
+  "cmd.model.switch": "Switch model",
+  "cmd.model.cycle": "Model cycle",
+  "cmd.model.cycleReverse": "Model cycle reverse",
+  "cmd.favorite.cycle": "Favorite cycle",
+  "cmd.favorite.cycleReverse": "Favorite cycle reverse",
+  "cmd.agent.switch": "Switch agent",
+  "cmd.mcp.toggle": "Toggle MCPs",
+  "cmd.agent.cycle": "Agent cycle",
+  "cmd.variant.cycle": "Variant cycle",
+  "cmd.model.variant": "Switch model variant",
+  "cmd.agent.cycleReverse": "Agent cycle reverse",
+  "cmd.provider.connect": "Connect provider",
+  "cmd.provider.setup": "Setup wizard",
+  "cmd.provider.setupDesc": "Run the initial setup wizard again",
+  "cmd.provider.skipSetup": "Skip setup",
+  "cmd.provider.skipSetupDesc": "Continue without connecting a provider",
+  "cmd.org.switch": "Switch org",
+  "cmd.status.view": "View status",
+  "cmd.theme.switch": "Switch theme",
+  "cmd.theme.light": "Switch to light mode",
+  "cmd.theme.dark": "Switch to dark mode",
+  "cmd.theme.lock": "Lock theme mode",
+  "cmd.theme.unlock": "Unlock theme mode",
+  "cmd.help": "Help",
+  "cmd.docs": "Open docs",
+  "cmd.exit": "Exit the app",
+  "cmd.debug": "Toggle debug panel",
+  "cmd.console": "Toggle console",
+  "cmd.heap": "Write heap snapshot",
+  "cmd.suspend": "Suspend terminal",
+  "cmd.session.share": "Share session",
+  "cmd.session.share.copy": "Copy share link",
+  "cmd.session.rename": "Rename session",
+  "cmd.session.timeline": "Jump to message",
+  "cmd.session.fork": "Fork session",
+  "cmd.session.compact": "Compact session",
+  "cmd.session.compact.warn": "Connect a provider to compact this session",
+  "cmd.session.unshare": "Unshare session",
+  "cmd.session.undo": "Undo previous message",
+  "cmd.session.redo": "Redo",
+  "cmd.session.sidebar.hide": "Hide sidebar",
+  "cmd.session.sidebar.show": "Show sidebar",
+  "cmd.session.conceal.enable": "Enable code concealment",
+  "cmd.session.conceal.disable": "Disable code concealment",
+  "cmd.session.timestamps.show": "Show timestamps",
+  "cmd.session.timestamps.hide": "Hide timestamps",
+  "cmd.session.thinking.show": "Show thinking",
+  "cmd.session.thinking.hide": "Hide thinking",
+  "cmd.session.tools.show": "Show tool details",
+  "cmd.session.tools.hide": "Hide tool details",
+  "cmd.session.scrollbar": "Toggle session scrollbar",
+  "cmd.session.pointing": "Pin folder",
+  "cmd.session.pointing.description": "Choose which folder to work in",
+  "cmd.session.unpointing": "Unpin folder",
+  "cmd.session.unpointing.description": "Remove pinned folder, go back to default",
+}
+
+const ko: Record<string, string> = {
+  "cmd.session.switch": "세션 전환",
+  "cmd.session.new": "새 세션",
+  "cmd.model.switch": "모델 변경",
+  "cmd.model.cycle": "모델 순환",
+  "cmd.model.cycleReverse": "모델 역순 순환",
+  "cmd.favorite.cycle": "즐겨찾기 순환",
+  "cmd.favorite.cycleReverse": "즐겨찾기 역순 순환",
+  "cmd.agent.switch": "에이전트 변경",
+  "cmd.mcp.toggle": "MCP 토글",
+  "cmd.agent.cycle": "에이전트 순환",
+  "cmd.variant.cycle": "변형 순환",
+  "cmd.model.variant": "모델 변형 변경",
+  "cmd.agent.cycleReverse": "에이전트 역순 순환",
+  "cmd.provider.connect": "공급자 연결",
+  "cmd.provider.setup": "설정 마법사",
+  "cmd.provider.setupDesc": "초기 설정 마법사 다시 실행",
+  "cmd.provider.skipSetup": "설정 건너뛰기",
+  "cmd.provider.skipSetupDesc": "공급자 연결 없이 계속하기",
+  "cmd.org.switch": "조직 전환",
+  "cmd.status.view": "상태 보기",
+  "cmd.theme.switch": "테마 변경",
+  "cmd.theme.light": "라이트 모드로 전환",
+  "cmd.theme.dark": "다크 모드로 전환",
+  "cmd.theme.lock": "테마 모드 잠금",
+  "cmd.theme.unlock": "테마 모드 잠금 해제",
+  "cmd.help": "도움말",
+  "cmd.docs": "문서 열기",
+  "cmd.exit": "종료",
+  "cmd.debug": "디버그 패널 토글",
+  "cmd.console": "콘솔 토글",
+  "cmd.heap": "힙 스냅샷 작성",
+  "cmd.suspend": "터미널 일시정지",
+  "cmd.session.share": "세션 공유",
+  "cmd.session.share.copy": "공유 링크 복사",
+  "cmd.session.rename": "세션 이름 변경",
+  "cmd.session.timeline": "메시지로 이동",
+  "cmd.session.fork": "세션 포크",
+  "cmd.session.compact": "세션 압축",
+  "cmd.session.compact.warn": "공급자를 연결하면 세션을 압축할 수 있습니다",
+  "cmd.session.unshare": "공유 해제",
+  "cmd.session.undo": "이전 메시지 실행 취소",
+  "cmd.session.redo": "다시 실행",
+  "cmd.session.sidebar.hide": "사이드바 숨기기",
+  "cmd.session.sidebar.show": "사이드바 보이기",
+  "cmd.session.conceal.enable": "코드 숨김 활성화",
+  "cmd.session.conceal.disable": "코드 숨김 비활성화",
+  "cmd.session.timestamps.show": "타임스탬프 보이기",
+  "cmd.session.timestamps.hide": "타임스탬프 숨기기",
+  "cmd.session.thinking.show": "사고 과정 보이기",
+  "cmd.session.thinking.hide": "사고 과정 숨기기",
+  "cmd.session.tools.show": "도구 상세 보이기",
+  "cmd.session.tools.hide": "도구 상세 숨기기",
+  "cmd.session.scrollbar": "세션 스크롤바 토글",
+  "cmd.session.pointing": "폴더 고정",
+  "cmd.session.pointing.description": "작업할 폴더를 선택하세요",
+  "cmd.session.unpointing": "고정 해제",
+  "cmd.session.unpointing.description": "고정된 폴더를 풀고 기본으로 돌아가요",
+}
+
+const ja: Record<string, string> = {
+  "cmd.session.switch": "セッション切替",
+  "cmd.session.new": "新規セッション",
+  "cmd.model.switch": "モデル切替",
+  "cmd.provider.connect": "プロバイダ接続",
+  "cmd.provider.setup": "セットアップウィザード",
+  "cmd.status.view": "ステータス表示",
+  "cmd.session.pointing": "フォルダを固定",
+  "cmd.session.unpointing": "固定解除",
+}
+
+const zh: Record<string, string> = {
+  "cmd.session.switch": "切换会话",
+  "cmd.session.new": "新建会话",
+  "cmd.model.switch": "切换模型",
+  "cmd.provider.connect": "连接提供商",
+  "cmd.provider.setup": "设置向导",
+  "cmd.status.view": "查看状态",
+  "cmd.session.pointing": "固定文件夹",
+  "cmd.session.unpointing": "取消固定",
+}
+
+const locales: Record<string, Record<string, string>> = { en, ko, ja, zh }
+
+let current = "en"
+
+export function setLocale(lang: string | undefined) {
+  if (!lang) return
+  const code = lang.split("-")[0]?.toLowerCase()
+  if (locales[code]) current = code
+  else if (locales[lang]) current = lang
+}
+
+export function t(key: string, fallback?: string): string {
+  return locales[current]?.[key] ?? locales.en?.[key] ?? fallback ?? key
+}
+
+export function locale() {
+  return current
+}

package/src/overlay/ignore-migrator.ts

@@ -0,0 +1,226 @@
+import * as path from "path"
+import os from "os"
+import * as Log from "@saeeol/core/util/log"
+import type { Config } from "../config/config"
+import type { ConfigPermission } from "../config/permission"
+
+export namespace IgnoreMigrator {
+  const log = Log.create({ service: "saeeol.ignore-migrator" })
+
+  const SAEEOLIGNORE_FILE = ".saeeolignore"
+  const GLOBAL_SAEEOLIGNORE = path.join(os.homedir(), ".saeeol", SAEEOLIGNORE_FILE)
+
+  export interface IgnorePattern {
+    pattern: string
+    negated: boolean
+    source: "global" | "project"
+  }
+
+  export interface MigrationResult {
+    permission: ConfigPermission.Info
+    warnings: string[]
+    patternCount: number
+  }
+
+  async function fileExists(filepath: string): Promise<boolean> {
+    return Bun.file(filepath).exists()
+  }
+
+  /**
+   * Parse .saeeolignore content into patterns.
+   * Follows gitignore syntax:
+   * - Lines starting with # are comments
+   * - Empty lines are ignored
+   * - Lines starting with ! are negation patterns
+   */
+  export function parseIgnoreContent(content: string): Array<{ pattern: string; negated: boolean }> {
+    const patterns: Array<{ pattern: string; negated: boolean }> = []
+
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim()
+
+      // Skip empty lines and comments
+      if (!trimmed || trimmed.startsWith("#")) continue
+
+      // Handle negation patterns
+      if (trimmed.startsWith("!")) {
+        patterns.push({ pattern: trimmed.slice(1), negated: true })
+      } else {
+        patterns.push({ pattern: trimmed, negated: false })
+      }
+    }
+
+    return patterns
+  }
+
+  /**
+   * Convert gitignore pattern to Saeeol wildcard pattern.
+   *
+   * Saeeol's Wildcard module uses simple patterns:
+   * - `*` matches any characters (converted to `.*` regex)
+   * - `?` matches single character
+   *
+   * Gitignore semantics we need to handle:
+   * - `foo/` matches directory and all contents -> `foo/*`
+   * - `*.env` matches anywhere in tree -> `*.env` (already works)
+   * - `/foo` matches only at root -> `foo` (rooted)
+   * - `foo` matches anywhere -> `*foo*` or just `foo` depending on context
+   *
+   * Note: Saeeol's wildcard `*` already matches any path depth because
+   * it's converted to `.*` regex which matches `/` characters.
+   */
+  export function convertToGlob(pattern: string): string {
+    let glob = pattern
+
+    // Directory patterns (ending with /) should match all contents
+    if (glob.endsWith("/")) {
+      glob = glob.slice(0, -1) + "/*"
+    }
+
+    // Patterns starting with / are rooted - remove the leading /
+    if (glob.startsWith("/")) {
+      glob = glob.slice(1)
+    }
+
+    // Remove **/ prefix if present - Saeeol's * already matches paths
+    if (glob.startsWith("**/")) {
+      glob = "*" + glob.slice(3)
+    }
+
+    // Replace **/ in the middle with just *
+    glob = glob.replace(/\*\*\//g, "*")
+
+    // Replace trailing /** with /*
+    if (glob.endsWith("/**")) {
+      glob = glob.slice(0, -3) + "/*"
+    }
+
+    return glob
+  }
+
+  /**
+   * Load patterns from a .saeeolignore file
+   */
+  async function loadIgnoreFile(filepath: string, source: "global" | "project"): Promise<IgnorePattern[]> {
+    if (!(await fileExists(filepath))) return []
+
+    const content = await Bun.file(filepath).text()
+    const parsed = parseIgnoreContent(content)
+
+    return parsed.map((p) => ({
+      pattern: p.pattern,
+      negated: p.negated,
+      source,
+    }))
+  }
+
+  /**
+   * Build permission rules from ignore patterns.
+   *
+   * Order matters! Patterns are evaluated in order:
+   * 1. Start with "*": "allow" (default allow)
+   * 2. Add deny patterns
+   * 3. Add negated patterns (allow) last to override denies
+   */
+  export function buildPermissionRules(patterns: IgnorePattern[]): Record<string, ConfigPermission.Action> {
+    const rules: Record<string, ConfigPermission.Action> = {
+      "*": "allow", // Default: allow all
+    }
+
+    // First pass: add deny rules
+    for (const p of patterns) {
+      if (!p.negated) {
+        const glob = convertToGlob(p.pattern)
+        rules[glob] = "deny"
+      }
+    }
+
+    // Second pass: add negated (allow) rules - these override denies
+    for (const p of patterns) {
+      if (p.negated) {
+        const glob = convertToGlob(p.pattern)
+        rules[glob] = "allow"
+      }
+    }
+
+    return rules
+  }
+
+  /**
+   * Migrate .saeeolignore to Saeeol permission config
+   */
+  export async function migrate(options: { projectDir: string; skipGlobalPaths?: boolean }): Promise<MigrationResult> {
+    const warnings: string[] = []
+    const allPatterns: IgnorePattern[] = []
+
+    // 1. Load global .saeeolignore (lower priority)
+    if (!options.skipGlobalPaths) {
+      const globalPatterns = await loadIgnoreFile(GLOBAL_SAEEOLIGNORE, "global")
+      allPatterns.push(...globalPatterns)
+
+      if (globalPatterns.length > 0) {
+        log.debug("loaded global .saeeolignore", { count: globalPatterns.length })
+      }
+    }
+
+    // 2. Load project .saeeolignore (higher priority - added last)
+    const projectIgnorePath = path.join(options.projectDir, SAEEOLIGNORE_FILE)
+    const projectPatterns = await loadIgnoreFile(projectIgnorePath, "project")
+    allPatterns.push(...projectPatterns)
+
+    if (projectPatterns.length > 0) {
+      log.debug("loaded project .saeeolignore", { count: projectPatterns.length })
+    }
+
+    // 3. Build permission rules
+    if (allPatterns.length === 0) {
+      return {
+        permission: {},
+        warnings,
+        patternCount: 0,
+      }
+    }
+
+    const rules = buildPermissionRules(allPatterns)
+
+    // 4. Create permission config for both read and edit
+    const permission: ConfigPermission.Info = {
+      read: rules,
+      edit: rules,
+    }
+
+    return {
+      permission,
+      warnings,
+      patternCount: allPatterns.length,
+    }
+  }
+
+  /**
+   * Load .saeeolignore and return permission config.
+   * Handles all logging internally.
+   */
+  export async function loadIgnoreConfig(
+    projectDir: string,
+    skipGlobalPaths?: boolean,
+  ): Promise<ConfigPermission.Info> {
+    try {
+      const result = await migrate({ projectDir, skipGlobalPaths })
+
+      if (result.patternCount > 0) {
+        log.info("loaded .saeeolignore patterns", {
+          count: result.patternCount,
+        })
+      }
+
+      for (const warning of result.warnings) {
+        log.warn("ignore migration warning", { warning })
+      }
+
+      return result.permission
+    } catch (err) {
+      log.warn("failed to load .saeeolignore", { error: err })
+      return {}
+    }
+  }
+}

package/src/overlay/index.ts

@@ -0,0 +1,7 @@
+export { ModesMigrator } from "./modes-migrator"
+export { RulesMigrator } from "./rules-migrator"
+export { WorkflowsMigrator } from "./workflows-migrator"
+export { McpMigrator } from "./mcp-migrator"
+export { IgnoreMigrator } from "./ignore-migrator"
+export { SaeeolConfigInjector } from "./config-injector"
+export { SaeeolPaths } from "./paths"

package/src/overlay/indexing-auth.ts

@@ -0,0 +1,114 @@
+type Auth = unknown
+
+type Env = {
+  SAEEOL_API_KEY?: string
+  SAEEOL_ORG_ID?: string
+}
+
+type Provider = {
+  key?: unknown
+  options?: Record<string, unknown>
+}
+
+export type SaeeolIndexingAuth = {
+  apiKey?: string
+  baseUrl?: string
+  organizationId?: string
+}
+
+const providers = [
+  "openai",
+  "ollama",
+  "openai-compatible",
+  "gemini",
+  "mistral",
+  "vercel-ai-gateway",
+  "bedrock",
+  "openrouter",
+  "voyage",
+]
+
+function record(value: unknown): Record<string, unknown> {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return {}
+  return value as Record<string, unknown>
+}
+
+function text(value: unknown): string | undefined {
+  if (typeof value !== "string") return
+  const trimmed = value.trim()
+  return trimmed || undefined
+}
+
+function token(auth: Auth): string | undefined {
+  const data = record(auth)
+  if (data.type === "api") return text(data.key)
+  if (data.type === "oauth") return text(data.access)
+  return
+}
+
+function org(auth: Auth): string | undefined {
+  const data = record(auth)
+  if (data.type === "oauth") return text(data.accountId)
+  return
+}
+
+function value(input: unknown): boolean {
+  if (input === undefined || input === null) return false
+  if (typeof input === "string") return input.trim().length > 0
+  if (typeof input === "object") return Object.values(input).some(value)
+  return true
+}
+
+function hasOtherProvider(indexing: unknown): boolean {
+  const cfg = record(indexing)
+  return providers.some((provider) => value(cfg[provider]))
+}
+
+export function resolveSaeeolIndexingAuth(input: {
+  config?: unknown
+  provider?: Provider
+  auth?: Auth
+  env?: Env
+}): SaeeolIndexingAuth {
+  const config = record(input.config)
+  const options = record(record(config.provider).saeeol)
+  const provider = input.provider ?? record(input.provider)
+  const providerOptions = record(provider.options)
+  const providerConfig = record(options.options)
+  const saeeol = record(record(config.indexing).saeeol)
+  const env = input.env ?? process.env
+
+  return {
+    apiKey:
+      text(saeeol.apiKey) ??
+      text(providerConfig.apiKey) ??
+      token(input.auth) ??
+      text(provider.key) ??
+      text(providerOptions.saeeolToken) ??
+      text(env.SAEEOL_API_KEY),
+    baseUrl: text(saeeol.baseUrl) ?? text(providerConfig.baseURL) ?? text(providerConfig.baseUrl),
+    organizationId:
+      text(saeeol.organizationId) ??
+      text(providerConfig.saeeolOrganizationId) ??
+      org(input.auth) ??
+      text(providerOptions.saeeolOrganizationId) ??
+      text(env.SAEEOL_ORG_ID),
+  }
+}
+
+export function hasSaeeolIndexingAuth(input: Parameters<typeof resolveSaeeolIndexingAuth>[0]): boolean {
+  return !!resolveSaeeolIndexingAuth(input).apiKey
+}
+
+export function shouldDefaultIndexingToSaeeol(indexing: unknown, auth: SaeeolIndexingAuth): boolean {
+  const cfg = record(indexing)
+  if (cfg.provider !== undefined || !auth.apiKey) return false
+  return !hasOtherProvider(cfg)
+}
+
+export function indexingWithSaeeolDefault(config: unknown, auth: SaeeolIndexingAuth) {
+  const cfg = record(config)
+  const indexing = cfg.indexing
+  if (!shouldDefaultIndexingToSaeeol(indexing, auth)) return indexing
+  return { ...record(indexing), provider: "saeeol" }
+}

package/src/overlay/indexing-feature.ts

@@ -0,0 +1,43 @@
+import { pathToFileURL } from "url"
+import { hasIndexingPlugin } from "@saeeol/indexing/detect"
+
+export const INDEXING_PLUGIN = "@saeeol/indexing"
+
+// RATIONALE: Upstream PluginSpec changed from string to string | [string, Record].
+// Use a broad input type to accept both forms but return the concrete PluginSpec shape.
+type PluginSpec = string | [string, Record<string, unknown>]
+
+type ConfigLike = {
+  plugin?: readonly PluginSpec[] | null
+  experimental?: { semantic_indexing?: boolean } | null
+}
+
+type Req = {
+  resolve: (id: string) => string
+}
+
+type LogLike = {
+  debug: (msg: string, data?: Record<string, unknown>) => void
+}
+
+export function indexingEnabled(config?: ConfigLike | null): boolean {
+  return hasIndexingPlugin(config?.plugin ?? []) && config?.experimental?.semantic_indexing === true
+}
+
+export function resolveIndexingPlugin(req: Req, log?: LogLike): string {
+  try {
+    const file = req.resolve(INDEXING_PLUGIN)
+    return pathToFileURL(file).href
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err)
+    log?.debug("failed to resolve indexing plugin package, using package marker", { error })
+    return INDEXING_PLUGIN
+  }
+}
+
+export function ensureIndexingPlugin(items: readonly PluginSpec[], plugin?: string): PluginSpec[] {
+  const plugins = [...items]
+  if (!plugin) return plugins
+  if (hasIndexingPlugin(plugins)) return plugins
+  return [...plugins, plugin]
+}