jorin 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dave Hulbert
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# `jorin`
+
+![Logo](docs/jorin-logo-and-name.png)
+
+[**Jorin**](https://jorin.ai) is a small coding agent written in Go.
+
+It calls tools, like `shell`, `read_file`, `write_file`, `apply_patch`,
+`http_get` and communicates with an OpenAI-compatible API.
+It is designed for use as a composable command-line tool for shell scripts
+and also for interactive coding sessions.
+
+Jorin isn't designed to be your day-to-day coding agent for big projects.
+Instead, Jorin is designed to be ran in constrained environments like
+containers and on mobile devices.
+Jorin also serves as a research prototype for agent techniques such as
+[Skills to Agents](https://dave.engineer/blog/2025/11/skills-to-agents/)
+and [Agent Situations](https://github.com/dave1010/agent-situations).
+
+![jorin screenshot](docs/jorin-screenshot.png)
+
+## Documentation
+
+- [Usage guide](docs/usage.md)
+- [OpenAI APIs (Completions vs Responses)](docs/openai-apis.md)
+- [Development and architecture](docs/development.md)
+- [Security notes](docs/security.md)
+- [Contributing](CONTRIBUTING.md)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+- [Changelog](CHANGELOG.md)
+
+## Install
+
+One line install:
+
+```bash
+curl -fsSL https://get.jorin.ai | bash
+```
+
+Quick run with npx (no install needed):
+
+```bash
+npx jorin --help
+```
+
+The npm package bundles prebuilt binaries for supported platforms and will
+use them when available, falling back to downloading the matching GitHub
+release asset if needed.
+
+The installer will place `jorin` in `/usr/local/bin` when it can, otherwise it
+uses `~/.local/bin` and updates your shell profile to add it to `$PATH`.
+Set `JORIN_INSTALL_DIR` to override the install location.
+
+### Manual install
+
+Download the latest release for your platform from
+[GitHub Releases](https://github.com/dave1010/jorin/releases).
+
+Then add it to your $PATH.
+
+## Configuration
+
+Set your API key before running jorin:
+
+```bash
+export OPENAI_API_KEY="your-api-key"
+```
+
+To use a different OpenAI-compatible endpoint:
+
+```bash
+export OPENAI_BASE_URL="https://api.openai.com"
+```
+
+## Quick start
+
+Show help:
+
+```bash
+jorin --help
+```
+
+Start the REPL (default when invoked with no args):
+
+```bash
+jorin
+```
+
+Send a single prompt:
+
+```bash
+jorin "Refactor function X to be smaller"
+```
+
+Pipe stdin into a prompt:
+
+```bash
+cat document.md | jorin "Summarize the text"
+```
+
+Run a Jorin prompt file (shebang optional):
+
+```bash
+./review-code.jorin --target src/
+```
+
+To force a literal prompt instead of loading a file, use `--prompt`:
+
+```bash
+jorin --prompt "./review-code.jorin --target src/"
+```
+
+Enable Ralph Wiggum loop mode (iterative, self-referential AI loops that
+auto-repeat until DONE or max tries):
+
+```bash
+jorin --ralph --ralph-max-tries 6 "Build a hello world API"
+```
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) and follow the
+[Code of Conduct](CODE_OF_CONDUCT.md).
+
+## License
+
+MIT
+
+## Colophon
+
+"Jorin" is pronounced **jorin**, not *JOR-in* or *jor-IN*. Say it quickly, but not so quickly that it feels rushed: **Jorin**. That's it! The name comes from looking at my keyboard and trying to find something without too many Google results.

package/bin/jorin.js

@@ -0,0 +1,150 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const https = require("https");
+const { spawn } = require("child_process");
+
+const PACKAGE_JSON = path.join(__dirname, "..", "package.json");
+const pkg = JSON.parse(fs.readFileSync(PACKAGE_JSON, "utf8"));
+
+function resolveTarget() {
+  let platform = process.platform;
+  if (platform === "android") {
+    platform = "android";
+  }
+
+  switch (platform) {
+    case "linux":
+    case "darwin":
+    case "freebsd":
+    case "windows":
+    case "android":
+      break;
+    case "win32":
+      platform = "windows";
+      break;
+    default:
+      throw new Error(`Unsupported platform: ${process.platform}`);
+  }
+
+  let arch;
+  switch (process.arch) {
+    case "x64":
+      arch = "amd64";
+      break;
+    case "arm64":
+      arch = "arm64";
+      break;
+    case "arm":
+      arch = "arm";
+      break;
+    case "ia32":
+      arch = "386";
+      break;
+    default:
+      throw new Error(`Unsupported architecture: ${process.arch}`);
+  }
+
+  if (platform === "windows" && arch === "arm64") {
+    throw new Error("Windows ARM64 builds are not available yet.");
+  }
+
+  const ext = platform === "windows" ? ".exe" : "";
+  return { platform, arch, ext };
+}
+
+function resolveVersion() {
+  const override = process.env.JORIN_NPX_VERSION;
+  if (override) {
+    return { tag: override.startsWith("v") ? override : `v${override}`, mode: "tag" };
+  }
+
+  if (pkg.version && pkg.version !== "0.0.0") {
+    return { tag: `v${pkg.version}`, mode: "tag" };
+  }
+
+  return { tag: "latest", mode: "latest" };
+}
+
+function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+}
+
+function downloadFile(url, destination) {
+  return new Promise((resolve, reject) => {
+    const request = https.get(url, (response) => {
+      if (response.statusCode >= 300 && response.statusCode < 400 && response.headers.location) {
+        response.resume();
+        return resolve(downloadFile(response.headers.location, destination));
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        return reject(new Error(`Download failed with status ${response.statusCode}`));
+      }
+
+      const file = fs.createWriteStream(destination, { mode: 0o755 });
+      response.pipe(file);
+      file.on("finish", () => file.close(resolve));
+      file.on("error", reject);
+    });
+
+    request.on("error", reject);
+  });
+}
+
+async function main() {
+  const { platform, arch, ext } = resolveTarget();
+  const { tag, mode } = resolveVersion();
+
+  const baseDir = process.env.JORIN_NPX_DIR || path.join(os.homedir(), ".jorin", "bin");
+  ensureDir(baseDir);
+
+  const assetName = `jorin-${platform}-${arch}${ext}`;
+  const cacheName = `jorin-${platform}-${arch}-${tag}${ext}`.replace(/[/:]/g, "-");
+  const targetPath = path.join(baseDir, cacheName);
+  const bundledPath = path.join(__dirname, "..", "dist", assetName);
+
+  const shouldRedownload = process.env.JORIN_NPX_FORCE === "1" || !fs.existsSync(targetPath);
+  if (shouldRedownload) {
+    if (fs.existsSync(bundledPath)) {
+      fs.copyFileSync(bundledPath, targetPath);
+    } else {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "jorin-npx-"));
+      const tmpPath = path.join(tmpDir, assetName);
+
+      const url =
+        mode === "latest"
+          ? `https://github.com/dave1010/jorin/releases/latest/download/${assetName}`
+          : `https://github.com/dave1010/jorin/releases/download/${tag}/${assetName}`;
+
+      process.stderr.write(`Downloading ${assetName} (${mode === "latest" ? "latest" : tag})...\n`);
+      await downloadFile(url, tmpPath);
+
+      if (platform !== "windows") {
+        fs.chmodSync(tmpPath, 0o755);
+      }
+
+      fs.renameSync(tmpPath, targetPath);
+    }
+  }
+
+  if (platform !== "windows") {
+    fs.chmodSync(targetPath, 0o755);
+  }
+
+  const child = spawn(targetPath, process.argv.slice(2), { stdio: "inherit" });
+  child.on("exit", (code) => process.exit(code ?? 0));
+  child.on("error", (err) => {
+    process.stderr.write(`Failed to launch jorin: ${err.message}\n`);
+    process.exit(1);
+  });
+}
+
+main().catch((err) => {
+  process.stderr.write(`${err.message}\n`);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "jorin",
+  "version": "0.0.0",
+  "description": "Jorin is a small coding agent written in Go.",
+  "license": "MIT",
+  "repository": "github:dave1010/jorin",
+  "homepage": "https://github.com/dave1010/jorin",
+  "bugs": {
+    "url": "https://github.com/dave1010/jorin/issues"
+  },
+  "bin": {
+    "jorin": "bin/jorin.js"
+  },
+  "files": [
+    "bin/",
+    "dist/"
+  ],
+  "engines": {
+    "node": ">=18"
+  }
+}