skalpel 2.0.23 → 3.0.0

package/npm-bin/colors.js

@@ -0,0 +1,125 @@
+'use strict';
+
+// colors.js — Catppuccin Frappé palette wrapper for the npm-side
+// surfaces (npx wizard banner, postinstall success line). Reads the
+// canonical hex values from design-tokens.json (Wave 1 artifact) and
+// wraps Picocolors so NO_COLOR is honoured automatically. The box()
+// helper draws a rounded Unicode-art frame around content; structure
+// chars are emitted unconditionally, only the ANSI sequences are
+// suppressed under NO_COLOR.
+
+const path = require('path');
+const pc = require('picocolors');
+
+const tokens = require(path.resolve(__dirname, '..', 'design-tokens.json'));
+
+const palette = (tokens.themes && tokens.themes.frappe) || {};
+
+function rgbFromHex(hex) {
+  const m = String(hex || '').replace('#', '').match(/^([0-9a-fA-F]{6})$/);
+  if (!m) return null;
+  const v = parseInt(m[1], 16);
+  return [(v >> 16) & 0xff, (v >> 8) & 0xff, v & 0xff];
+}
+
+function colorize(hex) {
+  const rgb = rgbFromHex(hex);
+  if (!rgb) {
+    return (s) => String(s);
+  }
+  return (s) => {
+    if (process.env.NO_COLOR) return String(s);
+    return `\x1b[38;2;${rgb[0]};${rgb[1]};${rgb[2]}m${s}\x1b[39m`;
+  };
+}
+
+const theme = {};
+for (const name of Object.keys(palette)) {
+  theme[name] = colorize(palette[name]);
+}
+
+function attr(open, close) {
+  return (s) => {
+    if (process.env.NO_COLOR) return String(s);
+    return `\x1b[${open}m${s}\x1b[${close}m`;
+  };
+}
+
+theme.bold = attr(1, 22);
+theme.italic = attr(3, 23);
+theme.dim = attr(2, 22);
+
+const semantic = (tokens.semantic) || {};
+
+function semanticHelper(key) {
+  const ref = semantic[key];
+  if (!ref) return (s) => String(s);
+  const parts = ref.split('.');
+  if (parts.length !== 2) return (s) => String(s);
+  const colorName = parts[1];
+  return theme[colorName] || ((s) => String(s));
+}
+
+function semanticKey(name) {
+  return name
+    .replace(/[^a-zA-Z0-9]+([a-zA-Z0-9])/g, (_, c) => c.toUpperCase())
+    .replace(/^([A-Z])/, (m) => m.toLowerCase());
+}
+
+for (const k of Object.keys(semantic)) {
+  const camel = semanticKey(k);
+  theme[camel] = semanticHelper(k);
+}
+
+const BORDERS = {
+  topLeft: '╭',
+  topRight: '╮',
+  bottomLeft: '╰',
+  bottomRight: '╯',
+  horizontal: '─',
+  vertical: '│',
+};
+
+function visibleLength(s) {
+  return String(s).replace(/\x1b\[[0-9;]*m/g, '').length;
+}
+
+function box(content, borderColor, options) {
+  const opts = options || {};
+  const padding = typeof opts.padding === 'number' ? opts.padding : 1;
+  const lines = String(content).split('\n');
+
+  let inner;
+  if (opts.width === 'fit' || opts.width == null) {
+    inner = 0;
+    for (const ln of lines) {
+      const len = visibleLength(ln);
+      if (len > inner) inner = len;
+    }
+    inner += padding * 2;
+  } else {
+    inner = Math.max(0, Number(opts.width) - 2);
+  }
+
+  const colorOK = pc.isColorSupported && !process.env.NO_COLOR;
+  const colorFn = (colorOK && typeof borderColor === 'string' && theme[borderColor])
+    ? theme[borderColor]
+    : (s) => String(s);
+
+  const horiz = BORDERS.horizontal.repeat(inner);
+  const top = colorFn(BORDERS.topLeft + horiz + BORDERS.topRight);
+  const bottom = colorFn(BORDERS.bottomLeft + horiz + BORDERS.bottomRight);
+  const v = colorFn(BORDERS.vertical);
+  const pad = ' '.repeat(padding);
+
+  const rendered = [top];
+  for (const ln of lines) {
+    const visLen = visibleLength(ln);
+    const fill = ' '.repeat(Math.max(0, inner - padding * 2 - visLen));
+    rendered.push(`${v}${pad}${ln}${fill}${pad}${v}`);
+  }
+  rendered.push(bottom);
+  return rendered.join('\n');
+}
+
+module.exports = { theme, box, BORDERS, palette };

package/npm-bin/skalpel.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+// Dispatch shim: locate the platform-specific `skalpel` binary that
+// optionalDependencies installed, then exec it with the user's argv.
+//
+// On first interactive run we render a one-time welcome banner before
+// dispatching. The "first run" predicate is the absence of a flag file
+// at $XDG_STATE_HOME/skalpel/.installed (Unix) or
+// %LOCALAPPDATA%\skalpel\.installed (Windows). If the flag-file write
+// fails (perm denied) we log a single dim line and continue dispatch —
+// banner repeats on every invocation under that condition.
+//
+// TTY/NO_COLOR rules:
+//   non-TTY (piped stdout)         → suppress banner entirely
+//   TTY + NO_COLOR set             → render box structure, no ANSI
+//   interactive TTY, NO_COLOR off  → fully colored banner
+//
+// Reference banner (rendered by colors.js box helper):
+//
+//   ╭───────────────────────────────────╮
+//   │ skalpel  v0.0.1                   │
+//   │                                   │
+//   │ ✓ Detecting platform… darwin-arm64│
+//   │ ✓ Resolving binary…   found       │
+//   ╰───────────────────────────────────╯
+//
+// On error a styled error block frames a ✗ glyph + title + body + hint.
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const colors = require('./colors.js');
+const { theme, box } = colors;
+
+const PLATFORM_PACKAGES = {
+  'darwin-arm64': '@skalpelai/skalpel-darwin-arm64',
+  'darwin-x64': '@skalpelai/skalpel-darwin-x64',
+  'linux-arm64': '@skalpelai/skalpel-linux-arm64',
+  'linux-x64': '@skalpelai/skalpel-linux-x64',
+  'win32-x64': '@skalpelai/skalpel-win32-x64',
+};
+
+function pkgVersion() {
+  try {
+    return require('../package.json').version || '0.0.0';
+  } catch (_) {
+    return '0.0.0';
+  }
+}
+
+function flagFilePath() {
+  if (os.platform() === 'win32') {
+    const root = process.env.LOCALAPPDATA;
+    if (!root) return null;
+    return path.join(root, 'skalpel', '.installed');
+  }
+  const root = process.env.XDG_STATE_HOME
+    || (process.env.HOME ? path.join(process.env.HOME, '.local', 'state') : null);
+  if (!root) return null;
+  return path.join(root, 'skalpel', '.installed');
+}
+
+function isFirstRun() {
+  const p = flagFilePath();
+  if (!p) return false;
+  try {
+    return !fs.existsSync(p);
+  } catch (_) {
+    return false;
+  }
+}
+
+function markInstalled() {
+  const p = flagFilePath();
+  if (!p) return { ok: false, path: null };
+  try {
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, `${new Date().toISOString()}\n`);
+    return { ok: true, path: p };
+  } catch (err) {
+    return { ok: false, path: p, err };
+  }
+}
+
+function renderWelcome(version, platformLabel, opts) {
+  const colored = opts && opts.colored;
+  const v = colored ? theme.bold(theme.mauve(`skalpel  v${version}`)) : `skalpel  v${version}`;
+  const detect = colored
+    ? `${theme.green('✓')} ${theme.text(`Detecting platform… ${platformLabel}`)}`
+    : `✓ Detecting platform… ${platformLabel}`;
+  const resolve = colored
+    ? `${theme.green('✓')} ${theme.text('Resolving binary…   found')}`
+    : `✓ Resolving binary…   found`;
+  const body = [v, '', detect, resolve].join('\n');
+  return box(body, colored ? 'mauve' : null, { padding: 1 });
+}
+
+function renderError(title, body, hint, opts) {
+  const colored = opts && opts.colored;
+  const t = colored ? theme.bold(theme.red(`✗ ${title}`)) : `✗ ${title}`;
+  const b = colored ? theme.dim(theme.text(body)) : body;
+  const h = colored ? theme.mauve(hint) : hint;
+  const content = [t, '', b, '', h].join('\n');
+  return box(content, colored ? 'red' : null, { padding: 1 });
+}
+
+function emitBanner(stream, platformLabel) {
+  if (!stream.isTTY) return; // non-TTY: suppress entirely
+  const colored = !process.env.NO_COLOR;
+  const banner = renderWelcome(pkgVersion(), platformLabel, { colored });
+  stream.write(`${banner}\n`);
+  const m = markInstalled();
+  if (!m.ok && m.path) {
+    const dim = colored ? theme.dim : (s) => s;
+    stream.write(`${dim(`(welcome shown but flag file unwritable: ${m.path})`)}\n`);
+  }
+}
+
+function emitError(stream, title, body, hint) {
+  const colored = stream.isTTY && !process.env.NO_COLOR;
+  const block = renderError(title, body, hint, { colored });
+  stream.write(`${block}\n`);
+}
+
+function platformLabel() {
+  return `${os.platform()}-${os.arch()}`;
+}
+
+// isInfoArg returns true for argv shapes that only request info
+// (--help / --version / -h / -v / help / version). When dispatch
+// fails for those args (no platform binary) we render an error
+// block and exit 0, since the shim succeeded at communicating.
+function isInfoArg(argv) {
+  if (argv.length === 0) return false;
+  const a = argv[0];
+  return a === '--help' || a === '-h' || a === 'help' ||
+    a === '--version' || a === '-v' || a === 'version';
+}
+
+function resolveBinary(name, argv) {
+  const infoOnly = isInfoArg(argv || []);
+  const failExit = infoOnly ? 0 : 1;
+  const key = `${process.platform}-${process.arch}`;
+  const pkg = PLATFORM_PACKAGES[key];
+  if (!pkg) {
+    const supported = Object.keys(PLATFORM_PACKAGES).join(', ');
+    emitError(
+      process.stderr,
+      'Unsupported platform',
+      `skalpel does not ship a binary for ${key}.\nSupported: ${supported}.`,
+      `→ Install from GitHub Releases: https://github.com/skalpelai/Skalpelai_Client/releases`
+    );
+    process.exit(failExit);
+  }
+  const exe = process.platform === 'win32' ? `${name}.exe` : name;
+  let pkgRoot;
+  try {
+    pkgRoot = path.dirname(require.resolve(`${pkg}/package.json`));
+  } catch (_err) {
+    emitError(
+      process.stderr,
+      'Platform package missing',
+      `${pkg} is not installed.`,
+      `→ Re-run \`npm install -g skalpel\` or \`npx skalpel\``
+    );
+    process.exit(failExit);
+  }
+  const candidate = path.join(pkgRoot, 'bin', exe);
+  if (!fs.existsSync(candidate)) {
+    emitError(
+      process.stderr,
+      'Binary missing',
+      `Expected binary at ${candidate} but it does not exist.`,
+      `→ Reinstall: \`npm install -g skalpel\``
+    );
+    process.exit(failExit);
+  }
+  return candidate;
+}
+
+if (require.main === module) {
+  if (isFirstRun()) {
+    emitBanner(process.stdout, platformLabel());
+  }
+  const argv = process.argv.slice(2);
+  const binary = resolveBinary('skalpel', argv);
+  const result = spawnSync(binary, argv, {
+    stdio: 'inherit',
+  });
+  if (result.error) {
+    emitError(process.stderr, 'Spawn failed', result.error.message, '→ Check that the binary is executable.');
+    process.exit(1);
+  }
+  process.exit(result.status === null ? 1 : result.status);
+}
+
+module.exports = { resolveBinary, PLATFORM_PACKAGES, renderWelcome, renderError, flagFilePath };

package/npm-bin/skalpeld.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+// Dispatch shim for the daemon. See npm-bin/skalpel.js for the
+// resolution rationale; this file delegates to the same lookup table.
+
+'use strict';
+
+const { spawnSync } = require('child_process');
+const { resolveBinary } = require('./skalpel.js');
+
+if (require.main === module) {
+  const binary = resolveBinary('skalpeld');
+  const result = spawnSync(binary, process.argv.slice(2), {
+    stdio: 'inherit',
+  });
+  if (result.error) {
+    process.stderr.write(`skalpeld: ${result.error.message}\n`);
+    process.exit(1);
+  }
+  process.exit(result.status === null ? 1 : result.status);
+}

package/package.json

@@ -1,81 +1,63 @@
 {
   "name": "skalpel",
-  "version": "2.0.23",
-  "type": "module",
-  "description": "Skalpel AI SDK — optimize your OpenAI and Anthropic API calls",
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
-    }
+  "version": "3.0.0",
+  "description": "Skalpel — local proxy and TUI for coding agents (skalpel + skalpeld bundle).",
+  "license": "Apache-2.0",
+  "homepage": "https://skalpel.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/skalpelai/Skalpelai_Client.git"
+  },
+  "bugs": {
+    "url": "https://github.com/skalpelai/Skalpelai_Client/issues"
+  },
+  "author": "SkalpelAI Inc.",
+  "keywords": [
+    "coding-agent",
+    "proxy",
+    "tui",
+    "claude",
+    "cursor",
+    "codex"
+  ],
+  "engines": {
+    "node": ">=18"
   },
   "bin": {
-    "skalpel": "./dist/cli/index.js"
+    "skalpel": "npm-bin/skalpel.js",
+    "skalpeld": "npm-bin/skalpeld.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall/index.js",
+    "preuninstall": "node postinstall/index.js --uninstall",
+    "test": "echo 'no top-level tests; run make test or npm run test:rc-edit' && exit 0",
+    "test:rc-edit": "node postinstall/lib/rc-edit.test.js"
   },
   "files": [
-    "dist",
+    "npm-bin/",
+    "postinstall/",
+    "design-tokens.json",
+    "INSTALL.md",
     "README.md",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsup",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "typecheck": "tsc --noEmit",
-    "seed-demo-key": "node scripts/seed-demo-key.mjs",
-    "prepublishOnly": "npm run build"
-  },
-  "peerDependencies": {
-    "@anthropic-ai/sdk": ">=0.30.0",
-    "openai": ">=4.0.0"
-  },
-  "peerDependenciesMeta": {
-    "openai": {
-      "optional": true
-    },
-    "@anthropic-ai/sdk": {
-      "optional": true
-    }
-  },
-  "devDependencies": {
-    "@anthropic-ai/sdk": "^0.30.0",
-    "@types/ws": "^8.18.1",
-    "@vitest/coverage-v8": "^2.0.0",
-    "fast-check": "^3.22.0",
-    "openai": "^4.0.0",
-    "pg": "^8.13.0",
-    "tsup": "^8.0.0",
-    "typescript": "^5.4.0",
-    "vitest": "^2.0.0"
+  "dependencies": {
+    "picocolors": "^1.1.1"
   },
-  "keywords": [
-    "llm",
-    "openai",
-    "anthropic",
-    "api",
-    "gateway",
-    "proxy",
-    "cost-optimization",
-    "ai",
-    "sdk"
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
   ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/skalpelai/Skalpel_User.git"
-  },
-  "homepage": "https://skalpel.ai",
-  "bugs": {
-    "url": "https://github.com/skalpelai/Skalpel_User/issues"
-  },
-  "license": "MIT",
-  "dependencies": {
-    "commander": "^14.0.3",
-    "open": "^10.0.0",
-    "undici": "^6.24.1",
-    "ws": "^8.20.0"
+  "cpu": [
+    "arm64",
+    "x64"
+  ],
+  "optionalDependencies": {
+    "@skalpelai/skalpel-darwin-arm64": "3.0.0",
+    "@skalpelai/skalpel-darwin-x64": "3.0.0",
+    "@skalpelai/skalpel-linux-arm64": "3.0.0",
+    "@skalpelai/skalpel-linux-x64": "3.0.0",
+    "@skalpelai/skalpel-win32-x64": "3.0.0"
   }
 }