conjure-js 0.0.1

package/src/bin/cli.ts

@@ -0,0 +1,250 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { createInterface } from 'node:readline/promises'
+import { stdin as input, stdout as output } from 'node:process'
+import { fileURLToPath } from 'node:url'
+import {
+  createSession,
+  printString,
+  define,
+  cljNativeFunction,
+  cljNil,
+  cljString,
+  valueToString,
+  type Session,
+  type CljValue,
+} from '../core'
+import { extractNsName } from '../vite-plugin-clj/namespace-utils'
+import { inferSourceRoot, discoverSourceRoots } from './nrepl-utils'
+import { startNreplServer } from './nrepl'
+import { VERSION } from './version'
+
+type CliIo = {
+  writeLine: (text: string) => void
+  writeError: (text: string) => void
+}
+
+function makeCliIo(): CliIo {
+  return {
+    writeLine: (text) => output.write(`${text}\n`),
+    writeError: (text) => process.stderr.write(`${text}\n`),
+  }
+}
+
+function injectHostFunctions(session: Session): void {
+  const coreEnv = session.getNs('clojure.core')!
+
+  define(
+    'slurp',
+    cljNativeFunction('slurp', (pathVal: CljValue) => {
+      const filePath = resolve(valueToString(pathVal))
+      if (!existsSync(filePath)) {
+        throw new Error(`slurp: file not found: ${filePath}`)
+      }
+      return cljString(readFileSync(filePath, 'utf8'))
+    }),
+    coreEnv
+  )
+
+  define(
+    'spit',
+    cljNativeFunction('spit', (pathVal: CljValue, content: CljValue) => {
+      const filePath = resolve(valueToString(pathVal))
+      writeFileSync(filePath, valueToString(content), 'utf8')
+      return cljNil()
+    }),
+    coreEnv
+  )
+
+  define(
+    'load',
+    cljNativeFunction('load', (pathVal: CljValue) => {
+      const filePath = resolve(valueToString(pathVal))
+      if (!existsSync(filePath)) {
+        throw new Error(`load: file not found: ${filePath}`)
+      }
+      const source = readFileSync(filePath, 'utf8')
+      const inferred = inferSourceRoot(filePath, source)
+      if (inferred) session.addSourceRoot(inferred)
+      const loadedNs = session.loadFile(source)
+      session.setNs(loadedNs)
+      return cljNil()
+    }),
+    coreEnv
+  )
+}
+
+export function createCliSession(sourceRoots: string[], io: CliIo): Session {
+  const session = createSession({
+    output: (text) => io.writeLine(text),
+    sourceRoots,
+    readFile: (filePath) => readFileSync(filePath, 'utf8'),
+  })
+  injectHostFunctions(session)
+  return session
+}
+
+function getSourceRoots(filePath?: string): string[] {
+  const roots = new Set<string>()
+  roots.add(process.cwd())
+  if (filePath) {
+    roots.add(dirname(filePath))
+  }
+  return [...roots]
+}
+
+function printUsage(io: CliIo) {
+  io.writeLine('Usage:')
+  io.writeLine('  conjure repl')
+  io.writeLine('  conjure run <file.clj>')
+  io.writeLine('  conjure nrepl-server [--port <number>] [--host <string>]')
+}
+
+export function runFile(fileArg: string, io: CliIo = makeCliIo()): number {
+  const filePath = resolve(fileArg)
+  if (!existsSync(filePath)) {
+    io.writeError(`File not found: ${fileArg}`)
+    return 1
+  }
+
+  try {
+    const source = readFileSync(filePath, 'utf8')
+    const inferredRoot = inferSourceRoot(filePath, source)
+    const sourceRoots = inferredRoot
+      ? [...new Set([inferredRoot, ...getSourceRoots(filePath)])]
+      : getSourceRoots(filePath)
+
+    const session = createCliSession(sourceRoots, io)
+    session.loadFile(source)
+
+    const nsName = extractNsName(source)
+    if (nsName) {
+      session.setNs(nsName)
+    }
+
+    return 0
+  } catch (error) {
+    io.writeError(error instanceof Error ? error.message : String(error))
+    return 1
+  }
+}
+
+function shouldExitRepl(source: string): boolean {
+  const trimmed = source.trim()
+  return trimmed === '(exit)'
+}
+
+function evaluateReplLine(session: Session, line: string, io: CliIo): boolean {
+  const trimmed = line.trim()
+  if (!trimmed) return true
+  if (shouldExitRepl(trimmed)) return false
+
+  try {
+    const result = session.evaluate(trimmed)
+    io.writeLine(printString(result))
+  } catch (error) {
+    io.writeError(error instanceof Error ? error.message : String(error))
+  }
+
+  return true
+}
+
+async function startInteractiveRepl(
+  session: Session,
+  io: CliIo
+): Promise<number> {
+  const rl = createInterface({ input, output })
+  try {
+    while (true) {
+      let line: string
+      try {
+        line = await rl.question(`${session.currentNs}=> `)
+      } catch {
+        break
+      }
+
+      if (!evaluateReplLine(session, line, io)) break
+    }
+
+    return 0
+  } finally {
+    rl.close()
+  }
+}
+
+async function startStreamRepl(session: Session, io: CliIo): Promise<number> {
+  const rl = createInterface({ input, output: process.stderr, terminal: false })
+
+  try {
+    for await (const line of rl) {
+      if (!evaluateReplLine(session, line, io)) break
+    }
+
+    return 0
+  } finally {
+    rl.close()
+  }
+}
+
+export async function startRepl(io: CliIo = makeCliIo()): Promise<number> {
+  const session = createCliSession(getSourceRoots(), io)
+
+  io.writeLine(`Conjure v${VERSION}`)
+  io.writeLine('Type (exit) to exit the REPL.')
+
+  if (!input.isTTY) {
+    return startStreamRepl(session, io)
+  }
+
+  return startInteractiveRepl(session, io)
+}
+
+function parseNreplArgs(args: string[]): { port: number; host: string } {
+  let port = 7888
+  let host = '127.0.0.1'
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--port' && args[i + 1]) {
+      port = parseInt(args[++i], 10)
+    } else if (args[i] === '--host' && args[i + 1]) {
+      host = args[++i]
+    }
+  }
+  return { port, host }
+}
+
+export async function runCli(
+  args: string[],
+  io: CliIo = makeCliIo()
+): Promise<number> {
+  const [command, ...rest] = args
+
+  if (!command || command === 'repl') {
+    return startRepl(io)
+  }
+
+  if (command === 'run') {
+    const [fileArg] = rest
+    if (!fileArg) {
+      printUsage(io)
+      return 1
+    }
+    return runFile(fileArg, io)
+  }
+
+  if (command === 'nrepl-server') {
+    const { port, host } = parseNreplArgs(rest)
+    const sourceRoots = discoverSourceRoots(process.cwd())
+    startNreplServer({ port, host, sourceRoots })
+    // Keep the process alive; the TCP server holds the event loop open.
+    return new Promise(() => {})
+  }
+
+  printUsage(io)
+  return 1
+}
+
+const entryPath = fileURLToPath(import.meta.url)
+if (process.argv[1] && resolve(process.argv[1]) === entryPath) {
+  const exitCode = await runCli(process.argv.slice(2))
+  process.exitCode = exitCode
+}

package/src/bin/nrepl-utils.ts

@@ -0,0 +1,59 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, resolve, join } from 'node:path'
+import { extractNsName } from '../vite-plugin-clj/namespace-utils'
+
+/**
+ * Given an absolute file path and the source it contains, infer the source
+ * root directory by stripping the namespace-derived suffix from the path.
+ *
+ * Example:
+ *   filePath = "/home/user/project/src/my/app.clj"
+ *   ns       = "my.app"
+ *   → "/home/user/project/src"
+ */
+export function inferSourceRoot(filePath: string, source: string): string | null {
+  const nsName = extractNsName(source)
+  if (!nsName) return null
+
+  const normalizedPath = filePath.replace(/\\/g, '/')
+  const nsSuffix = `/${nsName.replace(/\./g, '/')}.clj`
+  if (!normalizedPath.endsWith(nsSuffix)) {
+    return null
+  }
+
+  return normalizedPath.slice(0, -nsSuffix.length) || '/'
+}
+
+/**
+ * Walk upward from `startDir` looking for a `package.json` with a `"conjure"` key.
+ * If found, resolve `conjure.sourceRoots` to absolute paths relative to the
+ * package.json location and return them.
+ *
+ * Falls back to `[startDir]` if no config is found.
+ */
+export function discoverSourceRoots(startDir: string): string[] {
+  let dir = resolve(startDir)
+  const root = resolve('/')
+
+  while (true) {
+    const pkgPath = join(dir, 'package.json')
+    if (existsSync(pkgPath)) {
+      try {
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'))
+        if (pkg.conjure && Array.isArray(pkg.conjure.sourceRoots)) {
+          const roots = (pkg.conjure.sourceRoots as string[]).map((r) =>
+            resolve(dir, r)
+          )
+          return roots.length > 0 ? roots : [startDir]
+        }
+      } catch {
+        // Malformed JSON — skip and keep walking
+      }
+    }
+
+    if (dir === root) break
+    dir = dirname(dir)
+  }
+
+  return [startDir]
+}

package/src/bin/nrepl.ts

@@ -0,0 +1,393 @@
+import * as net from 'net'
+import { readFileSync, writeFileSync, unlinkSync, existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { BDecoderStream, BEncoderStream } from './bencode'
+import {
+  createSession,
+  createSessionFromSnapshot,
+  printString,
+  snapshotSession,
+  define,
+  cljNativeFunction,
+  cljNil,
+  cljString,
+  valueToString,
+  type Session,
+  type SessionSnapshot,
+  type CljValue,
+} from '../core'
+import { inferSourceRoot } from './nrepl-utils'
+import { VERSION } from './version'
+
+const CONJURE_VERSION = VERSION
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+type NreplMessage = Record<string, unknown>
+
+type ManagedSession = {
+  id: string
+  session: Session
+  /** Mutable: updated to the current eval message id before each eval call */
+  currentMsgId: string
+}
+
+// ---------------------------------------------------------------------------
+// Session helpers
+// ---------------------------------------------------------------------------
+
+function makeSessionId(): string {
+  return crypto.randomUUID()
+}
+
+function injectHostFunctions(session: Session): void {
+  const coreEnv = session.getNs('clojure.core')!
+
+  define(
+    'slurp',
+    cljNativeFunction('slurp', (pathVal: CljValue) => {
+      const filePath = resolve(valueToString(pathVal))
+      if (!existsSync(filePath)) {
+        throw new Error(`slurp: file not found: ${filePath}`)
+      }
+      return cljString(readFileSync(filePath, 'utf8'))
+    }),
+    coreEnv
+  )
+
+  define(
+    'spit',
+    cljNativeFunction('spit', (pathVal: CljValue, content: CljValue) => {
+      const filePath = resolve(valueToString(pathVal))
+      writeFileSync(filePath, valueToString(content), 'utf8')
+      return cljNil()
+    }),
+    coreEnv
+  )
+
+  define(
+    'load',
+    cljNativeFunction('load', (pathVal: CljValue) => {
+      const filePath = resolve(valueToString(pathVal))
+      if (!existsSync(filePath)) {
+        throw new Error(`load: file not found: ${filePath}`)
+      }
+      const source = readFileSync(filePath, 'utf8')
+      const inferred = inferSourceRoot(filePath, source)
+      if (inferred) session.addSourceRoot(inferred)
+      const loadedNs = session.loadFile(source)
+      session.setNs(loadedNs)
+      return cljNil()
+    }),
+    coreEnv
+  )
+}
+
+function createManagedSession(
+  id: string,
+  snapshot: SessionSnapshot,
+  encoder: BEncoderStream
+): ManagedSession {
+  let currentMsgId = ''
+
+  const session = createSessionFromSnapshot(snapshot, {
+    output: (text) => {
+      send(encoder, { id: currentMsgId, session: id, out: text })
+    },
+    readFile: (filePath) => readFileSync(filePath, 'utf8'),
+  })
+
+  injectHostFunctions(session)
+
+  return {
+    id,
+    session,
+    get currentMsgId() {
+      return currentMsgId
+    },
+    set currentMsgId(v) {
+      currentMsgId = v
+    },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Protocol helpers
+// ---------------------------------------------------------------------------
+
+function send(encoder: BEncoderStream, msg: NreplMessage) {
+  encoder.write(msg)
+}
+
+function done(
+  encoder: BEncoderStream,
+  id: string,
+  sessionId: string | undefined,
+  extra: NreplMessage = {}
+) {
+  // If the caller already sets status (e.g. ['eval-error', 'done']), preserve it.
+  send(encoder, {
+    id,
+    ...(sessionId ? { session: sessionId } : {}),
+    status: ['done'],
+    ...extra,
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Op handlers
+// ---------------------------------------------------------------------------
+
+function handleClone(
+  msg: NreplMessage,
+  sessions: Map<string, ManagedSession>,
+  snapshot: SessionSnapshot,
+  encoder: BEncoderStream
+) {
+  const id = (msg['id'] as string) ?? ''
+  const newId = makeSessionId()
+  const managed = createManagedSession(newId, snapshot, encoder)
+  sessions.set(newId, managed)
+  done(encoder, id, undefined, { 'new-session': newId })
+}
+
+function handleDescribe(msg: NreplMessage, encoder: BEncoderStream) {
+  const id = (msg['id'] as string) ?? ''
+  const sessionId = msg['session'] as string | undefined
+  done(encoder, id, sessionId, {
+    ops: {
+      eval: {},
+      clone: {},
+      close: {},
+      complete: {},
+      describe: {},
+      'load-file': {},
+    },
+    versions: {
+      conjure: { 'version-string': CONJURE_VERSION },
+    },
+  })
+}
+
+function handleEval(
+  msg: NreplMessage,
+  managed: ManagedSession,
+  encoder: BEncoderStream
+) {
+  const id = (msg['id'] as string) ?? ''
+  const code = (msg['code'] as string) ?? ''
+
+  managed.currentMsgId = id
+
+  try {
+    const result = managed.session.evaluate(code)
+    done(encoder, id, managed.id, {
+      value: printString(result),
+      ns: managed.session.currentNs,
+    })
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error)
+    done(encoder, id, managed.id, {
+      ex: message,
+      err: message + '\n',
+      ns: managed.session.currentNs,
+      status: ['eval-error', 'done'],
+    })
+  }
+}
+
+function handleLoadFile(
+  msg: NreplMessage,
+  managed: ManagedSession,
+  encoder: BEncoderStream
+) {
+  const id = (msg['id'] as string) ?? ''
+  const source = (msg['file'] as string) ?? ''
+  const fileName = (msg['file-name'] as string) ?? ''
+  const filePath = (msg['file-path'] as string) ?? ''
+
+  managed.currentMsgId = id
+
+  try {
+    // Dynamically infer source root from the file path + ns declaration.
+    // This is the zero-config path: Calva sends the absolute path, and we
+    // derive the root so sibling namespaces resolve via require.
+    if (filePath) {
+      const inferred = inferSourceRoot(filePath, source)
+      if (inferred) {
+        managed.session.addSourceRoot(inferred)
+      }
+    }
+
+    const nsHint =
+      fileName.replace(/\.clj$/, '').replace(/\//g, '.') || undefined
+    const loadedNs = managed.session.loadFile(source, nsHint)
+
+    // Switch the session's active namespace to the one declared in the loaded
+    // file. Without this, subsequent eval ops land in the wrong namespace and
+    // can't see the defs that were just loaded.
+    managed.session.setNs(loadedNs)
+
+    done(encoder, id, managed.id, {
+      value: 'nil',
+      ns: managed.session.currentNs,
+    })
+  } catch (error) {
+    done(encoder, id, managed.id, {
+      ex: error instanceof Error ? error.message : String(error),
+      ns: managed.session.currentNs,
+      status: ['eval-error', 'done'],
+    })
+  }
+}
+
+function handleComplete(
+  msg: NreplMessage,
+  managed: ManagedSession,
+  encoder: BEncoderStream
+) {
+  const id = (msg['id'] as string) ?? ''
+  const prefix = (msg['prefix'] as string) ?? ''
+  const nsName = msg['ns'] as string | undefined
+
+  const names = managed.session.getCompletions(prefix, nsName)
+  const completions = names.map((c) => ({
+    candidate: c,
+    type: 'var',
+    ns: managed.session.currentNs,
+  }))
+
+  done(encoder, id, managed.id, { completions })
+}
+
+function handleClose(
+  msg: NreplMessage,
+  sessions: Map<string, ManagedSession>,
+  encoder: BEncoderStream
+) {
+  // cider sends a close message with an id
+  const id = (msg['id'] as string) ?? ''
+  const sessionId = (msg['session'] as string) ?? ''
+  sessions.delete(sessionId)
+  send(encoder, { id, session: sessionId, status: ['done'] })
+}
+
+function handleUnknown(msg: NreplMessage, encoder: BEncoderStream) {
+  const id = (msg['id'] as string) ?? ''
+  send(encoder, { id, status: ['unknown-op', 'done'] })
+}
+
+// ---------------------------------------------------------------------------
+// Per-connection dispatcher
+// ---------------------------------------------------------------------------
+
+function handleMessage(
+  msg: NreplMessage,
+  sessions: Map<string, ManagedSession>,
+  snapshot: SessionSnapshot,
+  encoder: BEncoderStream,
+  defaultSession: ManagedSession
+) {
+  const op = msg['op'] as string
+  const sessionId = msg['session'] as string | undefined
+  const managed = sessionId
+    ? (sessions.get(sessionId) ?? defaultSession)
+    : defaultSession
+
+  switch (op) {
+    case 'clone':
+      handleClone(msg, sessions, snapshot, encoder)
+      break
+    case 'describe':
+      handleDescribe(msg, encoder)
+      break
+    case 'eval':
+      handleEval(msg, managed, encoder)
+      break
+    case 'load-file':
+      handleLoadFile(msg, managed, encoder)
+      break
+    case 'complete':
+      handleComplete(msg, managed, encoder)
+      break
+    case 'close':
+      handleClose(msg, sessions, encoder)
+      break
+    default:
+      handleUnknown(msg, encoder)
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Server startup
+// ---------------------------------------------------------------------------
+
+export type NreplServerOptions = {
+  port?: number
+  host?: string
+  sourceRoots?: string[]
+}
+
+export function startNreplServer(options: NreplServerOptions = {}): net.Server {
+  const port = options.port ?? 7888
+  const host = options.host ?? '127.0.0.1'
+
+  // Build a warm snapshot once — all clones skip the core bootstrap.
+  // Source roots from config discovery are baked in so every cloned session inherits them.
+  const warmSession = createSession({
+    sourceRoots: options.sourceRoots,
+    readFile: (filePath) => readFileSync(filePath, 'utf8'),
+  })
+  const snapshot = snapshotSession(warmSession)
+
+  const server = net.createServer((socket) => {
+    const encoder = new BEncoderStream()
+    const decoder = new BDecoderStream()
+
+    encoder.pipe(socket)
+    socket.pipe(decoder)
+
+    const sessions = new Map<string, ManagedSession>()
+
+    // A default session for session-less messages (e.g. Calva's initial eval)
+    const defaultId = makeSessionId()
+    const defaultSession = createManagedSession(defaultId, snapshot, encoder)
+    sessions.set(defaultId, defaultSession)
+
+    decoder.on('data', (msg: NreplMessage) => {
+      handleMessage(msg, sessions, snapshot, encoder, defaultSession)
+    })
+
+    socket.on('error', () => {
+      // Connection dropped — nothing to clean up beyond GC
+    })
+
+    socket.on('close', () => {
+      sessions.clear()
+    })
+  })
+
+  const portFile = join(process.cwd(), '.nrepl-port')
+
+  server.listen(port, host, () => {
+    writeFileSync(portFile, String(port), 'utf8')
+    process.stdout.write(`Conjure nREPL server v${VERSION} started on port ${port}\n`)
+  })
+
+  const cleanup = () => {
+    if (existsSync(portFile)) unlinkSync(portFile)
+  }
+  process.on('exit', cleanup)
+  process.on('SIGINT', () => {
+    cleanup()
+    process.exit(0)
+  })
+  process.on('SIGTERM', () => {
+    cleanup()
+    process.exit(0)
+  })
+
+  return server
+}

package/src/bin/version.ts

@@ -0,0 +1,4 @@
+// This file is auto-generated by scripts/gen-version.mjs
+// Do not edit manually - changes will be overwritten
+
+export const VERSION = '0.0.1'