@drael/code 0.3.0 → 0.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drael/code",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "Point your coding client at Drael.",
   "type": "module",
   "bin": {

package/src/code.js

@@ -41,12 +41,15 @@ import { isCancel, PasswordPrompt, SelectPrompt } from '@clack/core'
 
 /* ─────────────────────────────────────────────────────────────  where things live  ── */
 
-const CONFIG_HOME =
-  process.env.XDG_CONFIG_HOME ??
-  (platform() === 'win32'
-    ? join(process.env.APPDATA ?? homedir(), 'Config')
-    : join(homedir(), '.config'))
-
+// Home-relative on every platform, Windows included. The clients here document
+// `~/.config/<them>` literally and read nowhere else, so the earlier `%APPDATA%\\Config`
+// branch wrote a valid file into a directory nothing opens: the worst failure this tool
+// has, because it reports success.
+const CONFIG_HOME = process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config')
+
+// The backups do not follow, and that is deliberate: this directory is ours rather than a
+// client's, so it was never in the wrong place, and moving it would strand the records
+// written by an earlier version. An uninstall that cannot find them is not an uninstall.
 const STATE_HOME =
   process.env.XDG_STATE_HOME ??
   (platform() === 'win32'
@@ -55,8 +58,8 @@ const STATE_HOME =
 
 const BACKUPS = join(STATE_HOME, 'drael', 'installer')
 
-// Kilo documents this literal path on every platform, Windows included, so this one
-// does not go through CONFIG_HOME the way the others do.
+// Kilo documents this literal path, so unlike the others it is not moved by
+// XDG_CONFIG_HOME either.
 const KILO_CONFIG = join(homedir(), '.config', 'kilo', 'kilo.jsonc')
 
 // There is one origin (ADR 0017), and this package is published by the people who run
@@ -102,12 +105,12 @@ const clients = {
     merges: true,
     file: () => KILO_CONFIG,
     contents: (host, key, model) => {
-      const existing = readJson(KILO_CONFIG)
+      const kept = existing(KILO_CONFIG).value
       return json({
-        ...existing,
+        ...kept,
         $schema: 'https://app.kilo.ai/config.json',
         provider: {
-          ...existing.provider,
+          ...kept.provider,
           drael: {
             options: { baseURL: `${host}/v1`, apiKey: key },
             models: { [model]: { name: 'Drael' } },
@@ -118,6 +121,40 @@ const clients = {
     },
   },
 
+  continue: {
+    label: 'Continue',
+    file: () => join(homedir(), '.continue', 'config.yaml'),
+    contents: (host, key, model) =>
+      [
+        'name: Drael',
+        'version: 1.0.0',
+        'schema: v1',
+        'models:',
+        '  - name: Drael',
+        '    provider: openai',
+        `    model: ${scalar(model)}`,
+        `    apiBase: ${scalar(`${host}/v1`)}`,
+        `    apiKey: ${scalar(key)}`,
+        '',
+      ].join('\n'),
+  },
+
+  aider: {
+    label: 'Aider',
+    // A dotfile at the root of home, so its own presence is the only sign of it: the
+    // directory the others are found by would be the home directory, which is always there.
+    at: () => join(homedir(), '.aider.conf.yml'),
+    file: () => join(homedir(), '.aider.conf.yml'),
+    contents: (host, key, model) =>
+      [
+        '# Drael.',
+        `model: ${scalar(`openai/${model}`)}`,
+        `openai-api-base: ${scalar(`${host}/v1`)}`,
+        `openai-api-key: ${scalar(key)}`,
+        '',
+      ].join('\n'),
+  },
+
   env: {
     label: 'anything reading OPENAI_BASE_URL',
     file: () => join(CONFIG_HOME, 'drael', 'env.sh'),
@@ -137,30 +174,80 @@ const clients = {
 const json = (value) => `${JSON.stringify(value, null, 2)}\n`
 
 /**
- * Kilo's file is the whole extension's configuration and not ours, so ours is merged
- * into what is already there. A file that does not parse is treated as absent rather
- * than guessed at: JSONC allows comments, and a parser guessing at them writes back a
- * mangled config. The copy under BACKUPS still holds the original, and `parses` below
- * is what lets the frame say so before it writes.
+ * A YAML scalar, for the two files that are YAML. YAML 1.2 is a superset of JSON, so a
+ * JSON string is already a correctly quoted and escaped one, and quoting every value is
+ * what keeps the `https://` in a URL from reading as a key with a comment after it.
  */
-function readJson(file) {
-  try {
-    return JSON.parse(readFileSync(file, 'utf8'))
-  } catch {
-    return {}
-  }
-}
+const scalar = (value) => JSON.stringify(String(value))
 
-function parses(file) {
+/**
+ * Kilo's file is the whole extension's configuration and not ours, so ours is merged into
+ * what is already there. It is a `.jsonc`, and a file that names itself that has comments
+ * in it, so reading it with `JSON.parse` alone meant every commented config was replaced
+ * whole: the other providers, the keys and the settings in it, gone but for the copy under
+ * BACKUPS.
+ *
+ * What cannot be kept is the comments themselves, because what goes back is JSON. The
+ * frame says so when that is what happened.
+ */
+function existing(file) {
   if (!existsSync(file)) {
-    return true
+    return { value: {} }
+  }
+  const text = readFileSync(file, 'utf8')
+  try {
+    return { value: JSON.parse(text) }
+  } catch {
+    // Not plain JSON, so it is either JSONC or damaged, and those are different answers.
   }
   try {
-    JSON.parse(readFileSync(file, 'utf8'))
-    return true
+    return { value: JSON.parse(uncommented(text)), stripped: true }
   } catch {
-    return false
+    return { value: {}, replaced: true }
+  }
+}
+
+/**
+ * JSON with the comments and the trailing commas taken out, which is what JSONC is. A
+ * scanner rather than a pattern, because a `//` inside a string value is not a comment and
+ * a pattern cannot tell the difference; the same goes for the comma in `"a, }"`, which a
+ * pattern for trailing commas would eat.
+ */
+function uncommented(text) {
+  let out = ''
+  let comma = -1
+  let i = 0
+  while (i < text.length) {
+    const here = text[i]
+
+    if (here === '"') {
+      let end = i + 1
+      while (end < text.length && text[end] !== '"') {
+        end += text[end] === '\\' ? 2 : 1
+      }
+      out += text.slice(i, end + 1)
+      i = end + 1
+      continue
+    }
+    if (here === '/' && text[i + 1] === '/') {
+      while (i < text.length && text[i] !== '\n') i++
+      continue
+    }
+    if (here === '/' && text[i + 1] === '*') {
+      const closed = text.indexOf('*/', i + 2)
+      i = closed === -1 ? text.length : closed + 2
+      continue
+    }
+    if (here === ',') {
+      comma = out.length
+    } else if ((here === '}' || here === ']') && comma >= 0 && !out.slice(comma + 1).trim()) {
+      out = out.slice(0, comma) + out.slice(comma + 1)
+      comma = -1
+    }
+    out += here
+    i++
   }
+  return out
 }
 
 /* ──────────────────────────────────────────────────────────────────  the drawing  ── */
@@ -279,17 +366,24 @@ const askClient = () =>
  * product itself. The one call this makes, and the only one: it is to the host being
  * configured, with the key being configured, and a host that does not answer is not a
  * reason to refuse to write anything, so the published id stands in.
+ *
+ * It is also the only check the reader needs, which is why the frame reports what came
+ * back instead of handing out a curl line: that line carried the key in clear text, on
+ * screen and into the scrollback, one row under the prompt that had just masked it.
  */
-async function servedModel(host, key) {
+async function askHost(host, key) {
   try {
     const response = await fetch(`${host}/v1/models`, {
       headers: { Authorization: `Bearer ${key}` },
       signal: AbortSignal.timeout(4000),
     })
+    if (response.status === 401 || response.status === 403) {
+      return { refused: true }
+    }
     const served = (await response.json())?.data?.[0]?.id
-    return typeof served === 'string' && served ? served : MODEL
+    return { model: typeof served === 'string' && served ? served : null }
   } catch {
-    return MODEL
+    return {}
   }
 }
 
@@ -299,7 +393,7 @@ async function servedModel(host, key) {
  * list and detection only decides which one the cursor starts on.
  */
 function found(client) {
-  return existsSync(dirname(client.file()))
+  return existsSync(client.at?.() ?? dirname(client.file()))
 }
 
 function detected() {
@@ -327,8 +421,9 @@ async function install(args) {
     fail(`unknown client: ${name} (try --list)`)
   }
 
+  const answer = await askHost(host, key)
   const file = client.file()
-  const contents = client.contents(host, key, await servedModel(host, key))
+  const contents = client.contents(host, key, answer.model ?? MODEL)
 
   // An answered prompt leaves its frame on screen and needs a gap after it. With every
   // answer given as a flag there was no frame, and the masthead's own gap is already it.
@@ -346,8 +441,8 @@ async function install(args) {
     return
   }
 
-  // Asked before the write, or it inspects the valid JSON we are about to put there.
-  const replaced = client.merges && !parses(file)
+  // Asked before the write, or it inspects the JSON we are about to put there.
+  const was = client.merges ? existing(file) : {}
 
   const kept = backup(file)
   mkdirSync(dirname(file), { recursive: true })
@@ -355,8 +450,11 @@ async function install(args) {
   chmodSync(file, 0o600)
 
   console.log(row(client.merges ? 'merged' : 'wrote', tilde(file)))
-  if (replaced) {
-    console.log(under(dim('it was not plain JSON, so it was replaced rather than merged')))
+  if (was.replaced) {
+    console.log(under(dim('it did not parse at all, so it was replaced rather than merged')))
+  }
+  if (was.stripped) {
+    console.log(under(dim('everything in it was kept; its comments were not, because JSON')))
   }
   console.log(row(kept.label, dim(kept.detail)))
   if (client.after) {
@@ -367,11 +465,25 @@ async function install(args) {
   console.log()
   console.log(rule())
   console.log()
-  console.log(row('check it', dim(`curl ${host}/v1/models -H "Authorization: Bearer ${key}"`)))
+  console.log(row('the host', dim(`${host}/v1, ${said(answer)}`)))
+  if (answer.refused) {
+    console.log(under(dim(`create one at ${host}/developers, then run this again`)))
+  }
   console.log(row('undo it', dim('npx @drael/code --uninstall')))
   console.log()
 }
 
+/** What the one call came back with, in the frame's own voice. */
+function said(answer) {
+  if (answer.refused) {
+    return 'which refused that key'
+  }
+  if (answer.model) {
+    return `serving ${answer.model}`
+  }
+  return `which did not answer, so ${MODEL} was written`
+}
+
 /**
  * Every write is preceded by a copy. An uninstall that cannot put the file back is not
  * an uninstall, it is a deletion with better manners. It reports what it found rather
@@ -466,7 +578,8 @@ function help() {
 function list() {
   console.log()
   for (const [name, client] of Object.entries(clients)) {
-    console.log(row(name, `${dim(tilde(client.file()).padEnd(34))} ${client.label}`))
+    const said = `${client.label}${found(client) ? ' · on this machine' : ''}`
+    console.log(row(name, `${dim(tilde(client.file()).padEnd(34))} ${said}`))
   }
   console.log()
 }
@@ -497,7 +610,13 @@ function parse(argv) {
       parsed[name] = true
       continue
     }
-    parsed[name] = argv[++i]
+    // `--client --key dk-…` used to swallow the next flag as the value and then report
+    // `unknown client: --key`, which names neither the mistake nor the fix.
+    const value = argv[++i]
+    if (value === undefined || value.startsWith('--')) {
+      fail(`--${name} needs a value`)
+    }
+    parsed[name] = value
   }
   return parsed
 }