dfcode 1.0.0 → 1.0.2

package/packages/dfcode/src/cli/cmd/tui/attach.ts

@@ -1,39 +0,0 @@
-import { cmd } from "../cmd"
-import { tui } from "./app"
-
-export const AttachCommand = cmd({
-  command: "attach <url>",
-  describe: "attach to a running dfcode server",
-  builder: (yargs) =>
-    yargs
-      .positional("url", {
-        type: "string",
-        describe: "http://localhost:4096",
-        demandOption: true,
-      })
-      .option("dir", {
-        type: "string",
-        description: "directory to run in",
-      })
-      .option("session", {
-        alias: ["s"],
-        type: "string",
-        describe: "session id to continue",
-      }),
-  handler: async (args) => {
-    let directory = args.dir
-    if (args.dir) {
-      try {
-        process.chdir(args.dir)
-        directory = process.cwd()
-      } catch {
-        // If the directory doesn't exist locally (remote attach), pass it through.
-      }
-    }
-    await tui({
-      url: args.url,
-      args: { sessionID: args.session },
-      directory,
-    })
-  },
-})

package/packages/dfcode/src/cli/cmd/tui/component/border.tsx

@@ -1,21 +0,0 @@
-export const EmptyBorder = {
-  topLeft: "",
-  bottomLeft: "",
-  vertical: "",
-  topRight: "",
-  bottomRight: "",
-  horizontal: " ",
-  bottomT: "",
-  topT: "",
-  cross: "",
-  leftT: "",
-  rightT: "",
-}
-
-export const SplitBorder = {
-  border: ["left" as const, "right" as const],
-  customBorderChars: {
-    ...EmptyBorder,
-    vertical: "┃",
-  },
-}

package/packages/dfcode/src/cli/cmd/tui/component/dialog-agent.tsx

@@ -1,31 +0,0 @@
-import { createMemo } from "solid-js"
-import { useLocal } from "@tui/context/local"
-import { DialogSelect } from "@tui/ui/dialog-select"
-import { useDialog } from "@tui/ui/dialog"
-
-export function DialogAgent() {
-  const local = useLocal()
-  const dialog = useDialog()
-
-  const options = createMemo(() =>
-    local.agent.list().map((item) => {
-      return {
-        value: item.name,
-        title: item.name,
-        description: item.native ? "native" : item.description,
-      }
-    }),
-  )
-
-  return (
-    <DialogSelect
-      title="Select agent"
-      current={local.agent.current().name}
-      options={options()}
-      onSelect={(option) => {
-        local.agent.set(option.value)
-        dialog.clear()
-      }}
-    />
-  )
-}

package/packages/dfcode/src/cli/cmd/tui/component/dialog-command.tsx

@@ -1,148 +0,0 @@
-import { useDialog } from "@tui/ui/dialog"
-import { DialogSelect, type DialogSelectOption, type DialogSelectRef } from "@tui/ui/dialog-select"
-import {
-  createContext,
-  createMemo,
-  createSignal,
-  onCleanup,
-  useContext,
-  type Accessor,
-  type ParentProps,
-} from "solid-js"
-import { useKeyboard } from "@opentui/solid"
-import { useKeybind } from "@tui/context/keybind"
-import type { KeybindsConfig } from "@dfcode/sdk/v2"
-
-type Context = ReturnType<typeof init>
-const ctx = createContext<Context>()
-
-export type Slash = {
-  name: string
-  aliases?: string[]
-}
-
-export type CommandOption = DialogSelectOption<string> & {
-  keybind?: keyof KeybindsConfig
-  suggested?: boolean
-  slash?: Slash
-  hidden?: boolean
-  enabled?: boolean
-}
-
-function init() {
-  const [registrations, setRegistrations] = createSignal<Accessor<CommandOption[]>[]>([])
-  const [suspendCount, setSuspendCount] = createSignal(0)
-  const dialog = useDialog()
-  const keybind = useKeybind()
-
-  const entries = createMemo(() => {
-    const all = registrations().flatMap((x) => x())
-    return all.map((x) => ({
-      ...x,
-      footer: x.keybind ? keybind.print(x.keybind) : undefined,
-    }))
-  })
-
-  const isEnabled = (option: CommandOption) => option.enabled !== false
-  const isVisible = (option: CommandOption) => isEnabled(option) && !option.hidden
-
-  const visibleOptions = createMemo(() => entries().filter((option) => isVisible(option)))
-  const suggestedOptions = createMemo(() =>
-    visibleOptions()
-      .filter((option) => option.suggested)
-      .map((option) => ({
-        ...option,
-        value: `suggested:${option.value}`,
-        category: "Suggested",
-      })),
-  )
-  const suspended = () => suspendCount() > 0
-
-  useKeyboard((evt) => {
-    if (suspended()) return
-    if (dialog.stack.length > 0) return
-    for (const option of entries()) {
-      if (!isEnabled(option)) continue
-      if (option.keybind && keybind.match(option.keybind, evt)) {
-        evt.preventDefault()
-        option.onSelect?.(dialog)
-        return
-      }
-    }
-  })
-
-  const result = {
-    trigger(name: string) {
-      for (const option of entries()) {
-        if (option.value === name) {
-          if (!isEnabled(option)) return
-          option.onSelect?.(dialog)
-          return
-        }
-      }
-    },
-    slashes() {
-      return visibleOptions().flatMap((option) => {
-        const slash = option.slash
-        if (!slash) return []
-        return {
-          display: "/" + slash.name,
-          description: option.description ?? option.title,
-          aliases: slash.aliases?.map((alias) => "/" + alias),
-          onSelect: () => result.trigger(option.value),
-        }
-      })
-    },
-    keybinds(enabled: boolean) {
-      setSuspendCount((count) => count + (enabled ? -1 : 1))
-    },
-    suspended,
-    show() {
-      dialog.replace(() => <DialogCommand options={visibleOptions()} suggestedOptions={suggestedOptions()} />)
-    },
-    register(cb: () => CommandOption[]) {
-      const results = createMemo(cb)
-      setRegistrations((arr) => [results, ...arr])
-      onCleanup(() => {
-        setRegistrations((arr) => arr.filter((x) => x !== results))
-      })
-    },
-  }
-  return result
-}
-
-export function useCommandDialog() {
-  const value = useContext(ctx)
-  if (!value) {
-    throw new Error("useCommandDialog must be used within a CommandProvider")
-  }
-  return value
-}
-
-export function CommandProvider(props: ParentProps) {
-  const value = init()
-  const dialog = useDialog()
-  const keybind = useKeybind()
-
-  useKeyboard((evt) => {
-    if (value.suspended()) return
-    if (dialog.stack.length > 0) return
-    if (evt.defaultPrevented) return
-    if (keybind.match("command_list", evt)) {
-      evt.preventDefault()
-      value.show()
-      return
-    }
-  })
-
-  return <ctx.Provider value={value}>{props.children}</ctx.Provider>
-}
-
-function DialogCommand(props: { options: CommandOption[]; suggestedOptions: CommandOption[] }) {
-  let ref: DialogSelectRef<string>
-  const list = () => {
-    if (ref?.filter) return props.options
-    return [...props.suggestedOptions, ...props.options]
-  }
-  return <DialogSelect ref={(r) => (ref = r)} title="Commands" options={list()} />
-}

package/packages/dfcode/src/cli/cmd/tui/component/dialog-mcp.tsx

@@ -1,86 +0,0 @@
-import { createMemo, createSignal } from "solid-js"
-import { useLocal } from "@tui/context/local"
-import { useSync } from "@tui/context/sync"
-import { map, pipe, entries, sortBy } from "remeda"
-import { DialogSelect, type DialogSelectRef, type DialogSelectOption } from "@tui/ui/dialog-select"
-import { useTheme } from "../context/theme"
-import { Keybind } from "@/util/keybind"
-import { TextAttributes } from "@opentui/core"
-import { useSDK } from "@tui/context/sdk"
-
-function Status(props: { enabled: boolean; loading: boolean }) {
-  const { theme } = useTheme()
-  if (props.loading) {
-    return <span style={{ fg: theme.textMuted }}>⋯ Loading</span>
-  }
-  if (props.enabled) {
-    return <span style={{ fg: theme.success, attributes: TextAttributes.BOLD }}>✓ Enabled</span>
-  }
-  return <span style={{ fg: theme.textMuted }}>○ Disabled</span>
-}
-
-export function DialogMcp() {
-  const local = useLocal()
-  const sync = useSync()
-  const sdk = useSDK()
-  const [, setRef] = createSignal<DialogSelectRef<unknown>>()
-  const [loading, setLoading] = createSignal<string | null>(null)
-
-  const options = createMemo(() => {
-    // Track sync data and loading state to trigger re-render when they change
-    const mcpData = sync.data.mcp
-    const loadingMcp = loading()
-
-    return pipe(
-      mcpData ?? {},
-      entries(),
-      sortBy(([name]) => name),
-      map(([name, status]) => ({
-        value: name,
-        title: name,
-        description: status.status === "failed" ? "failed" : status.status,
-        footer: <Status enabled={local.mcp.isEnabled(name)} loading={loadingMcp === name} />,
-        category: undefined,
-      })),
-    )
-  })
-
-  const keybinds = createMemo(() => [
-    {
-      keybind: Keybind.parse("space")[0],
-      title: "toggle",
-      onTrigger: async (option: DialogSelectOption<string>) => {
-        // Prevent toggling while an operation is already in progress
-        if (loading() !== null) return
-
-        setLoading(option.value)
-        try {
-          await local.mcp.toggle(option.value)
-          // Refresh MCP status from server
-          const status = await sdk.client.mcp.status()
-          if (status.data) {
-            sync.set("mcp", status.data)
-          } else {
-            console.error("Failed to refresh MCP status: no data returned")
-          }
-        } catch (error) {
-          console.error("Failed to toggle MCP:", error)
-        } finally {
-          setLoading(null)
-        }
-      },
-    },
-  ])
-
-  return (
-    <DialogSelect
-      ref={setRef}
-      title="MCPs"
-      options={options()}
-      keybind={keybinds()}
-      onSelect={(option) => {
-        // Don't close on select, only on escape
-      }}
-    />
-  )
-}

package/packages/dfcode/src/cli/cmd/tui/component/dialog-model.tsx

@@ -1,234 +0,0 @@
-import { createMemo, createSignal } from "solid-js"
-import { useLocal } from "@tui/context/local"
-import { useSync } from "@tui/context/sync"
-import { map, pipe, flatMap, entries, filter, sortBy, take } from "remeda"
-import { DialogSelect, type DialogSelectRef } from "@tui/ui/dialog-select"
-import { useDialog } from "@tui/ui/dialog"
-import { createDialogProviderOptions, DialogProvider } from "./dialog-provider"
-import { useKeybind } from "../context/keybind"
-import * as fuzzysort from "fuzzysort"
-
-export function useConnected() {
-  const sync = useSync()
-  return createMemo(() =>
-    sync.data.provider.some((x) => x.id !== "dfcode" || Object.values(x.models).some((y) => y.cost?.input !== 0)),
-  )
-}
-
-export function DialogModel(props: { providerID?: string }) {
-  const local = useLocal()
-  const sync = useSync()
-  const dialog = useDialog()
-  const keybind = useKeybind()
-  const [ref, setRef] = createSignal<DialogSelectRef<unknown>>()
-  const [query, setQuery] = createSignal("")
-
-  const connected = useConnected()
-  const providers = createDialogProviderOptions()
-
-  const showExtra = createMemo(() => {
-    if (!connected()) return false
-    if (props.providerID) return false
-    return true
-  })
-
-  const options = createMemo(() => {
-    const q = query()
-    const needle = q.trim()
-    const showSections = showExtra() && needle.length === 0
-    const favorites = connected() ? local.model.favorite() : []
-    const recents = local.model.recent()
-
-    const recentList = showSections
-      ? recents.filter(
-          (item) => !favorites.some((fav) => fav.providerID === item.providerID && fav.modelID === item.modelID),
-        )
-      : []
-
-    const favoriteOptions = showSections
-      ? favorites.flatMap((item) => {
-          const provider = sync.data.provider.find((x) => x.id === item.providerID)
-          if (!provider) return []
-          const model = provider.models[item.modelID]
-          if (!model) return []
-          return [
-            {
-              key: item,
-              value: {
-                providerID: provider.id,
-                modelID: model.id,
-              },
-              title: model.name ?? item.modelID,
-              description: provider.name,
-              category: "Favorites",
-              disabled: provider.id === "dfcode" && model.id.includes("-nano"),
-              footer: model.cost?.input === 0 && provider.id === "dfcode" ? "Free" : undefined,
-              onSelect: () => {
-                dialog.clear()
-                local.model.set(
-                  {
-                    providerID: provider.id,
-                    modelID: model.id,
-                  },
-                  { recent: true },
-                )
-              },
-            },
-          ]
-        })
-      : []
-
-    const recentOptions = showSections
-      ? recentList.flatMap((item) => {
-          const provider = sync.data.provider.find((x) => x.id === item.providerID)
-          if (!provider) return []
-          const model = provider.models[item.modelID]
-          if (!model) return []
-          return [
-            {
-              key: item,
-              value: {
-                providerID: provider.id,
-                modelID: model.id,
-              },
-              title: model.name ?? item.modelID,
-              description: provider.name,
-              category: "Recent",
-              disabled: provider.id === "dfcode" && model.id.includes("-nano"),
-              footer: model.cost?.input === 0 && provider.id === "dfcode" ? "Free" : undefined,
-              onSelect: () => {
-                dialog.clear()
-                local.model.set(
-                  {
-                    providerID: provider.id,
-                    modelID: model.id,
-                  },
-                  { recent: true },
-                )
-              },
-            },
-          ]
-        })
-      : []
-
-    const providerOptions = pipe(
-      sync.data.provider,
-      sortBy(
-        (provider) => provider.id !== "dfcode",
-        (provider) => provider.name,
-      ),
-      flatMap((provider) =>
-        pipe(
-          provider.models,
-          entries(),
-          filter(([_, info]) => info.status !== "deprecated"),
-          filter(([_, info]) => (props.providerID ? info.providerID === props.providerID : true)),
-          map(([model, info]) => {
-            const value = {
-              providerID: provider.id,
-              modelID: model,
-            }
-            return {
-              value,
-              title: info.name ?? model,
-              description: favorites.some(
-                (item) => item.providerID === value.providerID && item.modelID === value.modelID,
-              )
-                ? "(Favorite)"
-                : undefined,
-              category: connected() ? provider.name : undefined,
-              disabled: provider.id === "dfcode" && model.includes("-nano"),
-              footer: info.cost?.input === 0 && provider.id === "dfcode" ? "Free" : undefined,
-              onSelect() {
-                dialog.clear()
-                local.model.set(
-                  {
-                    providerID: provider.id,
-                    modelID: model,
-                  },
-                  { recent: true },
-                )
-              },
-            }
-          }),
-          filter((x) => {
-            if (!showSections) return true
-            const value = x.value
-            const inFavorites = favorites.some(
-              (item) => item.providerID === value.providerID && item.modelID === value.modelID,
-            )
-            if (inFavorites) return false
-            const inRecents = recentList.some(
-              (item) => item.providerID === value.providerID && item.modelID === value.modelID,
-            )
-            if (inRecents) return false
-            return true
-          }),
-          sortBy(
-            (x) => x.footer !== "Free",
-            (x) => x.title,
-          ),
-        ),
-      ),
-    )
-
-    const popularProviders = !connected()
-      ? pipe(
-          providers(),
-          map((option) => {
-            return {
-              ...option,
-              category: "Popular providers",
-            }
-          }),
-          take(6),
-        )
-      : []
-
-    // Search shows a single merged list (favorites inline)
-    if (needle) {
-      const filteredProviders = fuzzysort.go(needle, providerOptions, { keys: ["title", "category"] }).map((x) => x.obj)
-      const filteredPopular = fuzzysort.go(needle, popularProviders, { keys: ["title"] }).map((x) => x.obj)
-      return [...filteredProviders, ...filteredPopular]
-    }
-
-    return [...favoriteOptions, ...recentOptions, ...providerOptions, ...popularProviders]
-  })
-
-  const provider = createMemo(() =>
-    props.providerID ? sync.data.provider.find((x) => x.id === props.providerID) : null,
-  )
-
-  const title = createMemo(() => {
-    if (provider()) return provider()!.name
-    return "Select model"
-  })
-
-  return (
-    <DialogSelect
-      keybind={[
-        {
-          keybind: keybind.all.model_provider_list?.[0],
-          title: connected() ? "Connect provider" : "View all providers",
-          onTrigger() {
-            dialog.replace(() => <DialogProvider />)
-          },
-        },
-        {
-          keybind: keybind.all.model_favorite_toggle?.[0],
-          title: "Favorite",
-          disabled: !connected(),
-          onTrigger: (option) => {
-            local.model.toggleFavorite(option.value as { providerID: string; modelID: string })
-          },
-        },
-      ]}
-      ref={setRef}
-      onFilter={setQuery}
-      skipFilter={true}
-      title={title()}
-      current={local.model.current()}
-      options={options()}
-    />
-  )
-}