@opendash-ai/cli 0.1.0-beta.1 → 0.1.0-beta.3

package/src/config/parse.ts

@@ -1,44 +0,0 @@
-export * as ConfigParse from "./parse"
-
-import { type ParseError as JsoncParseError, parse as parseJsoncImpl, printParseErrorCode } from "jsonc-parser"
-import z from "zod"
-import { InvalidError, JsonError } from "./error"
-
-type Schema<T> = z.ZodType<T>
-
-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<T>(schema: Schema<T>, data: unknown, source: string): T {
-  const parsed = schema.safeParse(data)
-  if (parsed.success) return parsed.data
-
-  throw new InvalidError({
-    path: source,
-    issues: parsed.error.issues,
-  })
-}

package/src/config/paths.ts

@@ -1,73 +0,0 @@
-export * as ConfigPaths from "./paths"
-
-import path from "path"
-import { Filesystem } from "@/util"
-import { Flag } from "@/flag/flag"
-import { Global } from "@/global"
-import { unique } from "remeda"
-import { JsonError } from "./error"
-import * as Effect from "effect/Effect"
-import { AppFileSystem } from "@opendash-ai/shared/filesystem"
-
-export const files = Effect.fn("ConfigPaths.projectFiles")(function* (
-  name: string,
-  directory: string,
-  worktree?: string,
-) {
-  const afs = yield* AppFileSystem.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* AppFileSystem.Service
-  return unique([
-    Global.Path.config,
-    ...(!Flag.OPENDASH_DISABLE_PROJECT_CONFIG
-      ? yield* afs.up({
-          targets: [".opendash"],
-          start: directory,
-          stop: worktree,
-        })
-      : []),
-    ...(yield* afs.up({
-      targets: [".opendash"],
-      start: Global.Path.home,
-      stop: Global.Path.home,
-    })),
-    ...(Flag.OPENDASH_CONFIG_DIR ? [Flag.OPENDASH_CONFIG_DIR] : []),
-  ])
-})
-
-export const claudeCommandDirectories = Effect.fn("ConfigPaths.claudeCommandDirectories")(function* (
-  directory: string,
-  worktree?: string,
-) {
-  if (Flag.OPENDASH_DISABLE_CLAUDE_CODE_COMMANDS) return []
-  const afs = yield* AppFileSystem.Service
-  return unique([
-    path.join(Global.Path.home, ".claude"),
-    ...(!Flag.OPENDASH_DISABLE_PROJECT_CONFIG
-      ? yield* afs.up({
-          targets: [".claude"],
-          start: directory,
-          stop: worktree,
-        })
-      : []),
-  ])
-})
-
-export function fileInDirectory(dir: string, name: string) {
-  return [path.join(dir, `${name}.json`), path.join(dir, `${name}.jsonc`)]
-}
-
-/** Read a config file, returning undefined for missing files and throwing JsonError for other failures. */
-export async function readFile(filepath: string) {
-  return Filesystem.readText(filepath).catch((err: NodeJS.ErrnoException) => {
-    if (err.code === "ENOENT") return
-    throw new JsonError({ path: filepath }, { cause: err })
-  })
-}

package/src/config/permission.ts

@@ -1,76 +0,0 @@
-export * as ConfigPermission from "./permission"
-import { Schema } from "effect"
-import { zod, ZodPreprocess } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const Action = Schema.Literals(["ask", "allow", "deny"])
-  .annotate({ identifier: "PermissionActionConfig" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Action = Schema.Schema.Type<typeof Action>
-
-export const Object = Schema.Record(Schema.String, Action)
-  .annotate({ identifier: "PermissionObjectConfig" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Object = Schema.Schema.Type<typeof Object>
-
-export const Rule = Schema.Union([Action, Object])
-  .annotate({ identifier: "PermissionRuleConfig" })
-  .pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Rule = Schema.Schema.Type<typeof Rule>
-
-// Captures the user's original property insertion order before Schema.Struct
-// canonicalises the object.  See the `ZodPreprocess` comment in
-// `util/effect-zod.ts` for the full rationale — in short: rule precedence is
-// encoded in JSON key order (`evaluate.ts` uses `findLast`, so later keys win)
-// and `Schema.StructWithRest` would otherwise drop that order.
-const permissionPreprocess = (val: unknown) => {
-  if (typeof val === "object" && val !== null && !Array.isArray(val)) {
-    return { __originalKeys: globalThis.Object.keys(val), ...val }
-  }
-  return val
-}
-
-const ObjectShape = Schema.StructWithRest(
-  Schema.Struct({
-    __originalKeys: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-    read: Schema.optional(Rule),
-    edit: Schema.optional(Rule),
-    glob: Schema.optional(Rule),
-    grep: Schema.optional(Rule),
-    list: Schema.optional(Rule),
-    bash: Schema.optional(Rule),
-    task: Schema.optional(Rule),
-    actor: Schema.optional(Rule),
-    external_directory: Schema.optional(Rule),
-    question: Schema.optional(Action),
-    webfetch: Schema.optional(Action),
-    websearch: Schema.optional(Action),
-    codesearch: Schema.optional(Action),
-    lsp: Schema.optional(Rule),
-    doom_loop: Schema.optional(Action),
-    skill: Schema.optional(Rule),
-  }),
-  [Schema.Record(Schema.String, Rule)],
-)
-
-const InnerSchema = Schema.Union([ObjectShape, Action]).annotate({
-  [ZodPreprocess]: permissionPreprocess,
-})
-
-// Post-parse: drop the __originalKeys metadata and rebuild the rule map in the
-// user's original insertion order.  A plain string input (the Action branch of
-// the union) becomes `{ "*": action }`.
-const transform = (x: unknown): Record<string, Rule> => {
-  if (typeof x === "string") return { "*": x as Action }
-  const obj = x as { __originalKeys?: string[] } & Record<string, unknown>
-  const { __originalKeys, ...rest } = obj
-  if (!__originalKeys) return rest as Record<string, Rule>
-  const result: Record<string, Rule> = {}
-  for (const key of __originalKeys) {
-    if (key in rest) result[key] = rest[key] as Rule
-  }
-  return result
-}
-
-export const Info = zod(InnerSchema).transform(transform).meta({ ref: "PermissionConfig" })
-export type Info = Record<string, Rule>

package/src/config/plugin.ts

@@ -1,88 +0,0 @@
-import { Glob } from "@opendash-ai/shared/util/glob"
-import { Schema } from "effect"
-import { pathToFileURL } from "url"
-import { isPathPluginSpec, parsePluginSpecifier, resolvePathPluginTarget } from "@/plugin/shared"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-import path from "path"
-
-export const Options = Schema.Record(Schema.String, Schema.Unknown).pipe(withStatics((s) => ({ zod: zod(s) })))
-export type Options = Schema.Schema.Type<typeof Options>
-
-// Spec is the user-config value: either just a plugin identifier, or the identifier plus inline options.
-// It answers "what should we load?" but says nothing about where that value came from.
-export const Spec = Schema.Union([Schema.String, Schema.mutable(Schema.Tuple([Schema.String, Options]))]).pipe(
-  withStatics((s) => ({ zod: zod(s) })),
-)
-export type Spec = Schema.Schema.Type<typeof Spec>
-
-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: Spec
-  source: string
-  scope: Scope
-}
-
-export async function load(dir: string) {
-  const plugins: 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: Spec): string {
-  return Array.isArray(plugin) ? plugin[0] : plugin
-}
-
-export function pluginOptions(plugin: Spec): 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: Spec, configFilepath: string): Promise<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/provider.ts

@@ -1,118 +0,0 @@
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-const PositiveInt = Schema.Number.check(Schema.isInt()).check(Schema.isGreaterThan(0))
-
-export const Model = Schema.Struct({
-  id: Schema.optional(Schema.String),
-  name: Schema.optional(Schema.String),
-  family: Schema.optional(Schema.String),
-  release_date: Schema.optional(Schema.String),
-  attachment: Schema.optional(Schema.Boolean),
-  reasoning: Schema.optional(Schema.Boolean),
-  temperature: Schema.optional(Schema.Boolean),
-  tool_call: Schema.optional(Schema.Boolean),
-  interleaved: Schema.optional(
-    Schema.Union([
-      Schema.Literal(true),
-      Schema.Struct({
-        field: Schema.Literals(["reasoning_content", "reasoning_details"]),
-      }),
-    ]),
-  ),
-  cost: Schema.optional(
-    Schema.Struct({
-      input: Schema.Number,
-      output: Schema.Number,
-      cache_read: Schema.optional(Schema.Number),
-      cache_write: Schema.optional(Schema.Number),
-      context_over_200k: Schema.optional(
-        Schema.Struct({
-          input: Schema.Number,
-          output: Schema.Number,
-          cache_read: Schema.optional(Schema.Number),
-          cache_write: Schema.optional(Schema.Number),
-        }),
-      ),
-    }),
-  ),
-  limit: Schema.optional(
-    Schema.Struct({
-      context: Schema.Number,
-      input: Schema.optional(Schema.Number),
-      output: Schema.Number,
-    }),
-  ),
-  modalities: Schema.optional(
-    Schema.Struct({
-      input: Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"]))),
-      output: Schema.mutable(Schema.Array(Schema.Literals(["text", "audio", "image", "video", "pdf"]))),
-    }),
-  ),
-  experimental: Schema.optional(Schema.Boolean),
-  status: Schema.optional(Schema.Literals(["alpha", "beta", "deprecated"])),
-  cachePromptTTL: Schema.optional(Schema.Literals(["5m", "1h"])).annotate({
-    description:
-      "Prompt-cache breakpoint TTL for Anthropic/OpenRouter. '1h' keeps the cached prefix alive for one hour (2x write cost) instead of the 5m default. Ignored by providers whose SDK doesn't support a cache TTL.",
-  }),
-  provider: Schema.optional(
-    Schema.Struct({ npm: Schema.optional(Schema.String), api: Schema.optional(Schema.String) }),
-  ),
-  options: Schema.optional(Schema.Record(Schema.String, Schema.Any)),
-  headers: Schema.optional(Schema.Record(Schema.String, Schema.String)),
-  variants: Schema.optional(
-    Schema.Record(
-      Schema.String,
-      Schema.StructWithRest(
-        Schema.Struct({
-          disabled: Schema.optional(Schema.Boolean).annotate({ description: "Disable this variant for the model" }),
-        }),
-        [Schema.Record(Schema.String, Schema.Any)],
-      ),
-    ).annotate({ description: "Variant-specific configuration" }),
-  ),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export class Info extends Schema.Class<Info>("ProviderConfig")({
-  api: Schema.optional(Schema.String),
-  name: Schema.optional(Schema.String),
-  env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-  id: Schema.optional(Schema.String),
-  npm: Schema.optional(Schema.String),
-  whitelist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-  blacklist: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
-  options: Schema.optional(
-    Schema.StructWithRest(
-      Schema.Struct({
-        apiKey: Schema.optional(Schema.String),
-        baseURL: Schema.optional(Schema.String),
-        enterpriseUrl: Schema.optional(Schema.String).annotate({
-          description: "GitHub Enterprise URL for copilot authentication",
-        }),
-        setCacheKey: Schema.optional(Schema.Boolean).annotate({
-          description: "Enable promptCacheKey for this provider (default false)",
-        }),
-        timeout: Schema.optional(
-          Schema.Union([PositiveInt, Schema.Literal(false)]).annotate({
-            description:
-              "Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.",
-          }),
-        ).annotate({
-          description:
-            "Timeout in milliseconds for requests to this provider. Default is 300000 (5 minutes). Set to false to disable timeout.",
-        }),
-        chunkTimeout: Schema.optional(PositiveInt).annotate({
-          description:
-            "Timeout in milliseconds between streamed SSE chunks for this provider. If no chunk arrives within this window, the request is aborted.",
-        }),
-      }),
-      [Schema.Record(Schema.String, Schema.Any)],
-    ),
-  ),
-  models: Schema.optional(Schema.Record(Schema.String, Model)),
-}) {
-  static readonly zod = zod(this)
-}
-
-export * as ConfigProvider from "./provider"

package/src/config/server.ts

@@ -1,20 +0,0 @@
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-
-export class Server extends Schema.Class<Server>("ServerConfig")({
-  port: Schema.optional(Schema.Number.check(Schema.isInt()).check(Schema.isGreaterThan(0))).annotate({
-    description: "Port to listen on",
-  }),
-  hostname: Schema.optional(Schema.String).annotate({ description: "Hostname to listen on" }),
-  mdns: Schema.optional(Schema.Boolean).annotate({ description: "Enable mDNS service discovery" }),
-  mdnsDomain: Schema.optional(Schema.String).annotate({
-    description: "Custom domain name for mDNS service (default: opendash.local)",
-  }),
-  cors: Schema.optional(Schema.mutable(Schema.Array(Schema.String))).annotate({
-    description: "Additional domains to allow for CORS",
-  }),
-}) {
-  static readonly zod = zod(this)
-}
-
-export * as ConfigServer from "./server"

package/src/config/skills.ts

@@ -1,16 +0,0 @@
-import { Schema } from "effect"
-import { zod } from "@/util/effect-zod"
-import { withStatics } from "@/util/schema"
-
-export const Info = Schema.Struct({
-  paths: Schema.optional(Schema.Array(Schema.String)).annotate({
-    description: "Additional paths to skill folders",
-  }),
-  urls: Schema.optional(Schema.Array(Schema.String)).annotate({
-    description: "URLs to fetch skills from (e.g., https://example.com/.well-known/skills/)",
-  }),
-}).pipe(withStatics((s) => ({ zod: zod(s) })))
-
-export type Info = Schema.Schema.Type<typeof Info>
-
-export * as ConfigSkills from "./skills"

package/src/config/variable.ts

@@ -1,90 +0,0 @@
-export * as ConfigVariable from "./variable"
-
-import path from "path"
-import os from "os"
-import { Filesystem } from "@/util"
-import { InvalidError } from "./error"
-
-type ParseSource =
-  | {
-      type: "path"
-      path: string
-    }
-  | {
-      type: "virtual"
-      source: string
-      dir: string
-    }
-
-type SubstituteInput = ParseSource & {
-  text: string
-  missing?: "error" | "empty"
-}
-
-function source(input: ParseSource) {
-  return input.type === "path" ? input.path : input.source
-}
-
-function dir(input: ParseSource) {
-  return input.type === "path" ? path.dirname(input.path) : input.dir
-}
-
-/** Apply {env:VAR} and {file:path} substitutions to config text. */
-export async function substitute(input: SubstituteInput) {
-  const missing = input.missing ?? "error"
-  let text = input.text.replace(/\{env:([^}]+)\}/g, (_, varName) => {
-    return process.env[varName] || ""
-  })
-
-  const fileMatches = Array.from(text.matchAll(/\{file:[^}]+\}/g))
-  if (!fileMatches.length) return text
-
-  const configDir = dir(input)
-  const configSource = source(input)
-  let out = ""
-  let cursor = 0
-
-  for (const match of fileMatches) {
-    const token = match[0]
-    const index = match.index!
-    out += text.slice(cursor, index)
-
-    const lineStart = text.lastIndexOf("\n", index - 1) + 1
-    const prefix = text.slice(lineStart, index).trimStart()
-    if (prefix.startsWith("//")) {
-      out += token
-      cursor = index + token.length
-      continue
-    }
-
-    let filePath = token.replace(/^\{file:/, "").replace(/\}$/, "")
-    if (filePath.startsWith("~/")) {
-      filePath = path.join(os.homedir(), filePath.slice(2))
-    }
-
-    const resolvedPath = path.isAbsolute(filePath) ? filePath : path.resolve(configDir, filePath)
-    const fileContent = (
-      await Filesystem.readText(resolvedPath).catch((error: NodeJS.ErrnoException) => {
-        if (missing === "empty") return ""
-
-        const errMsg = `bad file reference: "${token}"`
-        if (error.code === "ENOENT") {
-          throw new InvalidError(
-            {
-              path: configSource,
-              message: errMsg + ` ${resolvedPath} does not exist`,
-            },
-            { cause: error },
-          )
-        }
-        throw new InvalidError({ path: configSource, message: errMsg }, { cause: error })
-      })
-    ).trim()
-
-    out += JSON.stringify(fileContent).slice(1, -1)
-    cursor = index + token.length
-  }
-
-  out += text.slice(cursor)
-  return out
-}

package/src/control-plane/adaptors/index.ts

@@ -1,52 +0,0 @@
-import { lazy } from "@/util/lazy"
-import type { ProjectID } from "@/project/schema"
-import type { WorkspaceAdaptor } from "../types"
-
-export type WorkspaceAdaptorEntry = {
-  type: string
-  name: string
-  description: string
-}
-
-const BUILTIN: Record<string, () => Promise<WorkspaceAdaptor>> = {
-  worktree: lazy(async () => (await import("./worktree")).WorktreeAdaptor),
-}
-
-const state = new Map<ProjectID, Map<string, WorkspaceAdaptor>>()
-
-export async function getAdaptor(projectID: ProjectID, type: string): Promise<WorkspaceAdaptor> {
-  const custom = state.get(projectID)?.get(type)
-  if (custom) return custom
-
-  const builtin = BUILTIN[type]
-  if (builtin) return builtin()
-
-  throw new Error(`Unknown workspace adaptor: ${type}`)
-}
-
-export async function listAdaptors(projectID: ProjectID): Promise<WorkspaceAdaptorEntry[]> {
-  const builtin = await Promise.all(
-    Object.entries(BUILTIN).map(async ([type, init]) => {
-      const adaptor = await init()
-      return {
-        type,
-        name: adaptor.name,
-        description: adaptor.description,
-      }
-    }),
-  )
-  const custom = [...(state.get(projectID)?.entries() ?? [])].map(([type, adaptor]) => ({
-    type,
-    name: adaptor.name,
-    description: adaptor.description,
-  }))
-  return [...builtin, ...custom]
-}
-
-// Plugins can be loaded per-project so we need to scope them. If you
-// want to install a global one pass `ProjectID.global`
-export function registerAdaptor(projectID: ProjectID, type: string, adaptor: WorkspaceAdaptor) {
-  const adaptors = state.get(projectID) ?? new Map<string, WorkspaceAdaptor>()
-  adaptors.set(type, adaptor)
-  state.set(projectID, adaptors)
-}

package/src/control-plane/adaptors/worktree.ts

@@ -1,47 +0,0 @@
-import z from "zod"
-import { AppRuntime } from "@/effect/app-runtime"
-import { Worktree } from "@/worktree"
-import { type WorkspaceAdaptor, WorkspaceInfo } from "../types"
-
-const WorktreeConfig = z.object({
-  name: WorkspaceInfo.shape.name,
-  branch: WorkspaceInfo.shape.branch.unwrap(),
-  directory: WorkspaceInfo.shape.directory.unwrap(),
-})
-
-export const WorktreeAdaptor: WorkspaceAdaptor = {
-  name: "Worktree",
-  description: "Create a git worktree",
-  async configure(info) {
-    const worktree = await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.makeWorktreeInfo()))
-    return {
-      ...info,
-      name: worktree.name,
-      branch: worktree.branch,
-      directory: worktree.directory,
-    }
-  },
-  async create(info) {
-    const config = WorktreeConfig.parse(info)
-    await AppRuntime.runPromise(
-      Worktree.Service.use((svc) =>
-        svc.createFromInfo({
-          name: config.name,
-          directory: config.directory,
-          branch: config.branch,
-        }),
-      ),
-    )
-  },
-  async remove(info) {
-    const config = WorktreeConfig.parse(info)
-    await AppRuntime.runPromise(Worktree.Service.use((svc) => svc.remove({ directory: config.directory })))
-  },
-  target(info) {
-    const config = WorktreeConfig.parse(info)
-    return {
-      type: "local",
-      directory: config.directory,
-    }
-  },
-}