@injectivelabs/ainj 0.0.1

package/dist/cli/status-cli.js

@@ -0,0 +1,43 @@
+import { readdir } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+import { readState } from '../install/state.js';
+
+const { version } = createRequire(import.meta.url)('../../package.json');
+const thisDir = import.meta.dirname;
+
+export async function run(
+  _args,
+  { _readState = readState, _readdir = readdir, _log = console.log } = {},
+) {
+  const state = _readState('global');
+
+  const scope = state.scope ?? '(none)';
+  const mainPort = state.ports?.main ?? '(none)';
+  const docsPort = state.ports?.docs ?? '(none)';
+  const harnesses = state.harnesses?.length ? state.harnesses.join(', ') : '(none)';
+  const defaultHarness = state.defaultHarness ?? '(none)';
+
+  const agentsSkillsDir = path.join(thisDir, '../../.agents/skills');
+  let skillNames = [];
+  try {
+    const entries = await _readdir(agentsSkillsDir, { withFileTypes: true });
+    skillNames = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+  }
+  let skillsStr;
+  if (skillNames.length > 0) {
+    skillsStr = `${skillNames.length} available.`;
+  } else {
+    skillsStr = '(none)';
+  }
+
+  _log(`version: ${version}`);
+  _log(`scope: ${scope}`);
+  _log(`ports: main=${mainPort}, docs=${docsPort}`);
+  _log(`harnesses: ${harnesses}`);
+  _log(`default harness: ${defaultHarness}`);
+  _log(`skills: ${skillsStr}`);
+}

package/dist/cli/update-cli.js

@@ -0,0 +1,16 @@
+import { spawnSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+
+import { readState } from '../install/state.js';
+
+const { name: packageName } = createRequire(import.meta.url)('../../package.json');
+
+export async function run(_args, { _readState = readState, _spawnSync = spawnSync } = {}) {
+  const state = _readState('global');
+
+  if (state.scope === 'local') {
+    _spawnSync('npm', ['install', `${packageName}@latest`], { stdio: 'inherit' });
+  } else {
+    _spawnSync('npm', ['install', '-g', `${packageName}@latest`], { stdio: 'inherit' });
+  }
+}

package/dist/env.js

@@ -0,0 +1,22 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+
+export function loadEnv(cwd = process.cwd()) {
+  let content;
+  try {
+    content = readFileSync(join(cwd, '.env'), 'utf8');
+  } catch {
+    return;
+  }
+  for (const line of content.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const eqIdx = trimmed.indexOf('=');
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx);
+    const value = trimmed.slice(eqIdx + 1);
+    if (key && !(key in process.env)) {
+      process.env[key] = value;
+    }
+  }
+}

package/dist/install/harnesses/claude-code.js

@@ -0,0 +1,31 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export function write(
+  scope,
+  mainPort,
+  docsPort,
+  { homeDir = os.homedir(), cwd = process.cwd() } = {},
+) {
+  const filePath =
+    scope === 'global'
+      ? path.join(homeDir, '.claude.json')
+      : path.join(cwd, '.claude', 'settings.json');
+
+  let data = {};
+  try {
+    data = JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    // File absent or unreadable: start fresh.
+  }
+
+  if (!data.mcpServers) data.mcpServers = {};
+  data.mcpServers['ainj-main'] = { command: 'ainj', args: ['mcp', 'main', 'stdio'] };
+  data.mcpServers['ainj-docs'] = { command: 'ainj', args: ['mcp', 'docs', 'stdio'] };
+  data.mcpServers['ainj-main-http'] = { url: `http://localhost:${mainPort}/mcp` };
+  data.mcpServers['ainj-docs-http'] = { url: `http://localhost:${docsPort}/mcp` };
+
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+}

package/dist/install/harnesses/codex.js

@@ -0,0 +1,51 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { parse as parseToml, stringify as stringifyToml } from 'smol-toml';
+
+export function write(
+  scope,
+  mainPort,
+  docsPort,
+  { homeDir = os.homedir(), cwd = process.cwd() } = {},
+) {
+  if (scope === 'local') {
+    _writeLocal(cwd, mainPort, docsPort);
+  } else {
+    _writeGlobal(homeDir, mainPort, docsPort);
+  }
+}
+
+function _writeGlobal(homeDir, mainPort, docsPort) {
+  const filePath = path.join(homeDir, '.codex', 'config.json');
+  let data = {};
+  try {
+    data = JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    // File absent or unreadable: start fresh.
+  }
+  _mergeEntries(data, mainPort, docsPort);
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+function _writeLocal(cwd, mainPort, docsPort) {
+  const filePath = path.join(cwd, '.codex', 'config.toml');
+  let data = {};
+  try {
+    data = parseToml(readFileSync(filePath, 'utf8'));
+  } catch {
+    // File absent or unreadable: start fresh.
+  }
+  _mergeEntries(data, mainPort, docsPort);
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, stringifyToml(data));
+}
+
+function _mergeEntries(data, mainPort, docsPort) {
+  if (!data.mcpServers) data.mcpServers = {};
+  data.mcpServers['ainj-main'] = { command: 'ainj', args: ['mcp', 'main', 'stdio'] };
+  data.mcpServers['ainj-docs'] = { command: 'ainj', args: ['mcp', 'docs', 'stdio'] };
+  data.mcpServers['ainj-main-http'] = { url: `http://localhost:${mainPort}/mcp` };
+  data.mcpServers['ainj-docs-http'] = { url: `http://localhost:${docsPort}/mcp` };
+}

package/dist/install/harnesses/cursor.js

@@ -0,0 +1,23 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export function write(_scope, mainPort, docsPort, { homeDir = os.homedir() } = {}) {
+  const filePath = path.join(homeDir, '.cursor', 'mcp.json');
+
+  let data = {};
+  try {
+    data = JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    // File absent or unreadable: start fresh.
+  }
+
+  if (!data.mcpServers) data.mcpServers = {};
+  data.mcpServers['ainj-main'] = { command: 'ainj', args: ['mcp', 'main', 'stdio'] };
+  data.mcpServers['ainj-docs'] = { command: 'ainj', args: ['mcp', 'docs', 'stdio'] };
+  data.mcpServers['ainj-main-http'] = { url: `http://localhost:${mainPort}/mcp` };
+  data.mcpServers['ainj-docs-http'] = { url: `http://localhost:${docsPort}/mcp` };
+
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+}

package/dist/install/harnesses/index.js

@@ -0,0 +1,13 @@
+import { write as claudeCode } from './claude-code.js';
+import { write as codex } from './codex.js';
+import { write as cursor } from './cursor.js';
+import { write as windsurf } from './windsurf.js';
+
+const writers = { claude: claudeCode, codex, cursor, windsurf };
+
+export function writeHarnessConfigs(harnesses, scope, mainPort, docsPort, opts = {}) {
+  for (const harness of harnesses) {
+    const writer = writers[harness];
+    if (writer) writer(scope, mainPort, docsPort, opts);
+  }
+}

package/dist/install/harnesses/windsurf.js

@@ -0,0 +1,23 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export function write(_scope, mainPort, docsPort, { homeDir = os.homedir() } = {}) {
+  const filePath = path.join(homeDir, '.codeium', 'windsurf', 'mcp_config.json');
+
+  let data = {};
+  try {
+    data = JSON.parse(readFileSync(filePath, 'utf8'));
+  } catch {
+    // File absent or unreadable: start fresh.
+  }
+
+  if (!data.mcpServers) data.mcpServers = {};
+  data.mcpServers['ainj-main'] = { command: 'ainj', args: ['mcp', 'main', 'stdio'] };
+  data.mcpServers['ainj-docs'] = { command: 'ainj', args: ['mcp', 'docs', 'stdio'] };
+  data.mcpServers['ainj-main-http'] = { url: `http://localhost:${mainPort}/mcp` };
+  data.mcpServers['ainj-docs-http'] = { url: `http://localhost:${docsPort}/mcp` };
+
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+}

package/dist/install/index.js

@@ -0,0 +1,17 @@
+import { fileURLToPath } from 'node:url';
+import { runDefaults, runWizard } from './prompts.js';
+
+export async function main(
+  isTTY = process.stdout.isTTY,
+  { _runDefaults = runDefaults, _runWizard = runWizard } = {},
+) {
+  if (isTTY) {
+    await _runWizard();
+  } else {
+    await _runDefaults();
+  }
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  await main();
+}

package/dist/install/prompts.js

@@ -0,0 +1,109 @@
+import * as p from '@clack/prompts';
+import { writeHarnessConfigs as writeHarnessConfigsDefault } from './harnesses/index.js';
+import { installSkills as installSkillsDefault } from './skills-install.js';
+import { readState, writeState } from './state.js';
+import { which as whichDefault } from './which.js';
+
+export async function runDefaults({
+  _which = whichDefault,
+  _writeState = writeState,
+  ...stateOpts
+} = {}) {
+  const defaultHarness = _which('claude') ? 'claude' : _which('codex') ? 'codex' : null;
+  _writeState(
+    'global',
+    {
+      scope: 'global',
+      ports: { main: 3001, docs: 3002 },
+      harnesses: [],
+      defaultHarness,
+      nonInteractive: true,
+    },
+    stateOpts,
+  );
+}
+
+export async function runWizard({
+  _which = whichDefault,
+  _readState = readState,
+  _writeState = writeState,
+  _writeHarnessConfigs = writeHarnessConfigsDefault,
+  _installSkills = installSkillsDefault,
+  _p = p,
+  ...stateOpts
+} = {}) {
+  const localState = _readState('local', stateOpts);
+  const existing =
+    Object.keys(localState).length > 0 ? localState : _readState('global', stateOpts);
+
+  _p.intro('AInj setup');
+
+  const scope = await _p.select({
+    message: 'Install scope',
+    options: [
+      { value: 'global', label: 'global (recommended)' },
+      { value: 'local', label: 'local (this project only)' },
+    ],
+    initialValue: existing.scope ?? 'global',
+  });
+  if (_p.isCancel(scope)) {
+    _p.cancel('Setup cancelled.');
+    process.exit(0);
+    return;
+  }
+
+  const mainPort = await _p.text({
+    message: 'Main MCP port',
+    initialValue: String(existing.ports?.main ?? 3001),
+  });
+  if (_p.isCancel(mainPort)) {
+    _p.cancel('Setup cancelled.');
+    process.exit(0);
+    return;
+  }
+
+  const docsPort = await _p.text({
+    message: 'Docs MCP port',
+    initialValue: String(existing.ports?.docs ?? 3002),
+  });
+  if (_p.isCancel(docsPort)) {
+    _p.cancel('Setup cancelled.');
+    process.exit(0);
+    return;
+  }
+
+  const harnesses = await _p.multiselect({
+    message: 'Select harnesses to configure',
+    options: [
+      { value: 'claude', label: 'Claude Code' },
+      { value: 'codex', label: 'Codex' },
+      { value: 'cursor', label: 'Cursor' },
+      { value: 'windsurf', label: 'Windsurf' },
+    ],
+    required: false,
+    initialValues: existing.harnesses ?? [],
+  });
+  if (_p.isCancel(harnesses)) {
+    _p.cancel('Setup cancelled.');
+    process.exit(0);
+    return;
+  }
+
+  _writeHarnessConfigs(harnesses, scope, Number(mainPort), Number(docsPort));
+  await _installSkills();
+
+  const defaultHarness = _which('claude') ? 'claude' : _which('codex') ? 'codex' : null;
+
+  _writeState(
+    scope,
+    {
+      scope,
+      ports: { main: Number(mainPort), docs: Number(docsPort) },
+      harnesses,
+      defaultHarness,
+    },
+    stateOpts,
+  );
+
+  _p.outro('AInj configured.');
+}

package/dist/install/skills-install.js

@@ -0,0 +1,38 @@
+import { spawnSync as _spawnSyncDefault } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+
+import { syncSkills } from '../../scripts/sync-skills.js';
+
+const thisDir = import.meta.dirname;
+const SKILLS_PACKAGE = 'skills@1.5.13';
+
+export async function installSkills({
+  _spawnSync = _spawnSyncDefault,
+  _warn = console.warn,
+  _fs = fs,
+  _syncSkills = syncSkills,
+} = {}) {
+  const skillsDir = path.join(thisDir, '../../.agents/skills/');
+
+  // Check if skills directory already exists, otherwise sync from upstream.
+  let skillsDirExists = false;
+  try {
+    const skillsDirStat = await _fs.stat(skillsDir);
+    skillsDirExists = skillsDirStat.isDirectory();
+  } catch (ex) {
+    if (ex.code !== 'ENOENT') throw ex;
+  }
+  if (!skillsDirExists) {
+    await _syncSkills();
+  }
+
+  console.log('skills directory:', skillsDir);
+  const result = _spawnSync('npx', ['-y', SKILLS_PACKAGE, 'add', '--global', skillsDir], {
+    stdio: 'inherit',
+    cwd: skillsDir,
+  });
+  if (result.status !== 0) {
+    _warn(`skills install failed with status ${result.status}, skipping`);
+  }
+}

package/dist/install/state.js

@@ -0,0 +1,23 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export function stateFilePath(scope, { homeDir = os.homedir(), cwd = process.cwd() } = {}) {
+  const base = scope === 'global' ? homeDir : cwd;
+  return path.join(base, '.ainj', 'config.json');
+}
+
+export function readState(scope, opts = {}) {
+  try {
+    const content = readFileSync(stateFilePath(scope, opts), 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return {};
+  }
+}
+
+export function writeState(scope, data, opts = {}) {
+  const filePath = stateFilePath(scope, opts);
+  mkdirSync(path.dirname(filePath), { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2));
+}

package/dist/install/which.js

@@ -0,0 +1,7 @@
+import { spawnSync } from 'node:child_process';
+
+export function which(name) {
+  const result = spawnSync('which', [name]);
+  if (result.status === 0) return result.stdout.toString().trim();
+  return null;
+}

package/dist/lib/ainj.js

@@ -0,0 +1,6 @@
+export { cli } from './cli.js';
+
+import { docs } from './mcp/docs.js';
+import { main } from './mcp/main.js';
+export const mcp = { main, docs };
+export { skills } from './skills.js';

package/dist/lib/cli.js

@@ -0,0 +1,44 @@
+import { execFile as execFileCb, spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, resolve } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCb);
+const _require = createRequire(import.meta.url);
+
+export function resolveBinary() {
+  // Strategy 1: resolve via injective-core package bin field
+  try {
+    const pkgPath = _require.resolve('injective-core/package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    if (pkg.bin?.injectived) {
+      return resolve(dirname(pkgPath), pkg.bin.injectived);
+    }
+  } catch {
+    // fall through to strategy 2
+  }
+
+  // Strategy 2: which injectived
+  const result = spawnSync('which', ['injectived'], { encoding: 'utf8' });
+  if (result.status === 0) {
+    return result.stdout.trim();
+  }
+
+  throw new Error('injectived not found: injective-core not installed and injectived not on $PATH');
+}
+
+async function cli(...args) {
+  const bin = resolveBinary();
+  const { stdout, stderr } = await execFile(bin, args);
+  return { stdout, stderr };
+}
+
+Object.defineProperty(cli, 'path', {
+  get: resolveBinary,
+  enumerable: true,
+  configurable: false,
+});
+
+export { cli };
+export default cli;

package/dist/lib/exec.js

@@ -0,0 +1,4 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+export const execFileAsync = promisify(execFile);

package/dist/lib/mcp/client.js

@@ -0,0 +1,68 @@
+import { connectHttp, connectStdio } from './connect.js';
+import { resolveServer } from './spawn.js';
+
+const INITIAL = 'INITIAL';
+const MANAGED = 'MANAGED';
+const CONNECTED = 'CONNECTED';
+
+export class McpClient {
+  #state = INITIAL;
+  #client = null;
+  #bin;
+
+  constructor(bin) {
+    this.#bin = bin;
+  }
+
+  get state() {
+    return this.#state;
+  }
+
+  async start() {
+    if (this.#state !== INITIAL) throw new Error(`Cannot start(): current state is ${this.#state}`);
+    const { command, args } = resolveServer(this.#bin);
+    this.#client = await connectStdio(command, args);
+    this.#state = MANAGED;
+  }
+
+  async stop() {
+    if (this.#state !== MANAGED) throw new Error(`Cannot stop(): current state is ${this.#state}`);
+    await this.#client.close();
+    this.#client = null;
+    this.#state = INITIAL;
+  }
+
+  async connect(url) {
+    if (this.#state !== INITIAL)
+      throw new Error(`Cannot connect(): current state is ${this.#state}`);
+    this.#client = await connectHttp(url);
+    this.#state = CONNECTED;
+  }
+
+  async disconnect() {
+    if (this.#state !== CONNECTED)
+      throw new Error(`Cannot disconnect(): current state is ${this.#state}`);
+    await this.#client.close();
+    this.#client = null;
+    this.#state = INITIAL;
+  }
+
+  async toolCall(name, params = {}) {
+    if (this.#state === INITIAL) {
+      throw new Error('toolCall() requires MANAGED or CONNECTED state; current state is INITIAL');
+    }
+    if (params === null) {
+      throw new TypeError('toolCall params must be a plain JSON object; got null');
+    }
+    if (Array.isArray(params)) {
+      throw new TypeError('toolCall params must be a plain JSON object; got array');
+    }
+    if (typeof params !== 'object') {
+      throw new TypeError(`toolCall params must be a plain JSON object; got ${typeof params}`);
+    }
+    if (name === 'tools/list') {
+      return this.#client.listTools(params);
+    }
+    return this.#client.callTool({ name, arguments: params });
+  }
+}

package/dist/lib/mcp/connect.js

@@ -0,0 +1,17 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+export async function connectStdio(command, args) {
+  const transport = new StdioClientTransport({ command, args });
+  const client = new Client({ name: 'ainj', version: '0.1.0' });
+  await client.connect(transport);
+  return client;
+}
+
+export async function connectHttp(url) {
+  const transport = new StreamableHTTPClientTransport(new URL(url));
+  const client = new Client({ name: 'ainj', version: '0.1.0' });
+  await client.connect(transport);
+  return client;
+}

package/dist/lib/mcp/docs.js

@@ -0,0 +1,4 @@
+import { McpClient } from './client.js';
+
+export const docs = new McpClient('docs');
+export const defaultHttpUrl = `http://localhost:${process.env.AINJ_MCP_DOCS_PORT ?? 3002}/mcp`;

package/dist/lib/mcp/main.js

@@ -0,0 +1,4 @@
+import { McpClient } from './client.js';
+
+export const main = new McpClient('main');
+export const defaultHttpUrl = `http://localhost:${process.env.AINJ_MCP_MAIN_PORT ?? 3001}/mcp`;

package/dist/lib/mcp/spawn.js

@@ -0,0 +1,12 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+
+function resolveAinj() {
+  const local = fileURLToPath(new URL('../../../node_modules/.bin/ainj', import.meta.url));
+  if (existsSync(local)) return local;
+  return 'ainj';
+}
+
+export function resolveServer(bin) {
+  return { command: resolveAinj(), args: ['mcp', bin, 'stdio'] };
+}