orch-code 0.1.1

package/npm/orch.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const packageRoot = path.resolve(__dirname, '..');
+const binaryName = process.platform === 'win32' ? 'orch.exe' : 'orch';
+const installedBinary = path.join(packageRoot, '.npm-bin', binaryName);
+
+if (!fs.existsSync(installedBinary)) {
+  console.error('orch binary is not installed. Re-run `npm install -g orch` or install from a published release.');
+  process.exit(1);
+}
+
+const result = spawnSync(installedBinary, process.argv.slice(2), {
+  stdio: 'inherit',
+});
+
+if (result.error) {
+  console.error(`failed to launch orch: ${result.error.message}`);
+  process.exit(1);
+}
+
+process.exit(result.status ?? 1);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "orch-code",
+  "version": "0.1.1",
+  "description": "Local-first control plane for deterministic AI coding",
+  "license": "MIT",
+  "bin": {
+    "orch": "npm/orch.js"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall.js",
+    "pack:dry": "npm pack --dry-run",
+    "changelog": "node scripts/changelog.js",
+    "release:prepare": "node scripts/release.js",
+    "release:patch": "node scripts/release.js patch",
+    "release:minor": "node scripts/release.js minor",
+    "release:major": "node scripts/release.js major"
+  },
+  "files": [
+    "cmd",
+    "internal",
+    "npm",
+    "scripts",
+    "CHANGELOG.md",
+    "main.go",
+    "go.mod",
+    "go.sum",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/furkanbeydemir/orch.git"
+  },
+  "bugs": {
+    "url": "https://github.com/furkanbeydemir/orch/issues"
+  },
+  "homepage": "https://github.com/furkanbeydemir/orch#readme",
+  "engines": {
+    "node": ">=18"
+  }
+}

package/scripts/changelog.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+const { bumpVersion, fail, getPackageVersion, isValidSemver, paths, updateChangelog } = require('./lib/release-utils');
+
+const requestedVersion = (process.argv[2] || '').trim();
+if (!requestedVersion) {
+  fail('missing version argument. Example: npm run changelog -- 0.1.1 or npm run changelog -- patch');
+}
+
+const currentVersion = getPackageVersion();
+const nextVersion = ['patch', 'minor', 'major'].includes(requestedVersion)
+  ? bumpVersion(currentVersion, requestedVersion)
+  : requestedVersion;
+
+if (!isValidSemver(nextVersion)) {
+  fail(`invalid version: ${nextVersion}`);
+}
+
+updateChangelog(nextVersion);
+console.log(`[orch] updated ${paths.changelog} for v${nextVersion}`);

package/scripts/check-release-version.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+
+const { fail, getCmdVersion, getPackageVersion } = require('./lib/release-utils');
+
+const tag = (process.argv[2] || '').trim();
+if (!tag) {
+  fail('missing tag argument, expected something like v0.1.0');
+}
+
+const normalizedTag = tag.startsWith('v') ? tag.slice(1) : tag;
+const packageVersion = getPackageVersion();
+if (normalizedTag !== packageVersion) {
+  fail(`git tag ${tag} does not match package.json version ${packageVersion}`);
+}
+
+const cmdVersion = getCmdVersion();
+if (cmdVersion !== packageVersion) {
+  fail(`cmd/version.go version ${cmdVersion} does not match package.json version ${packageVersion}`);
+}
+
+console.log(`[orch] release version ${packageVersion} matches tag ${tag}`);

package/scripts/lib/release-utils.js

@@ -0,0 +1,223 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const packageRoot = path.resolve(__dirname, '..', '..');
+const paths = {
+  packageJson: path.join(packageRoot, 'package.json'),
+  packageLock: path.join(packageRoot, 'package-lock.json'),
+  cmdVersion: path.join(packageRoot, 'cmd', 'version.go'),
+  changelog: path.join(packageRoot, 'CHANGELOG.md'),
+};
+
+function fail(message) {
+  console.error(`[orch] ${message}`);
+  process.exit(1);
+}
+
+function isValidSemver(value) {
+  return /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(value);
+}
+
+function parseSemver(value) {
+  if (!isValidSemver(value)) {
+    fail(`invalid version: ${value}`);
+  }
+  const match = value.match(/^(\d+)\.(\d+)\.(\d+)(.*)$/);
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3]),
+    suffix: match[4] || '',
+  };
+}
+
+function bumpVersion(currentVersion, releaseType) {
+  const parsed = parseSemver(currentVersion);
+  if (releaseType === 'patch') {
+    return `${parsed.major}.${parsed.minor}.${parsed.patch + 1}`;
+  }
+  if (releaseType === 'minor') {
+    return `${parsed.major}.${parsed.minor + 1}.0`;
+  }
+  if (releaseType === 'major') {
+    return `${parsed.major + 1}.0.0`;
+  }
+  return releaseType;
+}
+
+function readJSON(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJSON(filePath, data) {
+  fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function getPackageVersion() {
+  return readJSON(paths.packageJson).version;
+}
+
+function getCmdVersion() {
+  const source = fs.readFileSync(paths.cmdVersion, 'utf8');
+  const versionMatch = source.match(/version\s*=\s*"([^"]+)"/);
+  if (!versionMatch) {
+    fail('could not parse cmd/version.go');
+  }
+  return versionMatch[1];
+}
+
+function updateVersions(nextVersion) {
+  const pkg = readJSON(paths.packageJson);
+  const lock = readJSON(paths.packageLock);
+  const currentVersion = pkg.version;
+
+  pkg.version = nextVersion;
+  lock.version = nextVersion;
+  if (lock.packages && lock.packages['']) {
+    lock.packages[''].version = nextVersion;
+  }
+
+  writeJSON(paths.packageJson, pkg);
+  writeJSON(paths.packageLock, lock);
+  updateCmdVersion(nextVersion);
+  return currentVersion;
+}
+
+function updateCmdVersion(nextVersion) {
+  const source = fs.readFileSync(paths.cmdVersion, 'utf8');
+  if (source.includes(`var version = "${nextVersion}"`)) {
+    return;
+  }
+  const updated = source.replace(/var version = "[^"]+"/, `var version = "${nextVersion}"`);
+  if (updated === source) {
+    fail('could not update cmd/version.go');
+  }
+  fs.writeFileSync(paths.cmdVersion, updated);
+}
+
+function runGit(args, options = {}) {
+  const result = spawnSync('git', args, {
+    cwd: packageRoot,
+    encoding: 'utf8',
+    ...options,
+  });
+
+  if (!options.allowFailure && (result.error || result.status !== 0)) {
+    const stderr = (result.stderr || '').trim();
+    fail(stderr || `git ${args.join(' ')} failed`);
+  }
+
+  return result;
+}
+
+function getLastTag() {
+  const result = runGit(['describe', '--tags', '--abbrev=0'], { allowFailure: true });
+  if (result.error || result.status !== 0) {
+    return '';
+  }
+  return (result.stdout || '').trim();
+}
+
+function getCommitSubjects(range) {
+  const args = ['log', '--pretty=format:%s'];
+  if (range) {
+    args.push(range);
+  }
+  const result = runGit(args);
+  return (result.stdout || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function getWorkingTreeChanges() {
+  const result = runGit(['status', '--short']);
+  return (result.stdout || '')
+    .split('\n')
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function createTag(version, allowedFiles = []) {
+  const tagName = `v${version}`;
+  const changes = getWorkingTreeChanges().filter((line) => {
+    return !allowedFiles.some((allowedFile) => line.endsWith(allowedFile));
+  });
+
+  if (changes.length > 0) {
+    fail('refusing to create tag with unrelated working tree changes present');
+  }
+
+  const tagResult = runGit(['tag', tagName], { stdio: 'inherit', allowFailure: true });
+  if (tagResult.error) {
+    fail(`failed to create tag ${tagName}: ${tagResult.error.message}`);
+  }
+  if (tagResult.status !== 0) {
+    fail(`git tag exited with status ${tagResult.status}`);
+  }
+  return tagName;
+}
+
+function buildReleaseNotes(version) {
+  const lastTag = getLastTag();
+  const range = lastTag ? `${lastTag}..HEAD` : '';
+  const commits = getCommitSubjects(range);
+
+  const lines = [];
+  lines.push(`## v${version} - ${new Date().toISOString().slice(0, 10)}`);
+  lines.push('');
+  if (commits.length === 0) {
+    lines.push('- No user-facing changes recorded.');
+  } else {
+    for (const subject of commits) {
+      lines.push(`- ${subject}`);
+    }
+  }
+  lines.push('');
+  return lines.join('\n');
+}
+
+function updateChangelog(version) {
+  const releaseNotes = buildReleaseNotes(version);
+  const header = '# Changelog\n\nAll notable changes to this project will be documented in this file.\n\n';
+  let existing = fs.existsSync(paths.changelog) ? fs.readFileSync(paths.changelog, 'utf8') : header;
+
+  if (!existing.startsWith('# Changelog')) {
+    existing = `${header}${existing.trim()}\n`;
+  }
+
+  const sectionHeader = `## v${version} - `;
+  if (existing.includes(sectionHeader)) {
+    const sectionRegex = new RegExp(`## v${escapeRegExp(version)} - [\\s\\S]*?(?=\\n## v|$)`, 'm');
+    existing = existing.replace(sectionRegex, releaseNotes.trim());
+  } else {
+    existing = `${header}${releaseNotes}${existing.replace(header, '')}`;
+  }
+
+  fs.writeFileSync(paths.changelog, normalizeTrailingNewline(existing));
+}
+
+function normalizeTrailingNewline(content) {
+  return `${content.trim()}\n`;
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+module.exports = {
+  buildReleaseNotes,
+  bumpVersion,
+  createTag,
+  fail,
+  getCmdVersion,
+  getLastTag,
+  getPackageVersion,
+  isValidSemver,
+  packageRoot,
+  paths,
+  runGit,
+  updateChangelog,
+  updateVersions,
+};

package/scripts/postinstall.js

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+
+const fs = require('node:fs');
+const path = require('node:path');
+const https = require('node:https');
+const http = require('node:http');
+const { spawnSync } = require('node:child_process');
+
+const packageRoot = path.resolve(__dirname, '..');
+const pkg = require(path.join(packageRoot, 'package.json'));
+const binaryDir = path.join(packageRoot, '.npm-bin');
+const binaryName = process.platform === 'win32' ? 'orch.exe' : 'orch';
+const binaryPath = path.join(binaryDir, binaryName);
+
+const targets = {
+  darwin: { x64: 'darwin-x64', arm64: 'darwin-arm64' },
+  linux: { x64: 'linux-x64', arm64: 'linux-arm64' },
+  win32: { x64: 'windows-x64.exe', arm64: 'windows-arm64.exe' },
+};
+
+function main() {
+  if (process.env.ORCH_SKIP_DOWNLOAD === '1') {
+    console.log('[orch] skipping binary install because ORCH_SKIP_DOWNLOAD=1');
+    return;
+  }
+
+  ensureDir(binaryDir);
+
+  if (fs.existsSync(binaryPath)) {
+    makeExecutable(binaryPath);
+    console.log(`[orch] using existing binary at ${binaryPath}`);
+    return;
+  }
+
+  install()
+    .then(() => {
+      makeExecutable(binaryPath);
+      console.log(`[orch] binary ready at ${binaryPath}`);
+    })
+    .catch((error) => {
+      console.error(`[orch] install failed: ${error.message}`);
+      process.exit(1);
+    });
+}
+
+async function install() {
+  const assetName = resolveAssetName();
+  const baseUrl = process.env.ORCH_BINARY_BASE_URL || `https://github.com/furkanbeydemir/orch/releases/download/v${pkg.version}`;
+  const assetUrl = `${baseUrl}/${assetName}`;
+
+  try {
+    console.log(`[orch] downloading ${assetUrl}`);
+    await downloadFile(assetUrl, binaryPath);
+    return;
+  } catch (downloadError) {
+    console.warn(`[orch] release download unavailable: ${downloadError.message}`);
+  }
+
+  buildFromSource();
+}
+
+function resolveAssetName() {
+  const platformTargets = targets[process.platform];
+  if (!platformTargets) {
+    throw new Error(`unsupported platform: ${process.platform}`);
+  }
+
+  const assetSuffix = platformTargets[process.arch];
+  if (!assetSuffix) {
+    throw new Error(`unsupported architecture: ${process.arch}`);
+  }
+
+  return `orch-${assetSuffix}`;
+}
+
+function downloadFile(url, destination, redirectCount = 0) {
+  if (redirectCount > 5) {
+    return Promise.reject(new Error('too many redirects'));
+  }
+
+  const client = url.startsWith('https://') ? https : http;
+
+  return new Promise((resolve, reject) => {
+    const request = client.get(url, (response) => {
+      if (response.statusCode && response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        response.resume();
+        resolve(downloadFile(response.headers.location, destination, redirectCount + 1));
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`unexpected status code ${response.statusCode || 'unknown'}`));
+        return;
+      }
+
+      const file = fs.createWriteStream(destination, { mode: 0o755 });
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close((closeError) => {
+          if (closeError) {
+            reject(closeError);
+            return;
+          }
+          resolve();
+        });
+      });
+
+      file.on('error', (fileError) => {
+        fs.rmSync(destination, { force: true });
+        reject(fileError);
+      });
+    });
+
+    request.on('error', (error) => {
+      fs.rmSync(destination, { force: true });
+      reject(error);
+    });
+  });
+}
+
+function buildFromSource() {
+  const versionResult = spawnSync('go', ['version'], {
+    cwd: packageRoot,
+    encoding: 'utf8',
+  });
+
+  if (versionResult.error || versionResult.status !== 0) {
+    throw new Error('no published binary found and `go` is not available for source build fallback');
+  }
+
+  console.log('[orch] building from source with local Go toolchain');
+  const buildResult = spawnSync('go', ['build', '-o', binaryPath, '.'], {
+    cwd: packageRoot,
+    stdio: 'inherit',
+  });
+
+  if (buildResult.error) {
+    throw buildResult.error;
+  }
+  if (buildResult.status !== 0) {
+    throw new Error(`go build failed with exit code ${buildResult.status}`);
+  }
+}
+
+function ensureDir(directory) {
+  fs.mkdirSync(directory, { recursive: true });
+}
+
+function makeExecutable(filePath) {
+  if (process.platform !== 'win32' && fs.existsSync(filePath)) {
+    fs.chmodSync(filePath, 0o755);
+  }
+}
+
+main();

package/scripts/release.js

@@ -0,0 +1,52 @@
+#!/usr/bin/env node
+
+const {
+  bumpVersion,
+  createTag,
+  fail,
+  getPackageVersion,
+  isValidSemver,
+  paths,
+  updateChangelog,
+  updateVersions,
+} = require('./lib/release-utils');
+
+const args = process.argv.slice(2);
+const requestedVersion = (args[0] || '').trim();
+const shouldTag = args.includes('--tag');
+const shouldUpdateChangelog = !args.includes('--no-changelog');
+
+if (!requestedVersion) {
+  fail('missing version argument. Example: npm run release:prepare -- 0.1.1 or npm run release:prepare -- patch');
+}
+
+const currentVersion = getPackageVersion();
+const nextVersion = ['patch', 'minor', 'major'].includes(requestedVersion)
+  ? bumpVersion(currentVersion, requestedVersion)
+  : requestedVersion;
+
+if (!isValidSemver(nextVersion)) {
+  fail(`invalid version: ${nextVersion}`);
+}
+
+updateVersions(nextVersion);
+if (shouldUpdateChangelog) {
+  updateChangelog(nextVersion);
+}
+
+console.log(`[orch] updated version ${currentVersion} -> ${nextVersion}`);
+if (shouldUpdateChangelog) {
+  console.log(`[orch] updated ${paths.changelog}`);
+}
+
+if (shouldTag) {
+  const tagName = createTag(nextVersion, [
+    'package.json',
+    'package-lock.json',
+    'cmd/version.go',
+    'CHANGELOG.md',
+  ]);
+  console.log(`[orch] created git tag ${tagName}`);
+}
+
+console.log('[orch] next steps: review changes, commit, and push the tag when ready');