ultrahope 0.0.1

package/README.md

@@ -0,0 +1,62 @@
+# ultrahope
+
+LLM-powered development workflow assistant CLI.
+
+## Installation
+
+```bash
+npm install -g ultrahope
+```
+
+## Usage
+
+### Login
+
+Authenticate with your ultrahope account using device flow:
+
+```bash
+ultrahope login
+```
+
+This will display a URL and code. Open the URL in your browser, sign in, and enter the code to authorize the CLI.
+
+### Translate
+
+Translate input to various formats. Pipe content to the command:
+
+```bash
+# Generate a commit message from git diff
+git diff --staged | ultrahope translate --target vcs-commit-message
+
+# Generate PR title and body from diff
+git diff main | ultrahope translate --target pr-title-body
+
+# Analyze PR intent
+git diff main | ultrahope translate --target pr-intent
+```
+
+#### Targets
+
+- `vcs-commit-message` - Generate a commit message
+- `pr-title-body` - Generate PR title and body
+- `pr-intent` - Analyze the intent of changes
+
+## Configuration
+
+### Environment Variables
+
+- `ULTRAHOPE_API_URL` - API endpoint (default: `https://ultrahope.dev`)
+
+### Credentials
+
+Credentials are stored in `~/.config/ultrahope/credentials.json`.
+
+## Development
+
+```bash
+# Build
+pnpm run build
+
+# Link for local testing
+pnpm link --global
+```

package/dist/index.js

@@ -0,0 +1,225 @@
+// src/lib/api-client.ts
+var API_BASE_URL = process.env.ULTRAHOPE_API_URL ?? "https://ultrahope.dev";
+var InsufficientBalanceError = class extends Error {
+  constructor(balance) {
+    super("Token balance exhausted");
+    this.balance = balance;
+    this.name = "InsufficientBalanceError";
+  }
+};
+function createApiClient(token) {
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  return {
+    async translate(req) {
+      const res = await fetch(`${API_BASE_URL}/api/v1/translate`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(req)
+      });
+      if (!res.ok) {
+        if (res.status === 402) {
+          const data = await res.json();
+          throw new InsufficientBalanceError(data.balance ?? 0);
+        }
+        const text = await res.text();
+        throw new Error(`API error: ${res.status} ${text}`);
+      }
+      return res.json();
+    },
+    async requestDeviceCode() {
+      const res = await fetch(`${API_BASE_URL}/api/auth/device/code`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({ client_id: "ultrahope-cli" })
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`API error: ${res.status} ${text}`);
+      }
+      return res.json();
+    },
+    async pollDeviceToken(deviceCode) {
+      const res = await fetch(`${API_BASE_URL}/api/auth/device/token`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+          device_code: deviceCode,
+          client_id: "ultrahope-cli"
+        })
+      });
+      if (!res.ok && res.status !== 400) {
+        const text = await res.text();
+        throw new Error(`API error: ${res.status} ${text}`);
+      }
+      return res.json();
+    }
+  };
+}
+
+// src/lib/auth.ts
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+function getCredentialsPath() {
+  const configDir = process.env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+  return path.join(configDir, "ultrahope", "credentials.json");
+}
+async function getToken() {
+  const credPath = getCredentialsPath();
+  try {
+    const content = await fs.promises.readFile(credPath, "utf-8");
+    const creds = JSON.parse(content);
+    return creds.access_token ?? null;
+  } catch {
+    return null;
+  }
+}
+async function saveToken(token) {
+  const credPath = getCredentialsPath();
+  const dir = path.dirname(credPath);
+  await fs.promises.mkdir(dir, { recursive: true });
+  await fs.promises.writeFile(
+    credPath,
+    JSON.stringify({ access_token: token }, null, 2),
+    { mode: 384 }
+  );
+}
+
+// src/commands/login.ts
+async function login(_args) {
+  const api = createApiClient();
+  console.log("Requesting device code...");
+  const deviceCode = await api.requestDeviceCode();
+  console.log();
+  console.log(`Open this URL in your browser: ${deviceCode.verification_uri}`);
+  console.log(`Enter code: ${deviceCode.user_code}`);
+  console.log();
+  console.log("Waiting for authorization...");
+  const token = await pollForToken(
+    api,
+    deviceCode.device_code,
+    deviceCode.interval,
+    deviceCode.expires_in
+  );
+  await saveToken(token);
+  console.log("Successfully authenticated!");
+}
+async function pollForToken(api, deviceCode, interval, expiresIn) {
+  const deadline = Date.now() + expiresIn * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(interval * 1e3);
+    const result = await api.pollDeviceToken(deviceCode);
+    if (result.access_token) {
+      return result.access_token;
+    }
+    if (result.error && result.error !== "authorization_pending") {
+      throw new Error(`Authentication failed: ${result.error}`);
+    }
+  }
+  throw new Error("Authentication timed out");
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/lib/stdin.ts
+async function stdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
+// src/commands/translate.ts
+var VALID_TARGETS = [
+  "vcs-commit-message",
+  "pr-title-body",
+  "pr-intent"
+];
+async function translate(args2) {
+  const target = parseTarget(args2);
+  const input = await stdin();
+  if (!input.trim()) {
+    console.error(
+      "Error: No input provided. Pipe content to ultrahope translate."
+    );
+    process.exit(1);
+  }
+  const token = await getToken();
+  if (!token) {
+    console.error("Error: Not authenticated. Run `ultrahope login` first.");
+    process.exit(1);
+  }
+  const api = createApiClient(token);
+  try {
+    const result = await api.translate({ input, target });
+    console.log(result.output);
+  } catch (error) {
+    if (error instanceof InsufficientBalanceError) {
+      console.error(
+        "Error: Token balance exhausted. Upgrade your plan at https://ultrahope.dev/pricing"
+      );
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+function parseTarget(args2) {
+  const idx = args2.findIndex((a) => a === "--target" || a === "-t");
+  if (idx === -1 || !args2[idx + 1]) {
+    console.error("Error: Missing --target option");
+    console.error(
+      "Usage: ultrahope translate --target <vcs-commit-message|pr-title-body|pr-intent>"
+    );
+    process.exit(1);
+  }
+  const value = args2[idx + 1];
+  if (!VALID_TARGETS.includes(value)) {
+    console.error(`Error: Invalid target "${value}"`);
+    console.error(`Valid targets: ${VALID_TARGETS.join(", ")}`);
+    process.exit(1);
+  }
+  return value;
+}
+
+// src/index.ts
+var [command, ...args] = process.argv.slice(2);
+async function main() {
+  switch (command) {
+    case "translate":
+      await translate(args);
+      break;
+    case "login":
+      await login(args);
+      break;
+    case "--help":
+    case "-h":
+    case void 0:
+      printHelp();
+      break;
+    default:
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+  }
+}
+function printHelp() {
+  console.log(`Usage: ultrahope <command>
+
+Commands:
+  translate  Translate input to various formats
+  login      Authenticate with device flow
+
+Options:
+  --help, -h  Show this help message`);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+	"name": "ultrahope",
+	"version": "0.0.1",
+	"description": "LLM-powered development workflow assistant",
+	"type": "module",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/toyamarinyon/ultrahope.git"
+	},
+	"keywords": [
+		"cli",
+		"llm",
+		"ai",
+		"git",
+		"commit-message",
+		"pull-request"
+	],
+	"bin": {
+		"ultrahope": "dist/index.js"
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"build": "tsup",
+		"typecheck": "tsc --noEmit",
+		"prepublishOnly": "pnpm run build"
+	},
+	"devDependencies": {
+		"@types/node": "^22.15.29",
+		"tsup": "8.5.0",
+		"typescript": "^5.8.3"
+	}
+}