@polylogicai/polycode 1.1.3 → 1.1.4

package/README.md

@@ -1,25 +1,35 @@
 # polycode
 
-An agentic coding CLI. Runs on your machine with your keys. Every turn is appended to a SHA-256 chained session log on disk, so your history is auditable, replayable, and portable across machines.
+An agentic coding CLI. Runs on your machine, writes a SHA-256 chained session log to disk, and ships with a free hosted tier so you can start in one command. Your history is auditable, replayable, and portable across machines.
 
-## Install
+## Install and run
 
-The fastest way to try polycode is with `npx`. It works on macOS, Linux, and Windows from any terminal:
+One command, no setup, any platform:
 
 ```bash
 npx @polylogicai/polycode@latest
 ```
 
-For repeated use, install it globally:
+That is the entire install. The first run provisions a per-install ID under `~/.polycode/` and opens an interactive session. On the free hosted tier you get 60 turns per hour for free, routed through `polylogicai.com/api/polycode/inference`. For unlimited use, set `GROQ_API_KEY` (see below) and polycode will talk to Groq directly and skip the proxy.
+
+For repeated use, install globally:
 
 ```bash
 npm install -g @polylogicai/polycode
 polycode
 ```
 
-## Quick start
+## One-shot mode
+
+Pass your prompt as an argument:
+
+```bash
+npx @polylogicai/polycode@latest "read README.md and summarize it in one sentence"
+```
+
+## Unlimited use with your own key
 
-Set your Groq API key, then run polycode:
+Grab a free key from `console.groq.com`, then:
 
 ```bash
 # macOS and Linux
@@ -31,22 +41,14 @@ $env:GROQ_API_KEY = "gsk_..."
 npx @polylogicai/polycode@latest
 ```
 
-That opens an interactive session. For one-shot mode, pass your prompt as an argument:
-
-```bash
-npx @polylogicai/polycode@latest "read README.md and summarize it in one sentence"
-```
-
-A free Groq API key is available at `console.groq.com`.
-
 ## Configuration
 
 polycode reads configuration from environment variables and optionally from a `~/.polycode/secrets.env` file (chmod 600 recommended).
 
 | Variable | Purpose | Required |
 |---|---|---|
-| `GROQ_API_KEY` | Primary inference key for tool-use and reasoning | yes |
-| `ANTHROPIC_API_KEY` | Optional high-quality tier for long sessions | no |
+| `GROQ_API_KEY` | Direct Groq access, unlimited. If unset, polycode uses the hosted tier. | no |
+| `ANTHROPIC_API_KEY` | Optional higher-quality compile tier for long sessions | no |
 | `POLYCODE_MODEL` | Override the default model | no |
 | `POLYCODE_CWD` | Override the working directory | no |
 
@@ -109,7 +111,7 @@ Rules live in `~/.polycode/rules.yaml`. You can add your own.
 
 - Node.js 20 or newer
 - macOS, Linux, or Windows
-- A Groq API key
+- No API key required for the free hosted tier. Set `GROQ_API_KEY` for unlimited use.
 
 ## Documentation and support
 

package/bin/polycode.mjs

@@ -161,8 +161,8 @@ ${C.bold}Usage${C.reset}
   polycode --verify                 Verify session history integrity
 
 ${C.bold}Environment${C.reset}
-  GROQ_API_KEY                Required (free tier at console.groq.com)
-  ANTHROPIC_API_KEY           Optional high-quality tier for long sessions
+  GROQ_API_KEY                Optional. If unset, polycode uses the free hosted tier (60 turns/hour) via polylogicai.com. Set a free key from console.groq.com for unlimited use.
+  ANTHROPIC_API_KEY           Optional higher-quality compile tier for long sessions
   POLYCODE_MODEL              Override the default model
   POLYCODE_CWD                Override the working directory
 
@@ -259,6 +259,9 @@ async function runOneShot(message, opts) {
 async function runRepl(opts) {
   const rl = readline.createInterface({ input: stdin, output: stdout });
   stdout.write(BANNER + '\n');
+  if (opts.hostedMode) {
+    stdout.write(`${C.dim}hosted tier: 60 turns/hour via polylogicai.com. Set GROQ_API_KEY for unlimited use.${C.reset}\n`);
+  }
   if (opts.projectContextPath) {
     stdout.write(`${C.dim}project context: ${opts.projectContextPath}${C.reset}\n`);
   }
@@ -298,11 +301,12 @@ async function main() {
 
   const configDir = resolveConfigDir();
 
-  const apiKey = env.GROQ_API_KEY;
-  if (!apiKey) {
-    stdout.write(`${C.red}polycode error${C.reset}: GROQ_API_KEY is not set.\n`);
-    exit(1);
-  }
+  // Zero-config mode: if no GROQ_API_KEY is present, run through the Polylogic
+  // hosted inference proxy at polylogicai.com/api/polycode/inference. Users
+  // who want unlimited access or their own billing can set GROQ_API_KEY to a
+  // free key from console.groq.com and the CLI will talk to Groq directly.
+  const apiKey = env.GROQ_API_KEY || '';
+  const hostedMode = !apiKey;
 
   const rules = loadRules();
   const model = env.POLYCODE_MODEL || 'moonshotai/kimi-k2-instruct';
@@ -356,10 +360,10 @@ async function main() {
     canon_path: canonFile,
   }, hookDir);
 
-  const loop = new AgenticLoop({ apiKey, model, rules, projectContext });
+  const loop = new AgenticLoop({ apiKey, model, rules, projectContext, hostedMode, version: VERSION });
   const renderer = createRenderer(stdout, { verbose });
   const state = { lastTurnTokens: 0, lastCompiler: null };
-  const opts = { loop, canon, cwd, renderer, state, sessionId, hookDir, verbose, projectContextPath };
+  const opts = { loop, canon, cwd, renderer, state, sessionId, hookDir, verbose, projectContextPath, hostedMode };
 
   const positional = args.filter((a) => !a.startsWith('--') && args[args.indexOf(a) - 1] !== '--packet');
   if (positional.length > 0) {

package/lib/agentic.mjs

@@ -18,6 +18,7 @@ import { compilePacket } from './compiler.mjs';
 import { mintCommitment } from './commitment.mjs';
 import { ensureActiveIntent } from './intent.mjs';
 import { scrubSecrets } from './witness/secret-scrubber.mjs';
+import { createHostedClient } from './polycode-hosted-client.mjs';
 
 // Cross-platform directory walker. Pure Node.js, no shell-out. Skips common
 // noise directories (node_modules, .git, etc.) by default. Yields absolute
@@ -363,17 +364,21 @@ function recoverInlineToolCalls(content) {
 }
 
 export class AgenticLoop {
-  constructor({ apiKey, model, logger, rules, projectContext } = {}) {
+  constructor({ apiKey, model, logger, rules, projectContext, hostedMode, version } = {}) {
     this.apiKey = apiKey;
     this.defaultModel = model || DEFAULT_MODEL;
     this.logger = logger || console;
     this.rules = rules || {};
     this.systemPrompt = buildSystemPrompt(projectContext);
+    this.hostedMode = Boolean(hostedMode) || !(apiKey || process.env.GROQ_API_KEY);
+    this.version = version || 'unknown';
   }
 
   async runTurn({ canon, userMessage, cwd, onEvent, maxIterations }) {
     const start = Date.now();
-    const groq = new Groq({ apiKey: this.apiKey || process.env.GROQ_API_KEY });
+    const groq = this.hostedMode
+      ? createHostedClient({ version: this.version })
+      : new Groq({ apiKey: this.apiKey || process.env.GROQ_API_KEY });
     let model = this.defaultModel;
     let didFallback = false;
     const limit = maxIterations || DEFAULT_MAX_ITERATIONS;

package/lib/polycode-hosted-client.mjs

@@ -0,0 +1,100 @@
+// lib/polycode-hosted-client.mjs
+// Hosted inference client for users who have not provided a GROQ_API_KEY.
+// Posts chat-completions requests to the Polylogic proxy at
+// polylogicai.com/api/polycode/inference, which forwards them to Groq using
+// a server-side key. Rate limited to 60 turns per install per hour. Power
+// users can skip the proxy by setting GROQ_API_KEY, in which case the agent
+// talks to Groq directly.
+//
+// The returned object mimics the subset of the groq-sdk surface that the
+// agentic loop uses (chat.completions.create), so the call sites do not need
+// to know which backend is in play.
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+const DEFAULT_PROXY_URL = 'https://polylogicai.com/api/polycode/inference';
+const CONFIG_DIR = join(homedir(), '.polycode');
+const INSTALL_ID_PATH = join(CONFIG_DIR, 'install_id');
+
+// Produce a stable per-install identifier. Created on first run, persisted
+// to ~/.polycode/install_id so subsequent runs reuse the same ID for rate
+// limiting. The file contains a bare UUID with no PII.
+export function getOrCreateInstallId() {
+  try {
+    if (existsSync(INSTALL_ID_PATH)) {
+      const existing = readFileSync(INSTALL_ID_PATH, 'utf8').trim();
+      if (/^[A-Za-z0-9_-]{8,64}$/.test(existing)) return existing;
+    }
+  } catch {
+    // fall through and regenerate
+  }
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  const fresh = randomUUID();
+  try {
+    writeFileSync(INSTALL_ID_PATH, fresh + '\n', { mode: 0o600 });
+  } catch {
+    // non-fatal; rate limiting will fall back to per-IP
+  }
+  return fresh;
+}
+
+// Minimal Groq-SDK-shaped client that posts every request to the Polylogic
+// proxy. The shape matches what lib/agentic.mjs calls: an object with a
+// `chat.completions.create(payload)` method returning an OpenAI-compatible
+// chat completion object.
+export function createHostedClient({ version, proxyUrl } = {}) {
+  const url = proxyUrl || process.env.POLYCODE_PROXY_URL || DEFAULT_PROXY_URL;
+  const installId = getOrCreateInstallId();
+  const headers = {
+    'Content-Type': 'application/json',
+    'X-Polycode-Install-ID': installId,
+    'X-Polycode-Version': version || 'unknown',
+  };
+
+  async function createCompletion(payload) {
+    let res;
+    try {
+      res = await fetch(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(payload),
+      });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      const wrapped = new Error(
+        `polycode hosted inference unreachable at ${url}: ${msg}. Set GROQ_API_KEY to a free key from console.groq.com to bypass the proxy.`
+      );
+      wrapped.cause = err;
+      throw wrapped;
+    }
+
+    const text = await res.text();
+    if (!res.ok) {
+      let parsed;
+      try { parsed = JSON.parse(text); } catch { parsed = null; }
+      const serverMsg = parsed?.error || text || `HTTP ${res.status}`;
+      throw new Error(`polycode hosted inference error (${res.status}): ${serverMsg}`);
+    }
+
+    try {
+      return JSON.parse(text);
+    } catch (err) {
+      throw new Error(`polycode hosted inference returned non-JSON body: ${text.slice(0, 200)}`);
+    }
+  }
+
+  return {
+    chat: {
+      completions: {
+        create: createCompletion,
+      },
+    },
+    _proxyUrl: url,
+    _installId: installId,
+  };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polylogicai/polycode",
-  "version": "1.1.3",
+  "version": "1.1.4",
   "description": "An agentic coding CLI. Runs on your machine with your keys. Every turn is appended to a SHA-256 chained session log, so your history is auditable, replayable, and portable.",
   "type": "module",
   "main": "bin/polycode.mjs",