@farhanic017/octocode 3.5.0

package/src/config/entry-name.ts

@@ -0,0 +1,19 @@
+import path from "path"
+
+// Strips a known prefix from an already-relative path. Callers should pass the
+// path relative to the directory they scanned (e.g. `path.relative(dir, item)`)
+// so the prefix match is anchored. Matching anywhere in an absolute path used
+// to mis-key agents whose home/parent segments coincidentally contained one of
+// the prefix names (see #25713).
+function stripPrefix(relativePath: string, prefixes: string[]) {
+  const normalized = relativePath.replaceAll("\\", "/")
+  for (const prefix of prefixes) {
+    if (normalized.startsWith(prefix)) return normalized.slice(prefix.length)
+  }
+}
+
+export function configEntryNameFromPath(relativePath: string, prefixes: string[]) {
+  const candidate = stripPrefix(relativePath, prefixes) ?? path.basename(relativePath)
+  const ext = path.extname(candidate)
+  return ext.length ? candidate.slice(0, -ext.length) : candidate
+}

package/src/config/managed.ts

@@ -0,0 +1,77 @@
+export * as ConfigManaged from "./managed"
+
+import { existsSync } from "fs"
+import os from "os"
+import path from "path"
+import * as Log from "@octocode-ai/core/util/log"
+import { Process } from "@/util/process"
+
+const log = Log.create({ service: "config" })
+
+const MANAGED_PLIST_DOMAIN = "ai.octocode.managed"
+
+// Keys injected by macOS/MDM into the managed plist that are not octo code config
+const PLIST_META = new Set([
+  "PayloadDisplayName",
+  "PayloadIdentifier",
+  "PayloadType",
+  "PayloadUUID",
+  "PayloadVersion",
+  "_manualProfile",
+])
+
+function systemManagedConfigDir(): string {
+  switch (process.platform) {
+    case "darwin":
+      return "/Library/Application Support/octocode"
+    case "win32":
+      return path.join(process.env.ProgramData || "C:\\ProgramData", "octo")
+    default:
+      return "/etc/octocode"
+  }
+}
+
+export function managedConfigDir() {
+  return process.env.OCTOCODE_TEST_MANAGED_CONFIG_DIR || systemManagedConfigDir()
+}
+
+export function parseManagedPlist(json: string): string {
+  const raw = JSON.parse(json)
+  for (const key of Object.keys(raw)) {
+    if (PLIST_META.has(key)) delete raw[key]
+  }
+  return JSON.stringify(raw)
+}
+
+export async function readManagedPreferences() {
+  if (process.platform !== "darwin") return
+
+  const user = (() => {
+    try {
+      return os.userInfo().username || "user"
+    } catch (err) {
+      log.warn("failed to read system username, using fallback", { err })
+      return "user"
+    }
+  })()
+  const paths = [
+    path.join("/Library/Managed Preferences", user, `${MANAGED_PLIST_DOMAIN}.plist`),
+    path.join("/Library/Managed Preferences", `${MANAGED_PLIST_DOMAIN}.plist`),
+  ]
+
+  for (const plist of paths) {
+    if (!existsSync(plist)) continue
+    log.info("reading macOS managed preferences", { path: plist })
+    const result = await Process.run(["plutil", "-convert", "json", "-o", "-", plist], { nothrow: true })
+    if (result.code !== 0) {
+      log.warn("failed to convert managed preferences plist", { path: plist })
+      continue
+    }
+    return {
+      source: `mobileconfig:${plist}`,
+      text: parseManagedPlist(result.stdout.toString()),
+    }
+  }
+
+  return
+}

package/src/config/markdown.ts

@@ -0,0 +1,36 @@
+import { Filesystem } from "@/util/filesystem"
+import { FrontmatterError } from "@octocode-ai/core/v1/config/error"
+import { ConfigMarkdown as ConfigMarkdownCore } from "@octocode-ai/core/config/markdown"
+
+export const FILE_REGEX = /(?<![\w`])@(\.?[^\s`,.]*(?:\.[^\s`,.]+)*)/g
+export const SHELL_REGEX = /!`([^`]+)`/g
+
+export function files(template: string) {
+  return Array.from(template.matchAll(FILE_REGEX))
+}
+
+export function shell(template: string) {
+  return Array.from(template.matchAll(SHELL_REGEX))
+}
+
+// other coding agents like claude code allow invalid yaml in their
+// frontmatter, we need to fallback to a more permissive parser for those cases
+export const fallbackSanitization = ConfigMarkdownCore.sanitize
+
+export async function parse(filePath: string) {
+  const template = await Filesystem.readText(filePath)
+
+  try {
+    return ConfigMarkdownCore.parse(template)
+  } catch (err) {
+    throw new FrontmatterError(
+      {
+        path: filePath,
+        message: `${filePath}: Failed to parse YAML frontmatter: ${err instanceof Error ? err.message : String(err)}`,
+      },
+      { cause: err },
+    )
+  }
+}
+
+export * as ConfigMarkdown from "./markdown"

package/src/config/parse.ts

@@ -0,0 +1,79 @@
+export * as ConfigParse from "./parse"
+
+import { type ParseError as JsoncParseError, parse as parseJsoncImpl, printParseErrorCode } from "jsonc-parser"
+import { Cause, Exit, Schema as EffectSchema, SchemaIssue } from "effect"
+import type { DeepMutable } from "@octocode-ai/core/schema"
+import { InvalidError, JsonError } from "@octocode-ai/core/v1/config/error"
+
+export function jsonc(text: string, filepath: string): unknown {
+  const errors: JsoncParseError[] = []
+  const data = parseJsoncImpl(text, errors, { allowTrailingComma: true })
+  if (errors.length) {
+    const lines = text.split("\n")
+    const issues = errors
+      .map((e) => {
+        const beforeOffset = text.substring(0, e.offset).split("\n")
+        const line = beforeOffset.length
+        const column = beforeOffset[beforeOffset.length - 1].length + 1
+        const problemLine = lines[line - 1]
+
+        const error = `${printParseErrorCode(e.error)} at line ${line}, column ${column}`
+        if (!problemLine) return error
+
+        return `${error}\n   Line ${line}: ${problemLine}\n${"".padStart(column + 9)}^`
+      })
+      .join("\n")
+    throw new JsonError({
+      path: filepath,
+      message: `\n--- JSONC Input ---\n${text}\n--- Errors ---\n${issues}\n--- End ---`,
+    })
+  }
+
+  return data
+}
+
+export function schema<S extends EffectSchema.Decoder<unknown, never>>(
+  schema: S,
+  data: unknown,
+  source: string,
+): DeepMutable<S["Type"]> {
+  const extra = topLevelExtraKeys(schema, data)
+  if (extra.length) {
+    throw new InvalidError({
+      path: source,
+      issues: [
+        {
+          code: "unrecognized_keys",
+          keys: extra,
+          path: [],
+          message: `Unrecognized key${extra.length === 1 ? "" : "s"}: ${extra.join(", ")}`,
+        },
+      ],
+    })
+  }
+
+  const decoded = EffectSchema.decodeUnknownExit(schema)(data, { errors: "all", propertyOrder: "original" })
+  if (Exit.isSuccess(decoded)) return decoded.value as DeepMutable<S["Type"]>
+  const error = Cause.squash(decoded.cause)
+
+  throw new InvalidError(
+    {
+      path: source,
+      issues: EffectSchema.isSchemaError(error)
+        ? SchemaIssue.makeFormatterStandardSchemaV1()(error.issue).issues.map((issue) => ({
+            ...issue,
+            message: issue.message,
+            path: issue.path?.map(String) ?? [],
+          }))
+        : [{ message: String(error), path: [] }],
+    },
+    { cause: error },
+  )
+}
+
+function topLevelExtraKeys(schema: EffectSchema.Top, data: unknown) {
+  if (typeof data !== "object" || data === null || Array.isArray(data)) return []
+  if (schema.ast._tag !== "Objects" || schema.ast.indexSignatures.length > 0) return []
+  const known = new Set(schema.ast.propertySignatures.map((item) => String(item.name)))
+  return Object.keys(data).filter((key) => !known.has(key))
+}

package/src/config/paths.ts

@@ -0,0 +1,47 @@
+export * as ConfigPaths from "./paths"
+
+import path from "path"
+import { Flag } from "@octocode-ai/core/flag/flag"
+import { Global } from "@octocode-ai/core/global"
+import { unique } from "remeda"
+import * as Effect from "effect/Effect"
+import { FSUtil } from "@octocode-ai/core/fs-util"
+
+export const files = Effect.fn("ConfigPaths.projectFiles")(function* (
+  name: string,
+  directory: string,
+  worktree?: string,
+) {
+  const afs = yield* FSUtil.Service
+  const names = name === "octo" ? ["octo", "octocode"] : [name]
+  return (yield* afs.up({
+    targets: names.flatMap((item) => [`${item}.jsonc`, `${item}.json`]),
+    start: directory,
+    stop: worktree,
+  })).toReversed()
+})
+
+export const directories = Effect.fn("ConfigPaths.directories")(function* (directory: string, worktree?: string) {
+  const afs = yield* FSUtil.Service
+  return unique([
+    Global.Path.config,
+    ...(!Flag.OCTOCODE_DISABLE_PROJECT_CONFIG
+      ? yield* afs.up({
+          targets: [".octo", ".octocode"],
+          start: directory,
+          stop: worktree,
+        })
+      : []),
+    ...(yield* afs.up({
+      targets: [".octo", ".octocode"],
+      start: Global.Path.home,
+      stop: Global.Path.home,
+    })),
+    ...(Flag.OCTOCODE_CONFIG_DIR ? [Flag.OCTOCODE_CONFIG_DIR] : []),
+  ])
+})
+
+export function fileInDirectory(dir: string, name: string) {
+  const names = name === "octo" ? ["octo", "octo"] : [name]
+  return names.flatMap((item) => [path.join(dir, `${item}.json`), path.join(dir, `${item}.jsonc`)])
+}

package/src/config/plugin.ts

@@ -0,0 +1,79 @@
+import { Glob } from "@octocode-ai/core/util/glob"
+import { ConfigPluginV1 } from "@octocode-ai/core/v1/config/plugin"
+import { pathToFileURL } from "url"
+import { isPathPluginSpec, parsePluginSpecifier, resolvePathPluginTarget } from "@/plugin/shared"
+import path from "path"
+
+export type Scope = "global" | "local"
+
+// Origin keeps the original config provenance attached to a spec.
+// After multiple config files are merged, callers still need to know which file declared the plugin
+// and whether it should behave like a global or project-local plugin.
+export type Origin = {
+  spec: ConfigPluginV1.Spec
+  source: string
+  scope: Scope
+}
+
+export async function load(dir: string) {
+  const plugins: ConfigPluginV1.Spec[] = []
+
+  for (const item of await Glob.scan("{plugin,plugins}/*.{ts,js}", {
+    cwd: dir,
+    absolute: true,
+    dot: true,
+    symlink: true,
+  })) {
+    plugins.push(pathToFileURL(item).href)
+  }
+  return plugins
+}
+
+export function pluginSpecifier(plugin: ConfigPluginV1.Spec): string {
+  return Array.isArray(plugin) ? plugin[0] : plugin
+}
+
+export function pluginOptions(plugin: ConfigPluginV1.Spec): ConfigPluginV1.Options | undefined {
+  return Array.isArray(plugin) ? plugin[1] : undefined
+}
+
+// Path-like specs are resolved relative to the config file that declared them so merges later on do not
+// accidentally reinterpret `./plugin.ts` relative to some other directory.
+export async function resolvePluginSpec(
+  plugin: ConfigPluginV1.Spec,
+  configFilepath: string,
+): Promise<ConfigPluginV1.Spec> {
+  const spec = pluginSpecifier(plugin)
+  if (!isPathPluginSpec(spec)) return plugin
+
+  const base = path.dirname(configFilepath)
+  const file = (() => {
+    if (spec.startsWith("file://")) return spec
+    if (path.isAbsolute(spec) || /^[A-Za-z]:[\\/]/.test(spec)) return pathToFileURL(spec).href
+    return pathToFileURL(path.resolve(base, spec)).href
+  })()
+
+  const resolved = await resolvePathPluginTarget(file).catch(() => file)
+
+  if (Array.isArray(plugin)) return [resolved, plugin[1]]
+  return resolved
+}
+
+// Dedupe on the load identity (package name for npm specs, exact file URL for local specs), but keep the
+// full Origin so downstream code still knows which config file won and where follow-up writes should go.
+export function deduplicatePluginOrigins(plugins: Origin[]): Origin[] {
+  const seen = new Set<string>()
+  const list: Origin[] = []
+
+  for (const plugin of plugins.toReversed()) {
+    const spec = pluginSpecifier(plugin.spec)
+    const name = spec.startsWith("file://") ? spec : parsePluginSpecifier(spec).pkg
+    if (seen.has(name)) continue
+    seen.add(name)
+    list.push(plugin)
+  }
+
+  return list.toReversed()
+}
+
+export * as ConfigPlugin from "./plugin"

package/src/config/reference.ts

@@ -0,0 +1,48 @@
+export * as ConfigReference from "./reference"
+
+import { ConfigReferenceV1 } from "@octocode-ai/core/v1/config/reference"
+
+export type NormalizedEntry =
+  | {
+      kind: "local"
+      path: string
+    }
+  | {
+      kind: "git"
+      repository: string
+      branch?: string
+    }
+  | {
+      kind: "invalid"
+      message: string
+    }
+
+export type NormalizedInfo = Record<string, NormalizedEntry>
+
+export function validateAlias(name: string) {
+  if (name.length === 0) return "Reference alias must not be empty"
+  if (/[\/\s`,]/.test(name)) {
+    return "Reference alias must not contain /, whitespace, comma, or backtick"
+  }
+}
+
+export function normalizeEntry(entry: ConfigReferenceV1.Entry): NormalizedEntry {
+  if (typeof entry === "string") {
+    if (entry.startsWith(".") || entry.startsWith("/") || entry.startsWith("~")) {
+      return { kind: "local", path: entry }
+    }
+    return { kind: "git", repository: entry }
+  }
+
+  if ("path" in entry) return { kind: "local", path: entry.path }
+  return { kind: "git", repository: entry.repository, branch: entry.branch }
+}
+
+export function normalize(info: ConfigReferenceV1.Info): NormalizedInfo {
+  return Object.fromEntries(
+    Object.entries(info).map(([name, entry]) => {
+      const aliasError = validateAlias(name)
+      return [name, aliasError ? { kind: "invalid" as const, message: aliasError } : normalizeEntry(entry)] as const
+    }),
+  )
+}

package/src/config/tui-cwd.ts

@@ -0,0 +1,5 @@
+import { Context } from "effect"
+
+export const CurrentWorkingDirectory = Context.Reference<string>("CurrentWorkingDirectory", {
+  defaultValue: () => process.cwd(),
+})

package/src/config/tui-host-attention.ts

@@ -0,0 +1,21 @@
+import { TuiConfig } from "@octocode-ai/tui/config"
+import { isRecord } from "@octocode-ai/tui/util/record"
+import { Filesystem } from "@/util/filesystem"
+import { Schema } from "effect"
+
+export function resolveHostAttentionSoundPaths(
+  root: string,
+  sounds: unknown,
+  options?: { trim?: boolean },
+): TuiConfig.AttentionSoundPaths {
+  if (!isRecord(sounds)) return {}
+  return Object.fromEntries(
+    Object.entries(sounds).flatMap(([name, file]) => {
+      if (!Schema.is(TuiConfig.AttentionSoundName)(name)) return []
+      if (typeof file !== "string") return []
+      const value = options?.trim ? file.trim() : file
+      if (!value) return []
+      return [[name, Filesystem.resolveFilePath(root, value)]]
+    }),
+  )
+}

package/src/config/tui-migrate.ts

@@ -0,0 +1,156 @@
+import path from "path"
+import { type ParseError as JsoncParseError, applyEdits, modify, parse as parseJsonc } from "jsonc-parser"
+import { unique } from "remeda"
+import { Option, Schema } from "effect"
+import { TuiConfig } from "@octocode-ai/tui/config"
+import { Flag } from "@octocode-ai/core/flag/flag"
+import { Global } from "@octocode-ai/core/global"
+import { Filesystem } from "@/util/filesystem"
+import * as Log from "@octocode-ai/core/util/log"
+import * as ConfigPaths from "@/config/paths"
+
+const log = Log.create({ service: "tui.migrate" })
+
+const TUI_SCHEMA_URL = "https://octocode.ai/tui.json"
+
+const decodeTheme = Schema.decodeUnknownOption(Schema.String)
+const decodeRecord = Schema.decodeUnknownOption(Schema.Record(Schema.String, Schema.Unknown))
+const decodeScrollSpeed = Schema.decodeUnknownOption(TuiConfig.ScrollSpeed)
+const decodeScrollAcceleration = Schema.decodeUnknownOption(TuiConfig.ScrollAcceleration)
+const decodeDiffStyle = Schema.decodeUnknownOption(TuiConfig.DiffStyle)
+
+interface MigrateInput {
+  cwd: string
+  directories: string[]
+}
+
+/**
+ * Migrates tui-specific keys (theme, keybinds, tui) from octo/octocode config files
+ * into dedicated tui.json files. Migration is performed per-directory and
+ * skips only locations where a tui.json already exists.
+ */
+export async function migrateTuiConfig(input: MigrateInput) {
+  const configFiles = await octocodeFiles(input)
+  for (const file of configFiles) {
+    const source = await Filesystem.readText(file).catch((error) => {
+      log.warn("failed to read config for tui migration", { path: file, error })
+      return undefined
+    })
+    if (!source) continue
+    const errors: JsoncParseError[] = []
+    const data = parseJsonc(source, errors, { allowTrailingComma: true })
+    if (errors.length || !data || typeof data !== "object" || Array.isArray(data)) continue
+
+    const theme = decodeTheme("theme" in data ? data.theme : undefined)
+    const keybinds = decodeRecord("keybinds" in data ? data.keybinds : undefined)
+    const legacyTui = decodeRecord("tui" in data ? data.tui : undefined)
+    const extracted = {
+      theme: Option.getOrUndefined(theme),
+      keybinds: Option.getOrUndefined(keybinds),
+      tui: Option.getOrUndefined(legacyTui),
+    }
+    const tui = extracted.tui ? normalizeTui(extracted.tui) : undefined
+    if (extracted.theme === undefined && extracted.keybinds === undefined && !tui) continue
+
+    const target = path.join(path.dirname(file), "tui.json")
+    const targetExists = await Filesystem.exists(target)
+    if (targetExists) continue
+
+    const payload: Record<string, unknown> = {
+      $schema: TUI_SCHEMA_URL,
+    }
+    if (extracted.theme !== undefined) payload.theme = extracted.theme
+    if (extracted.keybinds !== undefined) payload.keybinds = extracted.keybinds
+    if (tui) Object.assign(payload, tui)
+
+    const wrote = await Filesystem.write(target, JSON.stringify(payload, null, 2))
+      .then(() => true)
+      .catch((error) => {
+        log.warn("failed to write tui migration target", { from: file, to: target, error })
+        return false
+      })
+    if (!wrote) continue
+
+    const stripped = await backupAndStripLegacy(file, source)
+    if (!stripped) {
+      log.warn("tui config migrated but source file was not stripped", { from: file, to: target })
+      continue
+    }
+    log.info("migrated tui config", { from: file, to: target })
+  }
+}
+
+function normalizeTui(data: Record<string, unknown>):
+  | {
+      scroll_speed: number | undefined
+      scroll_acceleration: { enabled: boolean } | undefined
+      diff_style: "auto" | "stacked" | undefined
+    }
+  | undefined {
+  const parsed = {
+    scroll_speed: Option.getOrUndefined(decodeScrollSpeed(data.scroll_speed)),
+    scroll_acceleration: Option.getOrUndefined(decodeScrollAcceleration(data.scroll_acceleration)),
+    diff_style: Option.getOrUndefined(decodeDiffStyle(data.diff_style)),
+  }
+  return parsed.scroll_speed === undefined &&
+    parsed.diff_style === undefined &&
+    parsed.scroll_acceleration === undefined
+    ? undefined
+    : parsed
+}
+
+async function backupAndStripLegacy(file: string, source: string) {
+  const backup = file + ".tui-migration.bak"
+  const hasBackup = await Filesystem.exists(backup)
+  const backed = hasBackup
+    ? true
+    : await Filesystem.write(backup, source)
+        .then(() => true)
+        .catch((error) => {
+          log.warn("failed to backup source config during tui migration", { path: file, backup, error })
+          return false
+        })
+  if (!backed) return false
+
+  const text = ["theme", "keybinds", "tui"].reduce((acc, key) => {
+    const edits = modify(acc, [key], undefined, {
+      formattingOptions: {
+        insertSpaces: true,
+        tabSize: 2,
+      },
+    })
+    if (!edits.length) return acc
+    return applyEdits(acc, edits)
+  }, source)
+
+  return Filesystem.write(file, text)
+    .then(() => {
+      log.info("stripped tui keys from server config", { path: file, backup })
+      return true
+    })
+    .catch((error) => {
+      log.warn("failed to strip legacy tui keys from server config", { path: file, backup, error })
+      return false
+    })
+}
+
+async function octocodeFiles(input: { directories: string[]; cwd: string }) {
+  const files = [
+    ...ConfigPaths.fileInDirectory(Global.Path.config, "octo"),
+    ...(await Filesystem.findUp(["octo.json", "octo.jsonc", "octocode.json", "octocode.jsonc"], input.cwd, undefined, {
+      rootFirst: true,
+    })),
+  ]
+  for (const dir of unique(input.directories)) {
+    files.push(...ConfigPaths.fileInDirectory(dir, "octo"))
+  }
+  if (Flag.OCTOCODE_CONFIG) files.push(Flag.OCTOCODE_CONFIG)
+
+  const existing = await Promise.all(
+    unique(files).map(async (file) => {
+      const ok = await Filesystem.exists(file)
+      return ok ? file : undefined
+    }),
+  )
+  return existing.filter((file): file is string => !!file)
+}