soraacode 0.2.0 → 0.2.1

package/src/config/entry-name.ts

@@ -1,19 +0,0 @@
-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

@@ -1,69 +0,0 @@
-export * as ConfigManaged from "./managed"
-
-import { existsSync } from "fs"
-import os from "os"
-import path from "path"
-import { Process } from "@/util/process"
-
-const MANAGED_PLIST_DOMAIN = "ai.opencode.managed"
-
-// Keys injected by macOS/MDM into the managed plist that are not OpenCode config
-const PLIST_META = new Set([
-  "PayloadDisplayName",
-  "PayloadIdentifier",
-  "PayloadType",
-  "PayloadUUID",
-  "PayloadVersion",
-  "_manualProfile",
-])
-
-function systemManagedConfigDir(): string {
-  switch (process.platform) {
-    case "darwin":
-      return "/Library/Application Support/opencode"
-    case "win32":
-      return path.join(process.env.ProgramData || "C:\\ProgramData", "opencode")
-    default:
-      return "/etc/opencode"
-  }
-}
-
-export function managedConfigDir() {
-  return process.env.OPENCODE_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 {
-      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
-    const result = await Process.run(["plutil", "-convert", "json", "-o", "-", plist], { nothrow: true })
-    if (result.code !== 0) continue
-    return {
-      source: `mobileconfig:${plist}`,
-      text: parseManagedPlist(result.stdout.toString()),
-    }
-  }
-
-  return
-}

package/src/config/markdown.ts

@@ -1,36 +0,0 @@
-import { Filesystem } from "@/util/filesystem"
-import { FrontmatterError } from "@soraacode/core/v1/config/error"
-import { ConfigMarkdown as ConfigMarkdownCore } from "@soraacode/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

@@ -1,61 +0,0 @@
-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 "@soraacode/core/schema"
-import { InvalidError, JsonError } from "@soraacode/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 decoded = EffectSchema.decodeUnknownExit(schema)(data, {
-    errors: "all",
-    onExcessProperty: "ignore",
-    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 },
-  )
-}

package/src/config/paths.ts

@@ -1,45 +0,0 @@
-export * as ConfigPaths from "./paths"
-
-import path from "path"
-import { Flag } from "@soraacode/core/flag/flag"
-import { Global } from "@soraacode/core/global"
-import { unique } from "remeda"
-import * as Effect from "effect/Effect"
-import { FSUtil } from "@soraacode/core/fs-util"
-
-export const files = Effect.fn("ConfigPaths.projectFiles")(function* (
-  name: string,
-  directory: string,
-  worktree?: string,
-) {
-  const afs = yield* FSUtil.Service
-  return (yield* afs.up({
-    targets: [`${name}.jsonc`, `${name}.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.OPENCODE_DISABLE_PROJECT_CONFIG
-      ? yield* afs.up({
-          targets: [".opencode"],
-          start: directory,
-          stop: worktree,
-        })
-      : []),
-    ...(yield* afs.up({
-      targets: [".opencode"],
-      start: Global.Path.home,
-      stop: Global.Path.home,
-    })),
-    ...(Flag.OPENCODE_CONFIG_DIR ? [Flag.OPENCODE_CONFIG_DIR] : []),
-  ])
-})
-
-export function fileInDirectory(dir: string, name: string) {
-  return [path.join(dir, `${name}.json`), path.join(dir, `${name}.jsonc`)]
-}

package/src/config/plugin.ts

@@ -1,79 +0,0 @@
-import { Glob } from "@soraacode/core/util/glob"
-import { ConfigPluginV1 } from "@soraacode/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"