armin-opencode 0.1.1 → 0.1.3

package/README.md

@@ -8,6 +8,9 @@ npx armin-opencode install      # or: npm i -g armin-opencode && armin install
 export ARMIN_ENABLED=1
 ```
 
+Prefer a global install over one-off `npx` runs: the plugin registration
+points at the package's install location, and `npx` caches are evicted.
+
 `armin install` downloads the `armin-engine` sidecar binary for your platform
 from the [GitHub releases](https://github.com/bastian-seifert/armin/releases)
 and registers the plugin in your global opencode config. Enable it per

package/bin/armin.js

@@ -94,10 +94,35 @@ function buildFromSource() {
   return true;
 }
 
+let pendingTypesafeKey = null;
+
+/** Ask for the Typesafe key when nothing is configured (TTY only; the key
+ * goes into the opencode config — the plugin passes it to the sidecar). */
+function askForTypesafeKey() {
+  if (process.env.TYPESAFE_AI_API_KEY) return Promise.resolve();
+  if (!process.stdin.isTTY) return Promise.resolve();
+  const readline = require("readline");
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(
+      "TypeSafe System One API key (jev extraction is the default) — paste, or Enter to skip: ",
+      (answer) => {
+        rl.close();
+        const key = (answer || "").trim();
+        if (key) pendingTypesafeKey = key;
+        resolve();
+      },
+    );
+  });
+}
+
 function registerPlugin() {
   const plugin = path.join(PKG_ROOT, "plugins", "armin.ts");
   if (!fs.existsSync(plugin)) throw new Error(`plugin not found at ${plugin}`);
-  const cfgDir = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config", "opencode");
+  const cfgDir = path.join(
+    process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"),
+    "opencode",
+  );
   const cfgPath = fs.existsSync(path.join(cfgDir, "opencode.jsonc"))
     ? path.join(cfgDir, "opencode.jsonc")
     : path.join(cfgDir, "opencode.json");
@@ -112,10 +137,18 @@ function registerPlugin() {
     }
   }
   const entry = "file://" + plugin;
+  let changed = false;
   const plugins = Array.isArray(data.plugin) ? data.plugin : [];
   if (!plugins.includes(entry)) {
     plugins.push(entry);
     data.plugin = plugins;
+    changed = true;
+  }
+  if (pendingTypesafeKey && !process.env.TYPESAFE_AI_API_KEY) {
+    data.armin = { ...(data.armin || {}), typesafeKey: pendingTypesafeKey };
+    changed = true;
+  }
+  if (changed) {
     fs.mkdirSync(cfgDir, { recursive: true });
     fs.writeFileSync(cfgPath, JSON.stringify(data, null, 2));
   }
@@ -141,7 +174,26 @@ async function install() {
       }
     }
   }
+  await askForTypesafeKey();
   registerPlugin();
+  const tsKey = process.env.TYPESAFE_AI_API_KEY || pendingTypesafeKey;
+  const llmKey = process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY;
+  if (tsKey) {
+    console.log("extraction: jev (TypeSafe System One) — ready");
+  } else if (llmKey) {
+    console.log(
+      "extraction: LLM fallback — jev is the default but no Typesafe key is set.\n" +
+        "  Get a key at typesafe.ai and export TYPESAFE_AI_API_KEY (or put\n" +
+        '  "armin": { "typesafeKey": "..." } in your opencode config).',
+    );
+  } else {
+    console.log(
+      "extraction: NONE (deterministic-only) — import, capture and unverified-edit\n" +
+        "  warnings work; prose extraction does not.\n" +
+        "  Set TYPESAFE_AI_API_KEY (typesafe.ai) for jev extraction — the default —\n" +
+        "  or ANTHROPIC_API_KEY / OPENAI_API_KEY for LLM fallback.",
+    );
+  }
   console.log(`
 ── done ────────────────────────────────────────────────────────
 Enable ARMIN per environment:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "armin-opencode",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "ARMIN — queryable decision memory for AI coding agents. Installs the armin-engine sidecar and registers the opencode plugin.",
   "license": "Apache-2.0",
   "author": "Bastian Seifert",

package/plugins/armin.ts

@@ -16,6 +16,8 @@
  *       "enabled": true,
  *       "provider": "anthropic",          // anthropic | openai (default: infer from keys)
  *       "apiKey": "sk-...",               // sent to the sidecar only; env key wins if both set
+ *       "typesafeKey": "...",             // Typesafe System One key (jev is the
+ *                                         // default extraction mode); env wins
  *       "model": "session",               // "session" = follow the live session model
  *                                         // "small"  = reuse opencode's small_model setting
  *                                         // any string = fixed extraction model
@@ -490,6 +492,10 @@ const ArminPlugin: Plugin = async (ctx) => {
   if (provider === "anthropic" || provider === "openai") {
     spawnEnv.LLM_PROVIDER = provider
   }
+  // Typesafe key (jev is the default extraction mode): config value is
+  // passed to the sidecar only; a key already in the environment wins.
+  const typesafeKey = cfgStr("typesafeKey", "TYPESAFE_AI_API_KEY")
+  if (typesafeKey) spawnEnv.TYPESAFE_AI_API_KEY = typesafeKey
   // API key: config value is passed to the sidecar only; a key already in
   // the environment wins (no override).
   if (typeof armin.apiKey === "string" && armin.apiKey) {
@@ -519,6 +525,31 @@ const ArminPlugin: Plugin = async (ctx) => {
   if (sidecar.port) {
     log(`reasoning-state UI: http://127.0.0.1:${sidecar.port}/ui`)
   }
+  // Surface the effective extraction mode once — this is the difference
+  // between "memory works" and a silent deterministic downgrade.
+  void (async () => {
+    try {
+      const health = await api.get<{ extraction: string }>("/health")
+      const mode = health?.extraction ?? "unknown"
+      if (mode === "jev") {
+        log(`extraction: jev (TypeSafe System One) — ready`)
+      } else if (mode === "llm") {
+        log(
+          `extraction: llm (fallback) — jev is the default but no Typesafe key is ` +
+            `configured. Set TYPESAFE_AI_API_KEY in your environment or ` +
+            `"armin": { "typesafeKey": "..." } in your opencode config.`,
+        )
+      } else {
+        log(
+          `extraction: deterministic-only — no API keys found. Import and ` +
+            `unverified-edit warnings work; prose extraction does not. Set ` +
+            `TYPESAFE_AI_API_KEY (or ANTHROPIC/OPENAI_API_KEY) to enable it.`,
+        )
+      }
+    } catch {
+      // best-effort status only
+    }
+  })()
 
   // ── Cold start: import AGENTS.md / CLAUDE.md into an empty graph ──────
   // Deterministic parse on the engine side (content-hash IDs, idempotent).