@outsidestudio/agent-kit 0.1.1 → 0.2.0

package/README.md

@@ -20,13 +20,14 @@ That command:
 2. Asks once for any secrets the profile needs (API keys, model endpoint) and stores them in `~/.config/outside-agent-kit/env` (chmod 600), loaded from `~/.zshrc` / `~/.bashrc`.
 3. Fetches the **latest** version of every skill and plugin. Nothing is pinned.
 4. Writes each tool's config, keeping anything the developer added themselves.
+5. Installing **only registry items** (no profile) is additive: it adds/replaces those items and keeps the rest of your install. Installing a profile reconciles the full set.
 
 ## Commands
 
 | Command | What it does |
 |---|---|
 | `agent-kit <profile...>` | Install one or more profiles |
-| `agent-kit outside/llm` | Install a single registry item (see `agent-kit list`) |
+| `agent-kit outside/llm` | Add/refresh a single registry item without touching the rest of the install (see `agent-kit list`) |
 | `agent-kit update` | Re-install the current targets with the latest of everything |
 | `agent-kit doctor` | Check tools, secrets, model endpoint, MCP servers, skills |
 | `agent-kit secrets` | Enter missing secrets |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outsidestudio/agent-kit",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "One-command setup of skills, MCP servers and model providers for OpenCode and OMP",
   "type": "module",
   "bin": {

package/registry/outside/llm.json

@@ -5,8 +5,8 @@
   "baseURL": "${OUTSIDE_LLM_BASE_URL}",
   "apiKey": "${OUTSIDE_LLM_API_KEY}",
   "models": {
-    "nvidia/Qwen2.8-Flash-Next-NVFP4": {
-      "name": "Qwen2.8 Flash Next (NVFP4)",
+    "nvidia/Qwen3.8-Flash-Next-NVFP4": {
+      "name": "Qwen3.8 Flash Next (NVFP4)",
       "reasoning": true,
       "contextWindow": 131072,
       "maxTokens": 32768,
@@ -22,5 +22,5 @@
     "OUTSIDE_LLM_BASE_URL",
     "OUTSIDE_LLM_API_KEY"
   ],
-  "defaultModel": "nvidia/Qwen2.8-Flash-Next-NVFP4"
+  "defaultModel": "nvidia/Qwen3.8-Flash-Next-NVFP4"
 }

package/skills/shared/outside-commit-conventions/SKILL.md

@@ -12,12 +12,13 @@ Write commits in Conventional Commits format:
 
 <optional body: what changed and why, wrapped at 72>
 
-Refs: <TICKET-123>
+Refs: TICKET-123 (optional - omit the line when there is no ticket)
 ```
 
 - `type` is one of: feat, fix, refactor, perf, test, docs, chore, ci.
 - `scope` is the package, app or module name.
-- Include the ticket reference when the branch name contains one.
+- The ticket reference is optional: include `Refs:` when a ticket exists
+  (e.g. the branch name contains one); omit the line entirely otherwise.
 - One logical change per commit. Split unrelated changes.
 - Always commit as the repository author, using the configured git
   `user.name` and `user.email`. Never override the author.

package/src/adapters/omp.ts

@@ -76,12 +76,15 @@ export const omp: Adapter = {
 
   async apply(plan, prev): Promise<ToolState> {
     const state: ToolState = { skills: [], mcp: [], plugins: [], providers: [] };
+    // Additive installs (single registry item) only replace the keys this plan writes.
+    const keeps = plan.additive === true;
+    const mcpKeys = new Set(plan.items.filter((i) => i.kind === "mcp").map((i) => toolKey(i.id)));
 
     // MCP servers
     const { data: cfg } = await readJsonFile<Record<string, any>>(paths.ompMcpFile);
     cfg.$schema ??= MCP_SCHEMA;
     cfg.mcpServers ??= {};
-    for (const name of prev?.mcp ?? []) delete cfg.mcpServers[name];
+    for (const name of prev?.mcp ?? []) if (!keeps || mcpKeys.has(name)) delete cfg.mcpServers[name];
 
     const skills = [...plan.skills];
     const providers: Provider[] = [];
@@ -112,10 +115,13 @@ export const omp: Adapter = {
     }
     await writeJsonFile(paths.ompMcpFile, cfg);
 
-    if (providers.length || prev?.providers?.length) {
-      state.providers = await writeProviders(providers, prev?.providers ?? []);
+    if (providers.length || (!keeps && prev?.providers?.length)) {
+      const dropProviders = (prev?.providers ?? []).filter(
+        (id) => !keeps || providers.some((p) => toolKey(p.id) === id),
+      );
+      state.providers = await writeProviders(providers, dropProviders);
     }
-    state.skills = syncSkillsDir(paths.ompSkillsDir, skills, prev?.skills ?? [], "omp");
+    state.skills = syncSkillsDir(paths.ompSkillsDir, skills, prev?.skills ?? [], "omp", keeps);
 
     log.ok(
       `omp: ${state.skills.length} skills, ${state.mcp.length} MCP servers, ` +

package/src/adapters/opencode.ts

@@ -64,13 +64,24 @@ export const opencode: Adapter = {
     cfg.$schema ??= "https://opencode.ai/config.json";
 
     const state: ToolState = { skills: [], mcp: [], plugins: [], providers: [] };
+    // Additive installs (single registry item) only replace the keys this plan writes.
+    const keeps = plan.additive === true;
+    const dropIfReplaced = (managed: string[], keys: Set<string>) =>
+      managed.filter((k) => !keeps || keys.has(k));
+    const mcpKeys = new Set(plan.items.filter((i) => i.kind === "mcp").map((i) => toolKey(i.id)));
+    const providerKeys = new Set(
+      plan.items.filter((i) => i.kind === "provider").map((i) => toolKey(i.id)),
+    );
+    const pluginKeys = new Set<string>();
+    for (const i of plan.items) if (i.kind === "plugin" && i.opencode) pluginKeys.add(i.opencode.plugin);
 
-    // Drop everything we managed last time, then add the current set.
+    // Drop the managed entries this plan replaces (in non-additive mode: all of them).
     cfg.mcp ??= {};
-    for (const name of prev?.mcp ?? []) delete cfg.mcp[name];
-    cfg.plugin = (cfg.plugin ?? []).filter((p: string) => !(prev?.plugins ?? []).includes(p));
+    for (const name of dropIfReplaced(prev?.mcp ?? [], mcpKeys)) delete cfg.mcp[name];
+    const dropPlugins = dropIfReplaced(prev?.plugins ?? [], pluginKeys);
+    cfg.plugin = (cfg.plugin ?? []).filter((p: string) => !dropPlugins.includes(p));
     cfg.provider ??= {};
-    for (const id of prev?.providers ?? []) delete cfg.provider[id];
+    for (const id of dropIfReplaced(prev?.providers ?? [], providerKeys)) delete cfg.provider[id];
 
     const skills = [...plan.skills];
     for (const item of plan.items) {
@@ -101,7 +112,7 @@ export const opencode: Adapter = {
     if (!Object.keys(cfg.provider).length) delete cfg.provider;
 
     await writeJsonFile(file, cfg);
-    state.skills = syncSkillsDir(paths.opencodeSkillsDir, skills, prev?.skills ?? [], "opencode");
+    state.skills = syncSkillsDir(paths.opencodeSkillsDir, skills, prev?.skills ?? [], "opencode", keeps);
 
     log.ok(
       `opencode: ${state.skills.length} skills, ${state.mcp.length} MCP servers, ` +

package/src/commands/install.ts

@@ -5,7 +5,7 @@ import { loadItem, resolveProfiles, resolveTargets, secretsOf } from "../registr
 import { resolveSkillSource } from "../sources";
 import { ensureSecrets, ensureShellSourcesEnv, readEnvFile } from "../secrets";
 import { readState, writeState } from "../state";
-import type { Plan, PluginItem, State } from "../types";
+import type { Plan, PluginItem, State, ToolState } from "../types";
 
 export interface InstallOptions {
   tools?: string[];
@@ -31,9 +31,24 @@ function pickTools(requested?: string[]): string[] {
   return found;
 }
 
+/** Additive installs keep what the previous install managed; new keys win. */
+function mergeToolState(prev: ToolState | undefined, next: ToolState): ToolState {
+  if (!prev) return next;
+  const u = (a: string[], b: string[]) => [...new Set([...a, ...b])];
+  return {
+    skills: u(prev.skills, next.skills),
+    mcp: u(prev.mcp, next.mcp),
+    plugins: u(prev.plugins, next.plugins),
+    providers: u(prev.providers, next.providers),
+  };
+}
+
 export async function install(targets: string[], opts: InstallOptions = {}) {
   const tools = pickTools(opts.tools);
   const { profiles, items: direct } = await resolveTargets(targets);
+  // Targeting only registry items adds/replaces those items; it never purges
+  // the rest of the install. A profile target still reconciles the full set.
+  const additive = profiles.length === 0 && direct.length > 0;
   log.head(`Setting up ${targets.map((t) => `"${t}"`).join(" + ")} for ${tools.join(" + ")}`);
 
   const ids = [...new Set([...(await resolveProfiles(profiles)), ...direct])];
@@ -48,7 +63,7 @@ export async function install(targets: string[], opts: InstallOptions = {}) {
 
   // Fetch skills (always latest).
   log.step("Fetching skills");
-  const plan: Plan = { profiles, items, skills: [], fallbackSkills: {}, fetched: {} };
+  const plan: Plan = { profiles, items, skills: [], fallbackSkills: {}, fetched: {}, additive };
   for (const item of items) {
     try {
       if (item.kind === "skills") {
@@ -79,15 +94,17 @@ export async function install(targets: string[], opts: InstallOptions = {}) {
   log.step("Writing tool configs");
   const prev = await readState();
   const state: State = {
-    profiles,
-    items: direct,
+    profiles: additive ? [...new Set([...(prev?.profiles ?? []), ...profiles])] : profiles,
+    items: additive ? [...new Set([...(prev?.items ?? []), ...direct])] : direct,
     tools: [...new Set([...(prev?.tools ?? []), ...tools])],
     updatedAt: new Date().toISOString(),
     managed: { ...(prev?.managed ?? {}) },
-    installed: plan.fetched,
+    installed: additive ? { ...(prev?.installed ?? {}), ...plan.fetched } : plan.fetched,
   };
+  if (additive && prev) log.step(`Additive: keeping ${prev.profiles.join(", ") || "existing items"}; replacing ${direct.join(", ")}`);
   for (const t of tools) {
-    state.managed[t] = await adapters[t].apply(plan, prev?.managed[t]);
+    const next = await adapters[t].apply(plan, prev?.managed[t]);
+    state.managed[t] = additive ? mergeToolState(prev?.managed[t], next) : next;
   }
   await writeState(state);
 

package/src/skills-install.ts

@@ -7,12 +7,15 @@ import type { ResolvedSkill } from "./types";
  * Copy skills into a tool's skills dir. Only overwrites folders the kit
  * installed before (tracked in `prevManaged`); a folder the user created
  * with the same name is left alone. Removes kit skills no longer wanted.
+ * In `additive` mode (single registry-item installs) nothing is removed;
+ * managed folders in the plan are still refreshed.
  */
 export function syncSkillsDir(
   targetDir: string,
   skills: ResolvedSkill[],
   prevManaged: string[],
   toolName: string,
+  additive = false,
 ): string[] {
   mkdirSync(targetDir, { recursive: true });
   const installed: string[] = [];
@@ -34,8 +37,9 @@ export function syncSkillsDir(
     installed.push(skill.name);
   }
 
-  for (const old of prevManaged) {
-    if (!seen.has(old)) rmSync(join(targetDir, old), { recursive: true, force: true });
-  }
+  if (!additive)
+    for (const old of prevManaged) {
+      if (!seen.has(old)) rmSync(join(targetDir, old), { recursive: true, force: true });
+    }
   return installed;
 }

package/src/types.ts

@@ -94,6 +94,11 @@ export interface Plan {
   fallbackSkills: Record<string, ResolvedSkill[]>;
   /** What was fetched, for the install log. */
   fetched: Record<string, string>;
+  /**
+   * Single registry-item install: replace only the items in this plan and
+   * keep everything else the kit managed before (no purge of skills/MCP/etc).
+   */
+  additive?: boolean;
 }
 
 export interface ToolState {