create-loopengine 0.1.15 → 0.1.17

package/README.md

@@ -115,10 +115,17 @@ Each of the five template-owned files gets one of:
   as any git merge conflict — resolve them by hand, then `npx tsc
   --noEmit` to confirm it builds.
 
-`upgrade` never touches `agents/`, `README.md`, `.env.example`, or
-`package.json`'s own dependency versions — run `npm install
-loopengine@latest` (and `actauth`/`skillgarden` if you use them directly)
-separately to pick those up.
+`upgrade` also bumps whichever of `loopengine`/`actauth`/`skillgarden`
+are already in your `package.json` to their latest published version
+(never adds one you don't already depend on) and runs `npm install` for
+you — a merged file that now calls a newer export is a silent, hard-to-
+notice failure if the installed package hasn't actually caught up, so
+this isn't left as a manual step. If the install itself fails (offline,
+a registry hiccup), the version bump is still written to `package.json`;
+just run `npm install` yourself to finish.
+
+`upgrade` never touches `agents/`, `README.md`, `.env.example`, or any
+dependency *other* than those three.
 
 ## Running in production
 

package/dist/cli.d.ts

@@ -11,10 +11,29 @@ export interface UpgradeFileResult {
     file: string;
     status: UpgradeFileStatus;
 }
+export interface UpgradeDependencyResult {
+    name: string;
+    from: string;
+    to: string;
+}
 export interface UpgradeResult {
     fromVersion: string;
     toVersion: string;
     files: UpgradeFileResult[];
+    /** Which of loopengine/actauth/skillgarden actually had their
+     * package.json range bumped — only ones already present as a
+     * dependency, never newly added (see bumpDependencies's own doc
+     * comment). Empty if the project has no package.json, or every present
+     * one was already at the latest range. */
+    dependencies: UpgradeDependencyResult[];
+    /** Only attempted when `dependencies` is non-empty — running `npm
+     * install` for a project with nothing to bump would be pointless. */
+    npmInstall?: {
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    };
 }
 export interface UpgradeOptions {
     /** Defaults to process.cwd(). */
@@ -31,6 +50,13 @@ export interface UpgradeOptions {
      * (a real `npm pack`). Test-only seam to avoid hitting the real
      * registry for a fixture "old" template. */
     resolveBaseTemplateDir?: (version: string) => string;
+    /** Resolves a package's current latest version — defaults to a real
+     * `npm view <pkg> version`. Test-only seam to avoid hitting the real
+     * registry. */
+    resolveLatestVersion?: (pkg: string) => string;
+    /** Runs `npm install` in projectDir — defaults to a real one. Test-only
+     * seam to avoid actually installing anything during tests. */
+    runNpmInstall?: (projectDir: string) => void;
 }
 export declare function upgradeProject(options?: UpgradeOptions): UpgradeResult;
 export declare function main(argv?: string[]): void;

package/dist/cli.js

@@ -163,8 +163,76 @@ export function upgradeProject(options = {}) {
     const resolveBase = options.resolveBaseTemplateDir ?? fetchPublishedTemplateDir;
     const baseTemplateDir = resolveBase(fromVersion);
     const files = UPGRADE_CANDIDATE_FILES.map((candidate) => upgradeFile(candidate, baseTemplateDir, currentTemplateDir, projectDir));
+    const resolveLatestVersion = options.resolveLatestVersion ?? resolveLatestVersionFromNpm;
+    const dependencies = bumpDependencies(projectDir, resolveLatestVersion);
+    let npmInstall;
+    if (dependencies.length > 0) {
+        const install = options.runNpmInstall ?? runRealNpmInstall;
+        try {
+            install(projectDir);
+            npmInstall = { ok: true };
+        }
+        catch (err) {
+            // Non-fatal — the file merge and the package.json bump already
+            // succeeded and are on disk either way; a failed install (offline,
+            // a registry hiccup) just means the operator runs `npm install`
+            // themselves, the same single command this was trying to save them
+            // from typing, not a reason to unwind everything already done.
+            npmInstall = { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
     writeFileSync(provenancePath, JSON.stringify({ version: toVersion }, null, 2) + '\n');
-    return { fromVersion, toVersion, files };
+    return { fromVersion, toVersion, files, dependencies, npmInstall };
+}
+function resolveLatestVersionFromNpm(pkg) {
+    return execFileSync('npm', ['view', pkg, 'version'], { stdio: 'pipe' }).toString().trim();
+}
+function runRealNpmInstall(projectDir) {
+    execFileSync('npm', ['install'], { cwd: projectDir, stdio: 'pipe' });
+}
+// Only loopengine/actauth/skillgarden — the three packages a scaffolded
+// project's own adapters/http.ts can import directly (see this repo's own
+// README on why: template code that imports a package must declare it as
+// its own direct dependency, not rely on loopengine's transitive one) —
+// and only ones already present in the project's own package.json.
+// Deliberately never *adds* a dependency a project doesn't already have:
+// this command upgrades what's there, it doesn't decide what a project
+// should depend on.
+const UPGRADABLE_DEPENDENCIES = ['loopengine', 'actauth', 'skillgarden'];
+/** Bumps package.json's dependency ranges for whichever of
+ * loopengine/actauth/skillgarden are already present, to `^<latest>` —
+ * run automatically as part of `upgrade` (not left as a manual follow-up
+ * step) because a project whose merged template code now calls a newer
+ * export, but whose installed package is still old, fails silently: no
+ * conflict marker, no build error, just a feature that's quietly not
+ * there yet (confirmed live — this exact gap is what prompted adding this
+ * function in the first place, see this repo's own git history). Returns
+ * [] untouched if the project has no package.json at all, same
+ * "can't merge what isn't there" reasoning upgradeFile's own missing-file
+ * check uses. */
+function bumpDependencies(projectDir, resolveLatestVersion) {
+    const pkgPath = join(projectDir, 'package.json');
+    if (!existsSync(pkgPath))
+        return [];
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    const deps = pkg.dependencies;
+    if (!deps)
+        return [];
+    const changes = [];
+    for (const name of UPGRADABLE_DEPENDENCIES) {
+        const currentRange = deps[name];
+        if (currentRange === undefined)
+            continue;
+        const latest = resolveLatestVersion(name);
+        const newRange = `^${latest}`;
+        if (currentRange === newRange)
+            continue;
+        deps[name] = newRange;
+        changes.push({ name, from: currentRange, to: newRange });
+    }
+    if (changes.length > 0)
+        writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    return changes;
 }
 function parseUpgradeArgs(argv) {
     let from;
@@ -187,7 +255,18 @@ function printUpgradeSummary(result) {
         console.log(`${conflicted.length} file(s) have <<<<<<< conflict markers to resolve by hand before this will build.`);
     }
     else {
-        console.log('No conflicts. Run `npm install loopengine@latest` to pick up any library-side changes too.');
+        console.log('No conflicts.');
+    }
+    if (result.dependencies.length > 0) {
+        console.log();
+        for (const dep of result.dependencies)
+            console.log(`  ${dep.name}: ${dep.from} -> ${dep.to}`);
+        if (result.npmInstall?.ok) {
+            console.log('npm install completed.');
+        }
+        else if (result.npmInstall) {
+            console.log(`npm install failed (${result.npmInstall.error}) — run it yourself to finish picking up the new versions.`);
+        }
     }
 }
 function parseArgs(argv) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "Scaffold a new loopengine agent project — a runnable HTTP server with one example agent, in your own repo.",
   "license": "MIT",
   "type": "module",

package/template/adapters/http.ts

@@ -524,6 +524,13 @@ async function handleHttpToolPost(req: IncomingMessage, res: ServerResponse, age
     return
   }
 
+  // Resolved *before* createHttpTool writes anything to disk. Reading it
+  // after would risk a cold import of the freshly-written tools/index.ts
+  // (folder-form agents don't cache config.tools) — which already contains
+  // the new tool by then, so the ...currentTools, tool below would append
+  // it a second time.
+  const currentTools = entry.config.tools ?? (await loadDefaultTools(entry.config))
+
   let tool: ToolDefinition
   try {
     const result = await createHttpTool(agentName, parsed.value)
@@ -534,7 +541,6 @@ async function handleHttpToolPost(req: IncomingMessage, res: ServerResponse, age
     return
   }
 
-  const currentTools = entry.config.tools ?? (await loadDefaultTools(entry.config))
   updateAgent(agentName, { config: { tools: [...currentTools, tool] } })
 
   if (parsed.decision) {