savant-code 0.0.16 → 0.0.19

package/cli/release-staging/README.md

@@ -0,0 +1,70 @@
+# 🚀 Savant-Code Staging — Internal Test Package
+
+**⚠️ This package is private and for internal staging validation only. It is not a production release.**
+
+The package name is `savant-code-staging`; its in-app display name remains Codecane for staging identification.
+
+Codecane is a CLI tool that writes code for you.
+
+1. Run `savant-code-staging` from your project directory
+2. Tell it what to do
+3. It will read and write to files and run commands to produce the code you want
+
+Note: Codecane will run commands in your terminal as it deems necessary to fulfill your request.
+
+## Installation
+
+This package is not published for public installation. For a local validation pack only:
+
+```bash
+npm pack ./cli/release-staging --dry-run
+```
+
+Do not install this package as the production `savant-code` CLI.
+
+## Usage
+
+For local validation, start the staging binary with:
+
+```bash
+savant-code-staging [project-directory]
+```
+
+If no project directory is specified, Savant-Code Staging will use the current directory.
+
+Once running, simply chat with Codecane to say what coding task you want done.
+
+## Features
+
+- Understands your whole codebase
+- Creates and edits multiple files based on your request
+- Can run your tests or type checker or linter; can install packages
+- It's powerful: ask Codecane to keep working until it reaches a condition and it will.
+
+Our users regularly use Codecane to implement new features, write unit tests, refactor code, write scripts, or give advice.
+
+## Knowledge Files
+
+To unlock the full benefits of modern LLMs, we recommend storing knowledge alongside your code. Add a `knowledge.md`
+file anywhere in your project to provide helpful context, guidance, and tips for the LLM as it performs tasks for you.
+
+Codecane can fluently read and write files, so it will add knowledge as it goes. You don't need to write knowledge manually!
+
+Some have said every change should be paired with a unit test. In 2024, every change should come with a knowledge update!
+
+## Tips
+
+1. Type '/help' or just '/' to see available commands.
+2. Create a `knowledge.md` file and collect specific points of advice. The assistant will use this knowledge to improve
+   its responses.
+3. Type `undo` or `redo` to revert or reapply file changes from the conversation.
+4. Press `Esc` or `Ctrl+C` while Codecane is generating a response to stop it.
+
+## Troubleshooting
+
+This package is not intended for installation from npm. If a local validation pack fails, rerun the dry-run command
+above and report the failure to the release owner.
+
+## Feedback
+
+We value your input! Please email your feedback to `founders@savant-code.com`. Thank you for using Codecane!

package/cli/release-staging/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+
+const fs = require('fs')
+const path = require('path')
+
+const packagedLauncherPath = path.join(__dirname, 'launcher.js')
+const sourceLauncherPath = path.join(
+  __dirname,
+  '..',
+  'release-core',
+  'launcher.js',
+)
+// Published packages must not let an unrelated sibling path shadow their
+// bundled launcher. Source checkouts only fall back when that copy is absent.
+const { createLauncher } = require(
+  fs.existsSync(packagedLauncherPath)
+    ? packagedLauncherPath
+    : sourceLauncherPath,
+)
+
+const launcher = createLauncher({
+  packageName: 'savant-code-staging',
+  displayName: 'Codecane',
+  includeTreeSitterWasm: false,
+  startupBanner: [
+    '\x1b[1m\x1b[91m' + '='.repeat(60) + '\x1b[0m',
+    '\x1b[1m\x1b[93m❄️ CODECANE STAGING ENVIRONMENT ❄️\x1b[0m',
+    '\x1b[1m\x1b[91mFOR TESTING PURPOSES ONLY - NOT FOR PRODUCTION USE\x1b[0m',
+    '\x1b[1m\x1b[91m' + '='.repeat(60) + '\x1b[0m',
+  ],
+  telemetryProperties: { isStaging: true },
+  tempDownloadDirName: '.download-temp-staging',
+})
+
+module.exports = launcher
+
+if (require.main === module) {
+  launcher.main().catch((error) => {
+    console.error('❌ Unexpected error:', error.message)
+    process.exit(1)
+  })
+}

package/cli/release-staging/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "savant-code-staging",
+  "version": "0.0.1",
+  "private": true,
+  "description": "Savant-Code AI coding agent CLI (staging)",
+  "license": "Apache-2.0",
+  "bin": {
+    "savant-code-staging": "index.js"
+  },
+  "scripts": {
+    "prepack": "node ../release-core/prepare-package.js",
+    "postpack": "node ../release-core/prepare-package.js --clean"
+  },
+  "files": [
+    "index.js",
+    "launcher.js",
+    "http.js",
+    "README.md"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {
+    "tar": "^7.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/savant0x/savant-code.git"
+  },
+  "homepage": "https://savant-code.com",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/cli/scripts/build-binary.ts

@@ -0,0 +1,469 @@
+#!/usr/bin/env bun
+
+import { spawnSync, type SpawnSyncOptions } from 'child_process'
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'fs'
+import { createRequire } from 'module'
+import { tmpdir } from 'os'
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+
+type TargetInfo = {
+  bunTarget: string
+  platform: NodeJS.Platform
+  arch: string
+}
+
+const VERBOSE = process.env.VERBOSE === 'true'
+const OVERRIDE_TARGET = process.env.OVERRIDE_TARGET
+const OVERRIDE_PLATFORM = process.env.OVERRIDE_PLATFORM as
+  NodeJS.Platform | undefined
+const OVERRIDE_ARCH = process.env.OVERRIDE_ARCH ?? undefined
+const OVERRIDE_COMPILE_EXECUTABLE_PATH = process.env.BUN_COMPILE_EXECUTABLE_PATH
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+const cliRoot = join(__dirname, '..')
+const repoRoot = dirname(cliRoot)
+
+function log(message: string) {
+  if (VERBOSE) {
+    console.log(message)
+  }
+}
+
+function logAlways(message: string) {
+  console.log(message)
+}
+
+function runCommand(
+  command: string,
+  args: string[],
+  options: SpawnSyncOptions = {},
+) {
+  const result = spawnSync(command, args, {
+    cwd: options.cwd,
+    stdio: VERBOSE ? 'inherit' : 'pipe',
+    env: options.env,
+  })
+
+  if (result.status !== 0) {
+    const stderr = result.stderr?.toString() ?? ''
+    throw new Error(
+      `Command "${command} ${args.join(' ')}" failed with exit code ${
+        result.status
+      }${stderr ? `\n${stderr}` : ''}`,
+    )
+  }
+}
+
+function getTargetInfo(): TargetInfo {
+  if (OVERRIDE_TARGET && OVERRIDE_PLATFORM && OVERRIDE_ARCH) {
+    return {
+      bunTarget: OVERRIDE_TARGET,
+      platform: OVERRIDE_PLATFORM,
+      arch: OVERRIDE_ARCH,
+    }
+  }
+
+  const platform = process.platform
+  const arch = process.arch
+
+  const mappings: Record<string, TargetInfo> = {
+    'linux-x64': { bunTarget: 'bun-linux-x64', platform: 'linux', arch: 'x64' },
+    'linux-arm64': {
+      bunTarget: 'bun-linux-arm64',
+      platform: 'linux',
+      arch: 'arm64',
+    },
+    'darwin-x64': {
+      bunTarget: 'bun-darwin-x64',
+      platform: 'darwin',
+      arch: 'x64',
+    },
+    'darwin-arm64': {
+      bunTarget: 'bun-darwin-arm64',
+      platform: 'darwin',
+      arch: 'arm64',
+    },
+    'win32-x64': {
+      bunTarget: 'bun-windows-x64',
+      platform: 'win32',
+      arch: 'x64',
+    },
+  }
+
+  const key = `${platform}-${arch}`
+  const target = mappings[key]
+
+  if (!target) {
+    throw new Error(`Unsupported build target: ${key}`)
+  }
+
+  return target
+}
+
+function getCliTargetLabel(targetInfo: TargetInfo): string {
+  const baseTarget = `${targetInfo.platform}-${targetInfo.arch}`
+  return targetInfo.bunTarget.endsWith('-baseline')
+    ? `${baseTarget}-baseline`
+    : baseTarget
+}
+
+async function main() {
+  const [, , binaryNameArg, version] = process.argv
+  const binaryName = binaryNameArg ?? 'savant-code'
+
+  if (!version) {
+    throw new Error('Version argument is required when building a binary')
+  }
+
+  // Release binaries must run in production mode. Local dev builds can opt out
+  // by setting SAVANT_CODE_BUILD_ENV before invoking this script.
+  const buildEnv = process.env.SAVANT_CODE_BUILD_ENV
+  process.env.NEXT_PUBLIC_CB_ENVIRONMENT = buildEnv ?? 'prod'
+
+  log(
+    `Building ${binaryName} @ ${version} (env=${process.env.NEXT_PUBLIC_CB_ENVIRONMENT})`,
+  )
+
+  const targetInfo = getTargetInfo()
+  const binDir = join(cliRoot, 'bin')
+
+  if (!existsSync(binDir)) {
+    mkdirSync(binDir, { recursive: true })
+  }
+
+  // Generate bundled agents file before compiling
+  log('Generating bundled agents...')
+  runCommand('bun', ['run', 'scripts/prebuild-agents.ts'], {
+    cwd: cliRoot,
+    env: process.env,
+  })
+
+  // Ensure SDK assets exist before compiling the CLI
+  log('Building SDK dependencies...')
+  runCommand('bun', ['run', '--cwd', '../sdk', 'build'], {
+    cwd: cliRoot,
+    env: process.env,
+  })
+
+  patchOpenTuiAssetPaths()
+  await ensureOpenTuiNativeBundle(targetInfo)
+
+  const outputFilename =
+    targetInfo.platform === 'win32' ? `${binaryName}.exe` : binaryName
+  const outputFile = join(binDir, outputFilename)
+
+  // Build the canonical runtime environment for the release binary. We used
+  // to pass these as `--define` flags, but workspace packages are pre-built
+  // to dist and minified, so `--define` does not reliably replace every
+  // `process.env.*` reference. Instead we ship an `env.json` next to the
+  // binary and load it at startup (see cli/src/pre-init/load-dev-env.ts).
+  const binaryEnv: Record<string, string> = {
+    NODE_ENV: 'production',
+    SAVANT_CODE_IS_BINARY: 'true',
+    SAVANT_CODE_CLI_VERSION: version,
+    SAVANT_CODE_CLI_TARGET: getCliTargetLabel(targetInfo),
+    SAVANT_FREE_MODE: process.env.SAVANT_FREE_MODE ?? 'false',
+  }
+
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith('NEXT_PUBLIC_') && value !== undefined) {
+      binaryEnv[key] = value
+    }
+  }
+
+  const defineFlags = [
+    ['process.env.NODE_ENV', '"production"'],
+    ['process.env.SAVANT_CODE_IS_BINARY', '"true"'],
+    ['process.env.SAVANT_CODE_CLI_VERSION', `"${version}"`],
+    [
+      'process.env.SAVANT_CODE_CLI_TARGET',
+      `"${getCliTargetLabel(targetInfo)}"`,
+    ],
+    [
+      'process.env.SAVANT_FREE_MODE',
+      `"${process.env.SAVANT_FREE_MODE ?? 'false'}"`,
+    ],
+    // FID-2026-0803-002 DB-8: llm-providers' `openai-compatible/version.ts`
+    // reads `__PACKAGE_VERSION__` (bare identifier, source-consumed) with a
+    // `0.0.0-test` fallback. Without this define every request advertises the
+    // test suffix in the User-Agent. `--define` is reliable here because the
+    // reference lives in source (not a pre-built dist bundle).
+    ['__PACKAGE_VERSION__', `"${version}"`],
+  ]
+
+  const buildArgs = [
+    'build',
+    'src/index.tsx',
+    '--compile',
+    '--production', // Required so compiled binaries use the production JSX runtime (avoids jsxDEV crashes).
+    '--no-compile-autoload-bunfig', // User project bunfig.toml must not affect the standalone CLI.
+    `--target=${targetInfo.bunTarget}`,
+    ...(OVERRIDE_COMPILE_EXECUTABLE_PATH
+      ? [`--compile-executable-path=${OVERRIDE_COMPILE_EXECUTABLE_PATH}`]
+      : []),
+    `--outfile=${outputFile}`,
+    '--sourcemap=none',
+    // Keep non-env build constants as `--define` fallbacks. Env vars are
+    // injected at runtime via the sibling env.json file.
+    ...defineFlags.flatMap(([key, value]) => ['--define', `${key}=${value}`]),
+  ]
+
+  log(
+    `bun ${buildArgs
+      .map((arg) => (arg.includes(' ') ? `"${arg}"` : arg))
+      .join(' ')}`,
+  )
+
+  runCommand('bun', buildArgs, { cwd: cliRoot })
+
+  // Ship tree-sitter.wasm as a sibling file next to the binary. Bun
+  // --compile asset embedding is unreliable on Windows (every JS-level
+  // retrieval mechanism we tried — `with { type: 'file' }`, base64 string
+  // literals, chunked base64, function-wrapped chunked base64 — got
+  // tree-shaken, minified away, or returned an undefined binding even
+  // when the bytes were in the binary). The pre-init reads it from
+  // `dirname(process.execPath)`, which works the same on every platform
+  // because it's a normal disk read, not a bunfs lookup.
+  const sourceWasm = findWebTreeSitterWasm()
+  const siblingWasm = join(binDir, 'tree-sitter.wasm')
+  writeFileSync(siblingWasm, readFileSync(sourceWasm))
+  logAlways(`Copied tree-sitter.wasm sibling: ${sourceWasm} → ${siblingWasm}`)
+
+  // Ship the runtime environment as a sibling JSON file. This is more
+  // reliable than `--define` because workspace packages are pre-built to
+  // dist and minified, so compile-time replacements can miss references.
+  const envJsonPath = join(binDir, 'env.json')
+  writeFileSync(envJsonPath, JSON.stringify(binaryEnv, null, 2))
+  logAlways(`Wrote env.json sibling: ${envJsonPath}`)
+
+  // FID-2026-0803-011 BH-3: bun --compile emits an `index.js.map` sibling
+  // even with `--sourcemap=none` (verified on bun 1.3.11). It is not shipped
+  // by the release tarball (binary + tree-sitter.wasm + env.json only) and
+  // nothing references it — remove it so local builds stay lean.
+  rmSync(join(binDir, 'index.js.map'), { force: true })
+
+  if (targetInfo.platform !== 'win32') {
+    chmodSync(outputFile, 0o755)
+  }
+
+  logAlways(`✅ Built ${outputFilename} (${getCliTargetLabel(targetInfo)})`)
+}
+
+main().catch((error: unknown) => {
+  if (error instanceof Error) {
+    console.error(error.message)
+  } else {
+    console.error(error)
+  }
+  process.exit(1)
+})
+
+/**
+ * Find web-tree-sitter's tree-sitter.wasm in any plausible node_modules
+ * layout — bun hoists differently across platforms and `bun install`
+ * variants, and CI Windows lays it out differently than monorepo-root
+ * installs.
+ */
+function findWebTreeSitterWasm(): string {
+  const candidates = [
+    join(cliRoot, 'node_modules', 'web-tree-sitter', 'tree-sitter.wasm'),
+    join(cliRoot, '..', 'node_modules', 'web-tree-sitter', 'tree-sitter.wasm'),
+    join(
+      cliRoot,
+      '..',
+      'sdk',
+      'node_modules',
+      'web-tree-sitter',
+      'tree-sitter.wasm',
+    ),
+  ]
+  const found = candidates.find((p) => existsSync(p))
+  if (found) return found
+  try {
+    const cliRequire = createRequire(join(cliRoot, 'package.json'))
+    return cliRequire.resolve('web-tree-sitter/tree-sitter.wasm')
+  } catch (err) {
+    throw new Error(
+      `Could not locate web-tree-sitter/tree-sitter.wasm. Searched:\n  - ` +
+        candidates.join('\n  - ') +
+        `\nAnd createRequire failed: ${err instanceof Error ? err.message : String(err)}`,
+    )
+  }
+}
+
+function patchOpenTuiAssetPaths() {
+  const coreDir = join(cliRoot, 'node_modules', '@opentui', 'core')
+  if (!existsSync(coreDir)) {
+    log('OpenTUI core package not found; skipping asset patch')
+    return
+  }
+
+  const indexFile = readdirSync(coreDir).find(
+    (file) => file.startsWith('index') && file.endsWith('.js'),
+  )
+
+  if (!indexFile) {
+    log('OpenTUI core index bundle not found; skipping asset patch')
+    return
+  }
+
+  const indexPath = join(coreDir, indexFile)
+  const content = readFileSync(indexPath, 'utf8')
+
+  const absolutePathPattern =
+    /var __dirname = ".*?packages\/core\/src\/lib\/tree-sitter\/assets";/
+  if (!absolutePathPattern.test(content)) {
+    log('OpenTUI core bundle already has relative asset paths')
+    return
+  }
+
+  const replacement =
+    'var __dirname = path3.join(path3.dirname(fileURLToPath(new URL(".", import.meta.url))), "lib/tree-sitter/assets");'
+
+  const patched = content.replace(absolutePathPattern, replacement)
+  writeFileSync(indexPath, patched)
+  logAlways('Patched OpenTUI core tree-sitter asset paths')
+}
+
+async function ensureOpenTuiNativeBundle(targetInfo: TargetInfo) {
+  const packageName = `@opentui/core-${targetInfo.platform}-${targetInfo.arch}`
+  const packageFolder = `core-${targetInfo.platform}-${targetInfo.arch}`
+  const installTargets = [
+    {
+      label: 'workspace root',
+      packagesDir: join(repoRoot, 'node_modules', '@opentui'),
+      packageDir: join(repoRoot, 'node_modules', '@opentui', packageFolder),
+    },
+    {
+      label: 'CLI workspace',
+      packagesDir: join(cliRoot, 'node_modules', '@opentui'),
+      packageDir: join(cliRoot, 'node_modules', '@opentui', packageFolder),
+    },
+  ]
+
+  const missingTargets = installTargets.filter(
+    ({ packageDir }) => !existsSync(packageDir),
+  )
+  if (missingTargets.length === 0) {
+    log(
+      `OpenTUI native bundle already present for ${targetInfo.platform}-${targetInfo.arch}`,
+    )
+    return
+  }
+
+  const corePackagePath =
+    installTargets
+      .map(({ packagesDir }) => join(packagesDir, 'core', 'package.json'))
+      .find((candidate) => existsSync(candidate)) ?? null
+
+  if (!corePackagePath) {
+    log('OpenTUI core package metadata missing; skipping native bundle fetch')
+    return
+  }
+  const corePackageJson = JSON.parse(readFileSync(corePackagePath, 'utf8')) as {
+    optionalDependencies?: Record<string, string>
+  }
+  const version = corePackageJson.optionalDependencies?.[packageName]
+  if (!version) {
+    log(
+      `No optional dependency declared for ${packageName}; skipping native bundle fetch`,
+    )
+    return
+  }
+
+  const registryBase =
+    process.env.SAVANT_CODE_NPM_REGISTRY ??
+    process.env.NPM_REGISTRY_URL ??
+    'https://registry.npmjs.org'
+  const metadataUrl = `${registryBase.replace(/\/$/, '')}/${encodeURIComponent(packageName)}`
+  log(`Fetching OpenTUI native bundle metadata from ${metadataUrl}`)
+
+  const metadataResponse = await fetch(metadataUrl)
+  if (!metadataResponse.ok) {
+    throw new Error(
+      `Failed to fetch metadata for ${packageName}: ${metadataResponse.status} ${metadataResponse.statusText}`,
+    )
+  }
+
+  const metadataResponseBody = await metadataResponse.json()
+  const metadata = metadataResponseBody as {
+    versions?: Record<
+      string,
+      {
+        dist?: {
+          tarball?: string
+        }
+      }
+    >
+  }
+  const tarballUrl = metadata.versions?.[version]?.dist?.tarball
+  if (!tarballUrl) {
+    throw new Error(`Tarball URL missing for ${packageName}@${version}`)
+  }
+
+  log(`Downloading OpenTUI native bundle from ${tarballUrl}`)
+  const tarballResponse = await fetch(tarballUrl)
+  if (!tarballResponse.ok) {
+    throw new Error(
+      `Failed to download ${packageName}@${version}: ${tarballResponse.status} ${tarballResponse.statusText}`,
+    )
+  }
+
+  const tempDir = mkdtempSync(join(tmpdir(), 'opentui-'))
+  try {
+    const tarballPath = join(
+      tempDir,
+      `${packageName.split('/').pop() ?? 'package'}-${version}.tgz`,
+    )
+    const tarballBuffer = await tarballResponse.arrayBuffer()
+    await Bun.write(tarballPath, tarballBuffer)
+
+    for (const target of missingTargets) {
+      mkdirSync(target.packagesDir, { recursive: true })
+      mkdirSync(target.packageDir, { recursive: true })
+
+      if (!existsSync(target.packageDir)) {
+        throw new Error(
+          `Failed to create directory for ${packageName}: ${target.packageDir}`,
+        )
+      }
+
+      const tarballForTar =
+        process.platform === 'win32'
+          ? tarballPath.replace(/\\/g, '/')
+          : tarballPath
+      const extractDirForTar =
+        process.platform === 'win32'
+          ? target.packageDir.replace(/\\/g, '/')
+          : target.packageDir
+
+      const tarArgs = [
+        '-xzf',
+        tarballForTar,
+        '--strip-components=1',
+        '-C',
+        extractDirForTar,
+      ]
+      runCommand('tar', tarArgs)
+      log(
+        `Installed OpenTUI native bundle for ${targetInfo.platform}-${targetInfo.arch} in ${target.label}`,
+      )
+    }
+    logAlways(
+      `Fetched OpenTUI native bundle for ${targetInfo.platform}-${targetInfo.arch}`,
+    )
+  } finally {
+    rmSync(tempDir, { recursive: true, force: true })
+  }
+}

package/cli/scripts/clean.ts

@@ -0,0 +1,16 @@
+#!/usr/bin/env bun
+
+// FID-2026-0803-011 BH-3: purge cli/bin build artifacts. Everything in bin/
+// is generated (see scripts/build-binary.ts + src/pre-init/tree-sitter-wasm.ts)
+// and gitignored (root .gitignore + cli/.gitignore), so removal is safe and
+// self-healing via `bun run build:binary` / `bun savant-free/cli/build.ts`.
+
+import { rmSync } from 'fs'
+import { dirname, join } from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const binDir = join(__dirname, '..', 'bin')
+
+rmSync(binDir, { recursive: true, force: true })
+console.log(`Cleaned ${binDir}`)