loopengine 0.1.14 → 0.1.15

package/dist/bin/package-manager.js

@@ -24,7 +24,7 @@ import { tmpdir } from 'node:os';
 import { parse as parseYaml } from 'yaml';
 import semver from 'semver';
 import { agentDir } from '../core/gateway-tools.js';
-import { addToolToIndex, toCamelCase } from '../web/http-tool-admin.js';
+import { addToolToIndex, removeToolFromIndex, toCamelCase } from '../web/http-tool-admin.js';
 import { addActauthRule, updateActauthRule, removeActauthRule, readActauthConfig } from '../web/actauth-admin.js';
 export class PackageManifestError extends Error {
 }
@@ -484,6 +484,7 @@ export function removePackage(agentName, packageName, force = false) {
     const refused = [];
     const remainingTools = [];
     const remainingSkills = [];
+    const toolsIndexPath = join(agentDir(agentName), 'tools', 'index.ts');
     for (const toolName of record.tools) {
         const relPath = `tools/${toolName}.ts`;
         const fullPath = join(agentDir(agentName), relPath);
@@ -493,6 +494,14 @@ export function removePackage(agentName, packageName, force = false) {
             continue;
         }
         rmSync(fullPath, { force: true });
+        // Undoes installPackage's own addToolToIndex call — without this, a
+        // deleted tool's import survives in tools/index.ts, and either fails
+        // the next build (a dangling import to a file that no longer exists)
+        // or, worse, silently duplicates on a later add-package of the same
+        // tool (addToolToIndex used to have no idempotence check at all —
+        // now it does, but this is the actual fix: the stale entry shouldn't
+        // be there to begin with).
+        removeToolFromIndex(toolsIndexPath, toolName, toCamelCase(toolName));
         removed.push(relPath);
     }
     for (const skillId of record.skills) {

package/dist/web/http-tool-admin.d.ts

@@ -38,6 +38,17 @@ export interface HttpToolSpec {
 }
 export declare function toCamelCase(snakeCase: string): string;
 export declare function addToolToIndex(toolsIndexPath: string, toolFileName: string, exportName: string): void;
+/** addToolToIndex's own undo — removes the named tool's import line and
+ * array entry. Best-effort, not "refuse rather than guess" like
+ * addToolToIndex: this only ever runs against a tool package-manager.ts
+ * itself installed (so the exact shape addToolToIndex wrote is known),
+ * and the caller (removePackage) has already deleted the tool's .ts
+ * file — leaving a stale entry behind, the previous behavior, means a
+ * dangling import that fails the next build, which is strictly worse
+ * than a no-op here if the file turns out not to match (hand-edited
+ * since). No-ops (rather than throwing) when the file is missing
+ * entirely, or the expected import/array-entry shape isn't found. */
+export declare function removeToolFromIndex(toolsIndexPath: string, toolFileName: string, exportName: string): void;
 /** Generates agents/<agentName>/tools/<spec.name>.ts, registers it in
  * that agent's tools/index.ts, then imports the file it just wrote and
  * returns the real, callable ToolDefinition object — so the route

package/dist/web/http-tool-admin.js

@@ -191,15 +191,52 @@ export function addToolToIndex(toolsIndexPath, toolFileName, exportName) {
     if (!arrayMatch) {
         throw new HttpToolIndexShapeError(`${toolsIndexPath} doesn't match the expected "export const tools: ToolDefinition[] = [...]" shape — add this tool to it by hand instead.`);
     }
+    // Idempotent — a caller that adds the same tool twice (e.g. package-
+    // manager.ts's removePackage not having cleaned up this same file
+    // before a re-add, or simply calling this twice by mistake) gets a
+    // no-op the second time instead of a duplicate `import { X }`
+    // declaration, which is a TypeScript syntax error ("Duplicate
+    // identifier"), not just a harmless extra line.
+    const arrayEntries = arrayMatch[1]
+        .split(',')
+        .map((e) => e.trim())
+        .filter(Boolean);
+    if (arrayEntries.includes(exportName))
+        return;
     const importLine = `import { ${exportName} } from './${toolFileName}.js'\n`;
     const lastImportMatch = [...source.matchAll(/^import .+\n/gm)].pop();
     const insertAt = lastImportMatch ? lastImportMatch.index + lastImportMatch[0].length : 0;
     const withImport = source.slice(0, insertAt) + importLine + source.slice(insertAt);
-    const existingEntries = arrayMatch[1].trim();
-    const newEntries = existingEntries ? `${existingEntries}, ${exportName}` : exportName;
+    const newEntries = [...arrayEntries, exportName].join(', ');
     const withEntry = withImport.replace(/export const tools: ToolDefinition\[\] = \[([^\]]*)\]/, `export const tools: ToolDefinition[] = [${newEntries}]`);
     writeFileSync(toolsIndexPath, withEntry);
 }
+/** addToolToIndex's own undo — removes the named tool's import line and
+ * array entry. Best-effort, not "refuse rather than guess" like
+ * addToolToIndex: this only ever runs against a tool package-manager.ts
+ * itself installed (so the exact shape addToolToIndex wrote is known),
+ * and the caller (removePackage) has already deleted the tool's .ts
+ * file — leaving a stale entry behind, the previous behavior, means a
+ * dangling import that fails the next build, which is strictly worse
+ * than a no-op here if the file turns out not to match (hand-edited
+ * since). No-ops (rather than throwing) when the file is missing
+ * entirely, or the expected import/array-entry shape isn't found. */
+export function removeToolFromIndex(toolsIndexPath, toolFileName, exportName) {
+    if (!existsSync(toolsIndexPath))
+        return;
+    const source = readFileSync(toolsIndexPath, 'utf8');
+    const importLineRe = new RegExp(`^import \\{ ${exportName} \\} from '\\./${toolFileName}\\.js'\\n`, 'm');
+    const withoutImport = source.replace(importLineRe, '');
+    const arrayMatch = withoutImport.match(/export const tools: ToolDefinition\[\] = \[([^\]]*)\]/);
+    if (!arrayMatch)
+        return;
+    const remainingEntries = arrayMatch[1]
+        .split(',')
+        .map((e) => e.trim())
+        .filter((e) => e && e !== exportName);
+    const withEntry = withoutImport.replace(/export const tools: ToolDefinition\[\] = \[([^\]]*)\]/, `export const tools: ToolDefinition[] = [${remainingEntries.join(', ')}]`);
+    writeFileSync(toolsIndexPath, withEntry);
+}
 // The spec is persisted alongside the generated .ts file, under the same
 // name — this is what lets the Tools tab's Edit button repopulate the
 // form later without reverse-parsing generated code back into a spec,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loopengine",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "type": "module",
   "description": "Runtime for tool-using AI agents with a transparent ReAct loop.",
   "license": "MIT",