@positronic/cloudflare 0.0.15 → 0.0.17

package/dist/src/brain-resolver.js

@@ -0,0 +1,232 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr)) return arr;
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _defineProperties(target, props) {
+    for(var i = 0; i < props.length; i++){
+        var descriptor = props[i];
+        descriptor.enumerable = descriptor.enumerable || false;
+        descriptor.configurable = true;
+        if ("value" in descriptor) descriptor.writable = true;
+        Object.defineProperty(target, descriptor.key, descriptor);
+    }
+}
+function _create_class(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+}
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null) return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for(_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true){
+            _arr.push(_s.value);
+            if (i && _arr.length === i) break;
+        }
+    } catch (err) {
+        _d = true;
+        _e = err;
+    } finally{
+        try {
+            if (!_n && _i["return"] != null) _i["return"]();
+        } finally{
+            if (_d) throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+export var BrainResolver = /*#__PURE__*/ function() {
+    "use strict";
+    function BrainResolver(enhancedManifest) {
+        _class_call_check(this, BrainResolver);
+        _define_property(this, "enhancedManifest", void 0);
+        _define_property(this, "metadataCache", void 0);
+        this.enhancedManifest = enhancedManifest;
+        this.metadataCache = new Map();
+        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+        try {
+            // Pre-cache brain titles and descriptions
+            for(var _iterator = Object.entries(enhancedManifest)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                var _step_value = _sliced_to_array(_step.value, 2), filename = _step_value[0], metadata = _step_value[1];
+                var brain = metadata.brain;
+                // Access brain structure to get title and description
+                var structure = brain.structure;
+                this.metadataCache.set(filename, {
+                    title: structure.title || filename,
+                    description: structure.description
+                });
+            }
+        } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+        } finally{
+            try {
+                if (!_iteratorNormalCompletion && _iterator.return != null) {
+                    _iterator.return();
+                }
+            } finally{
+                if (_didIteratorError) {
+                    throw _iteratorError;
+                }
+            }
+        }
+    }
+    _create_class(BrainResolver, [
+        {
+            key: "resolve",
+            value: function resolve(identifier) {
+                var candidates = [];
+                // Normalize identifier for comparison
+                var normalizedIdentifier = identifier.toLowerCase().trim();
+                var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                try {
+                    // Check each brain in the manifest
+                    for(var _iterator = Object.entries(this.enhancedManifest)[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true){
+                        var _step_value = _sliced_to_array(_step.value, 2), filename = _step_value[0], metadata = _step_value[1];
+                        var cached = this.metadataCache.get(filename);
+                        var title = cached.title;
+                        var description = cached.description;
+                        // 1. Exact title match (case-insensitive)
+                        if (title.toLowerCase() === normalizedIdentifier) {
+                            return {
+                                matchType: 'exact',
+                                brain: metadata.brain
+                            };
+                        }
+                        // 2. Exact filename match (case-insensitive)
+                        if (filename.toLowerCase() === normalizedIdentifier) {
+                            return {
+                                matchType: 'exact',
+                                brain: metadata.brain
+                            };
+                        }
+                        // 3. Exact path match (case-insensitive)
+                        if (metadata.path.toLowerCase() === normalizedIdentifier) {
+                            return {
+                                matchType: 'exact',
+                                brain: metadata.brain
+                            };
+                        }
+                        // Collect candidates for partial matching
+                        var candidate = {
+                            title: title,
+                            filename: filename,
+                            path: metadata.path,
+                            description: description
+                        };
+                        // 4. Partial path match
+                        if (metadata.path.toLowerCase().includes(normalizedIdentifier)) {
+                            candidates.push(candidate);
+                            continue;
+                        }
+                        // 5. Title contains identifier
+                        if (title.toLowerCase().includes(normalizedIdentifier)) {
+                            candidates.push(candidate);
+                            continue;
+                        }
+                        // 6. Filename contains identifier
+                        if (filename.toLowerCase().includes(normalizedIdentifier)) {
+                            candidates.push(candidate);
+                            continue;
+                        }
+                        // 7. Description contains identifier (if exists)
+                        if (description && description.toLowerCase().includes(normalizedIdentifier)) {
+                            candidates.push(candidate);
+                        }
+                    }
+                } catch (err) {
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                } finally{
+                    try {
+                        if (!_iteratorNormalCompletion && _iterator.return != null) {
+                            _iterator.return();
+                        }
+                    } finally{
+                        if (_didIteratorError) {
+                            throw _iteratorError;
+                        }
+                    }
+                }
+                // Handle results
+                if (candidates.length === 0) {
+                    return {
+                        matchType: 'none'
+                    };
+                } else if (candidates.length === 1) {
+                    // Single match found through partial matching
+                    var match = this.enhancedManifest[candidates[0].filename];
+                    return {
+                        matchType: 'exact',
+                        brain: match.brain
+                    };
+                } else {
+                    // Multiple matches found
+                    return {
+                        matchType: 'multiple',
+                        candidates: candidates
+                    };
+                }
+            }
+        },
+        {
+            /**
+   * Get a brain by exact filename (used for backward compatibility)
+   */ key: "getByFilename",
+            value: function getByFilename(filename) {
+                var metadata = this.enhancedManifest[filename];
+                return metadata === null || metadata === void 0 ? void 0 : metadata.brain;
+            }
+        },
+        {
+            /**
+   * List all available brains
+   */ key: "list",
+            value: function list() {
+                return Object.keys(this.enhancedManifest);
+            }
+        }
+    ]);
+    return BrainResolver;
+}();

package/dist/src/brain-runner-do.js

@@ -504,7 +504,7 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
         },
         {
             key: "start",
-            value: function start(brainName, brainRunId, initialData) {
+            value: function start(brainTitle, brainRunId, initialData) {
                 return _async_to_generator(function() {
                     var sql, brainToRun, sqliteAdapter, eventStreamAdapter, monitorAdapter, scheduleAdapter, r2Resources, runnerWithResources, options, initialState;
                     return _ts_generator(this, function(_state) {
@@ -516,14 +516,14 @@ export var BrainRunnerDO = /*#__PURE__*/ function(DurableObject) {
                                 }
                                 return [
                                     4,
-                                    manifest.import(brainName)
+                                    manifest.import(brainTitle)
                                 ];
                             case 1:
                                 brainToRun = _state.sent();
                                 if (!brainToRun) {
-                                    console.error("[DO ".concat(brainRunId, "] Brain ").concat(brainName, " not found in manifest."));
+                                    console.error("[DO ".concat(brainRunId, "] Brain ").concat(brainTitle, " not found in manifest."));
                                     console.error(JSON.stringify(manifest, null, 2));
-                                    throw new Error("Brain ".concat(brainName, " not found"));
+                                    throw new Error("Brain ".concat(brainTitle, " not found"));
                                 }
                                 sqliteAdapter = new BrainRunSQLiteAdapter(sql);
                                 eventStreamAdapter = this.eventStreamAdapter;

package/dist/src/dev-server.js

@@ -254,6 +254,7 @@ import * as os from 'os';
 import { spawn } from 'child_process';
 import * as dotenv from 'dotenv';
 import caz from 'caz';
+import { createRequire } from 'module';
 /**
  * Implementation of ServerHandle that wraps a ChildProcess
  */ var ProcessServerHandle = /*#__PURE__*/ function() {
@@ -408,7 +409,7 @@ import caz from 'caz';
 }();
 function generateProject(projectName, projectDir, onSuccess) {
     return _async_to_generator(function() {
-        var devPath, newProjectTemplatePath, cazOptions, originalNewProjectPkg, copiedNewProjectPkg;
+        var devPath, newProjectTemplatePath, cazOptions, templateSourcePath, require, templatePackageJsonPath, copiedNewProjectPkg;
         return _ts_generator(this, function(_state) {
             switch(_state.label){
                 case 0:
@@ -434,19 +435,29 @@ function generateProject(projectName, projectDir, onSuccess) {
                         // monorepo which then causes the tests to fail. Also any time I was generating a new
                         // project it was a pain to have to run npm install over and over again just
                         // to get back to a good state.
-                        originalNewProjectPkg = path.resolve(devPath, 'packages', 'template-new-project');
-                        copiedNewProjectPkg = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-newproj-'));
-                        fs.cpSync(originalNewProjectPkg, copiedNewProjectPkg, {
-                            recursive: true
-                        });
-                        newProjectTemplatePath = copiedNewProjectPkg;
-                        cazOptions = {
-                            name: projectName,
-                            backend: 'cloudflare',
-                            install: true,
-                            pm: 'npm'
-                        };
+                        templateSourcePath = path.resolve(devPath, 'packages', 'template-new-project');
+                    } else {
+                        // Resolve the installed template package location
+                        require = createRequire(import.meta.url);
+                        templatePackageJsonPath = require.resolve('@positronic/template-new-project/package.json');
+                        templateSourcePath = path.dirname(templatePackageJsonPath);
                     }
+                    // Always copy to a temporary directory to avoid CAZ modifying our source
+                    // CAZ only supports local paths, GitHub repos, or ZIP URLs - not npm package names
+                    // Additionally, CAZ runs 'npm install --production' in the template directory,
+                    // which would modify our installed node_modules if we passed the path directly
+                    copiedNewProjectPkg = fs.mkdtempSync(path.join(os.tmpdir(), 'positronic-newproj-'));
+                    fs.cpSync(templateSourcePath, copiedNewProjectPkg, {
+                        recursive: true
+                    });
+                    newProjectTemplatePath = copiedNewProjectPkg;
+                    // Set CAZ options for cloudflare backend
+                    cazOptions = {
+                        name: projectName,
+                        backend: 'cloudflare',
+                        install: true,
+                        pm: 'npm'
+                    };
                     return [
                         4,
                         caz.default(newProjectTemplatePath, projectDir, _object_spread_props(_object_spread({}, cazOptions), {
@@ -467,13 +478,11 @@ function generateProject(projectName, projectDir, onSuccess) {
                     ];
                 case 4:
                     // Clean up the temporary copied new project package
-                    if (devPath) {
-                        fs.rmSync(newProjectTemplatePath, {
-                            recursive: true,
-                            force: true,
-                            maxRetries: 3
-                        });
-                    }
+                    fs.rmSync(newProjectTemplatePath, {
+                        recursive: true,
+                        force: true,
+                        maxRetries: 3
+                    });
                     return [
                         7
                     ];
@@ -527,7 +536,12 @@ function regenerateManifestFile(projectRootPath, targetSrcDir) {
                             importPath = "../../brains/".concat(brainName, ".js");
                             importAlias = "brain_".concat(brainName.replace(/[^a-zA-Z0-9_]/g, '_'));
                             importStatements += "import * as ".concat(importAlias, " from '").concat(importPath, "';\n");
-                            manifestEntries += "  ".concat(JSON.stringify(brainName), ": ").concat(importAlias, ".default as Brain,\n");
+                            // Create manifest entry with metadata
+                            manifestEntries += "  ".concat(JSON.stringify(brainName), ": {\n");
+                            manifestEntries += "    filename: ".concat(JSON.stringify(brainName), ",\n");
+                            manifestEntries += "    path: ".concat(JSON.stringify("brains/".concat(file)), ",\n");
+                            manifestEntries += "    brain: ".concat(importAlias, ".default as Brain,\n");
+                            manifestEntries += "  },\n";
                         }
                     } catch (err) {
                         _didIteratorError = true;
@@ -545,7 +559,7 @@ function regenerateManifestFile(projectRootPath, targetSrcDir) {
                     }
                     _state.label = 3;
                 case 3:
-                    manifestContent = "// This file is generated automatically. Do not edit directly.\n".concat(importStatements, "\nexport const staticManifest: Record<string, Brain> = {\n").concat(manifestEntries, "};\n");
+                    manifestContent = "// This file is generated automatically. Do not edit directly.\n".concat(importStatements, "\nimport type { BrainMetadata } from '@positronic/cloudflare';\n\nexport const manifest: Record<string, BrainMetadata> = {\n").concat(manifestEntries, "};\n");
                     return [
                         4,
                         fsPromises.readFile(runnerPath, 'utf-8')

package/dist/src/manifest.js

@@ -150,27 +150,37 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
+import { BrainResolver } from './brain-resolver.js';
 var StaticManifestStrategy = /*#__PURE__*/ function() {
     "use strict";
     function StaticManifestStrategy(manifest) {
         _class_call_check(this, StaticManifestStrategy);
         _define_property(this, "manifest", void 0);
+        _define_property(this, "resolver", void 0);
         this.manifest = manifest;
+        this.resolver = new BrainResolver(manifest);
     }
     _create_class(StaticManifestStrategy, [
         {
             key: "import",
-            value: function _import(name) {
+            value: function _import(filename) {
                 return _async_to_generator(function() {
+                    var _this_manifest_filename;
                     return _ts_generator(this, function(_state) {
                         return [
                             2,
-                            this.manifest[name]
+                            (_this_manifest_filename = this.manifest[filename]) === null || _this_manifest_filename === void 0 ? void 0 : _this_manifest_filename.brain
                         ];
                     });
                 }).call(this);
             }
         },
+        {
+            key: "resolve",
+            value: function resolve(identifier) {
+                return this.resolver.resolve(identifier);
+            }
+        },
         {
             key: "list",
             value: function list() {
@@ -190,7 +200,7 @@ var DynamicImportStrategy = /*#__PURE__*/ function() {
     _create_class(DynamicImportStrategy, [
         {
             key: "import",
-            value: function _import(name) {
+            value: function _import(filename) {
                 return _async_to_generator(function() {
                     var module, e;
                     return _ts_generator(this, function(_state) {
@@ -204,7 +214,7 @@ var DynamicImportStrategy = /*#__PURE__*/ function() {
                                 ]);
                                 return [
                                     4,
-                                    import("".concat(this.brainsDir, "/").concat(name, ".ts"))
+                                    import("".concat(this.brainsDir, "/").concat(filename, ".ts"))
                                 ];
                             case 1:
                                 module = _state.sent();
@@ -214,7 +224,7 @@ var DynamicImportStrategy = /*#__PURE__*/ function() {
                                 ];
                             case 2:
                                 e = _state.sent();
-                                console.error("Failed to import brain ".concat(name, ":"), e);
+                                console.error("Failed to import brain ".concat(filename, ":"), e);
                                 return [
                                     2,
                                     undefined
@@ -228,6 +238,20 @@ var DynamicImportStrategy = /*#__PURE__*/ function() {
                 }).call(this);
             }
         },
+        {
+            key: "resolve",
+            value: function resolve(identifier) {
+                // For dynamic imports, we can only do simple filename matching
+                return this.import(identifier).then(function(brain) {
+                    return brain ? {
+                        matchType: 'exact',
+                        brain: brain
+                    } : {
+                        matchType: 'none'
+                    };
+                }); // Type assertion needed due to async
+            }
+        },
         {
             key: "list",
             value: function list() {
@@ -245,28 +269,34 @@ export var PositronicManifest = /*#__PURE__*/ function() {
     function PositronicManifest(options) {
         _class_call_check(this, PositronicManifest);
         _define_property(this, "importStrategy", void 0);
-        if (options.staticManifest && options.brainsDir) {
-            throw new Error('Cannot provide both staticManifest and brainsDir - choose one import strategy');
+        if (options.manifest && options.brainsDir) {
+            throw new Error('Cannot provide both manifest and brainsDir - choose one import strategy');
         }
-        if (!options.staticManifest && !options.brainsDir) {
-            throw new Error('Must provide either staticManifest or brainsDir');
+        if (!options.manifest && !options.brainsDir) {
+            throw new Error('Must provide either manifest or brainsDir');
         }
-        this.importStrategy = options.staticManifest ? new StaticManifestStrategy(options.staticManifest) : new DynamicImportStrategy(options.brainsDir);
+        this.importStrategy = options.manifest ? new StaticManifestStrategy(options.manifest) : new DynamicImportStrategy(options.brainsDir);
     }
     _create_class(PositronicManifest, [
         {
             key: "import",
-            value: function _import(name) {
+            value: function _import(filename) {
                 return _async_to_generator(function() {
                     return _ts_generator(this, function(_state) {
                         return [
                             2,
-                            this.importStrategy.import(name)
+                            this.importStrategy.import(filename)
                         ];
                     });
                 }).call(this);
             }
         },
+        {
+            key: "resolve",
+            value: function resolve(identifier) {
+                return this.importStrategy.resolve(identifier);
+            }
+        },
         {
             key: "list",
             value: function list() {

package/dist/src/schedule-do.js

@@ -253,13 +253,13 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
         ]), _define_property(_this, "storage", void 0);
         _this.storage = state.storage.sql;
         // Initialize database schema
-        _this.storage.exec("\n      CREATE TABLE IF NOT EXISTS schedules (\n        id TEXT PRIMARY KEY,\n        brain_name TEXT NOT NULL,\n        cron_expression TEXT NOT NULL,\n        enabled INTEGER NOT NULL DEFAULT 1,\n        created_at INTEGER NOT NULL,\n        next_run_at INTEGER\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_schedules_brain\n      ON schedules(brain_name);\n\n      CREATE INDEX IF NOT EXISTS idx_schedules_enabled\n      ON schedules(enabled);\n\n      CREATE TABLE IF NOT EXISTS scheduled_runs (\n        id INTEGER PRIMARY KEY AUTOINCREMENT,\n        schedule_id TEXT NOT NULL,\n        brain_run_id TEXT UNIQUE,\n        status TEXT NOT NULL CHECK(status IN ('triggered', 'failed', 'complete')),\n        ran_at INTEGER NOT NULL,\n        completed_at INTEGER,\n        error TEXT,\n        FOREIGN KEY (schedule_id) REFERENCES schedules(id) ON DELETE CASCADE\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_runs_schedule\n      ON scheduled_runs(schedule_id, ran_at DESC);\n    ");
+        _this.storage.exec("\n      CREATE TABLE IF NOT EXISTS schedules (\n        id TEXT PRIMARY KEY,\n        brain_title TEXT NOT NULL,\n        cron_expression TEXT NOT NULL,\n        enabled INTEGER NOT NULL DEFAULT 1,\n        created_at INTEGER NOT NULL,\n        next_run_at INTEGER\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_schedules_brain\n      ON schedules(brain_title);\n\n      CREATE INDEX IF NOT EXISTS idx_schedules_enabled\n      ON schedules(enabled);\n\n      CREATE TABLE IF NOT EXISTS scheduled_runs (\n        id INTEGER PRIMARY KEY AUTOINCREMENT,\n        schedule_id TEXT NOT NULL,\n        brain_run_id TEXT UNIQUE,\n        status TEXT NOT NULL CHECK(status IN ('triggered', 'failed', 'complete')),\n        ran_at INTEGER NOT NULL,\n        completed_at INTEGER,\n        error TEXT,\n        FOREIGN KEY (schedule_id) REFERENCES schedules(id) ON DELETE CASCADE\n      );\n\n      CREATE INDEX IF NOT EXISTS idx_runs_schedule\n      ON scheduled_runs(schedule_id, ran_at DESC);\n    ");
         return _this;
     }
     _create_class(ScheduleDO, [
         {
             key: "createSchedule",
-            value: function createSchedule(brainName, cronExpression) {
+            value: function createSchedule(brainTitle, cronExpression) {
                 return _async_to_generator(function() {
                     var id, createdAt, alarm, cron, nextRunAt;
                     return _ts_generator(this, function(_state) {
@@ -293,12 +293,12 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                                 // Calculate next run time
                                 cron = parseCronExpression(cronExpression);
                                 nextRunAt = this.calculateNextRunTime(cron, createdAt);
-                                this.storage.exec("INSERT INTO schedules (id, brain_name, cron_expression, enabled, created_at, next_run_at)\n       VALUES (?, ?, ?, 1, ?, ?)", id, brainName, cronExpression, createdAt, nextRunAt);
+                                this.storage.exec("INSERT INTO schedules (id, brain_title, cron_expression, enabled, created_at, next_run_at)\n       VALUES (?, ?, ?, 1, ?, ?)", id, brainTitle, cronExpression, createdAt, nextRunAt);
                                 return [
                                     2,
                                     {
                                         id: id,
-                                        brainName: brainName,
+                                        brainTitle: brainTitle,
                                         cronExpression: cronExpression,
                                         enabled: true,
                                         createdAt: createdAt,
@@ -316,7 +316,7 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                 return _async_to_generator(function() {
                     var results, result;
                     return _ts_generator(this, function(_state) {
-                        results = this.storage.exec("SELECT id, brain_name, cron_expression, enabled, created_at, next_run_at\n         FROM schedules WHERE id = ?", scheduleId).toArray();
+                        results = this.storage.exec("SELECT id, brain_title, cron_expression, enabled, created_at, next_run_at\n         FROM schedules WHERE id = ?", scheduleId).toArray();
                         if (results.length === 0) {
                             return [
                                 2,
@@ -328,7 +328,7 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                             2,
                             {
                                 id: result.id,
-                                brainName: result.brain_name,
+                                brainTitle: result.brain_title,
                                 cronExpression: result.cron_expression,
                                 enabled: result.enabled === 1,
                                 createdAt: result.created_at,
@@ -408,10 +408,10 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                                 _state.sent();
                                 _state.label = 4;
                             case 4:
-                                schedules = this.storage.exec("SELECT id, brain_name, cron_expression, enabled, created_at, next_run_at\n         FROM schedules\n         ORDER BY created_at DESC").toArray().map(function(row) {
+                                schedules = this.storage.exec("SELECT id, brain_title, cron_expression, enabled, created_at, next_run_at\n         FROM schedules\n         ORDER BY created_at DESC").toArray().map(function(row) {
                                     return {
                                         id: row.id,
-                                        brainName: row.brain_name,
+                                        brainTitle: row.brain_title,
                                         cronExpression: row.cron_expression,
                                         enabled: row.enabled === 1,
                                         createdAt: row.created_at,
@@ -485,7 +485,7 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
             value: // Handle the alarm trigger - runs every minute in a perpetual cycle
             function alarm() {
                 return _async_to_generator(function() {
-                    var now, dueSchedules, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, schedule, scheduleId, brainName, cronExpression, brainRunId, error, errorMessage, cron, nextRunAt, err;
+                    var now, dueSchedules, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, schedule, scheduleId, brainTitle, cronExpression, brainRunId, error, errorMessage, cron, nextRunAt, err;
                     return _ts_generator(this, function(_state) {
                         switch(_state.label){
                             case 0:
@@ -500,7 +500,7 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                                 // checking every minute ensures we never miss a scheduled run.
                                 // Get all enabled schedules that are due
                                 now = Date.now();
-                                dueSchedules = this.storage.exec("SELECT id, brain_name, cron_expression\n           FROM schedules\n           WHERE enabled = 1 AND next_run_at <= ?", now).toArray();
+                                dueSchedules = this.storage.exec("SELECT id, brain_title, cron_expression\n           FROM schedules\n           WHERE enabled = 1 AND next_run_at <= ?", now).toArray();
                                 _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
                                 _state.label = 1;
                             case 1:
@@ -519,7 +519,7 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                                 ];
                                 schedule = _step.value;
                                 scheduleId = schedule.id;
-                                brainName = schedule.brain_name;
+                                brainTitle = schedule.brain_title;
                                 cronExpression = schedule.cron_expression;
                                 _state.label = 3;
                             case 3:
@@ -531,7 +531,7 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                                 ]);
                                 return [
                                     4,
-                                    this.triggerBrainRun(brainName)
+                                    this.triggerBrainRun(brainTitle)
                                 ];
                             case 4:
                                 brainRunId = _state.sent();
@@ -546,7 +546,7 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                                 // Record failed run
                                 errorMessage = _instanceof(error, Error) ? error.message : 'Unknown error';
                                 this.storage.exec("INSERT INTO scheduled_runs (schedule_id, status, ran_at, error)\n               VALUES (?, 'failed', ?, ?)", scheduleId, now, errorMessage);
-                                console.error("[ScheduleDO] Failed to trigger brain ".concat(brainName, ":"), error);
+                                console.error("[ScheduleDO] Failed to trigger brain ".concat(brainTitle, ":"), error);
                                 return [
                                     3,
                                     6
@@ -621,7 +621,7 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
         },
         {
             key: "triggerBrainRun",
-            value: function triggerBrainRun(brainName) {
+            value: function triggerBrainRun(brainTitle) {
                 return _async_to_generator(function() {
                     var brainRunId, namespace, doId, stub;
                     return _ts_generator(this, function(_state) {
@@ -631,10 +631,10 @@ export var ScheduleDO = /*#__PURE__*/ function(DurableObject) {
                                 namespace = this.env.BRAIN_RUNNER_DO;
                                 doId = namespace.idFromName(brainRunId);
                                 stub = namespace.get(doId);
-                                console.log("[ScheduleDO] Triggering brain run ".concat(brainName, " with id ").concat(brainRunId));
+                                console.log("[ScheduleDO] Triggering brain run ".concat(brainTitle, " with id ").concat(brainRunId));
                                 return [
                                     4,
-                                    stub.start(brainName, brainRunId)
+                                    stub.start(brainTitle, brainRunId)
                                 ];
                             case 1:
                                 _state.sent();

package/dist/types/api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAgB,MAAM,MAAM,CAAC;AAI1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,2BAA2B,CAAC;AAGpE,KAAK,QAAQ,GAAG;IACd,eAAe,EAAE,sBAAsB,CAAC,aAAa,CAAC,CAAC;IACvD,UAAU,EAAE,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC9C,WAAW,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAChD,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAmBF,QAAA,MAAM,GAAG;cAAwB,QAAQ;yCAAK,CAAC;AA+hB/C,eAAe,GAAG,CAAC"}
+{"version":3,"file":"api.d.ts","sourceRoot":"","sources":["../../src/api.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAgB,MAAM,MAAM,CAAC;AAI1C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAE1D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACjD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAY,MAAM,2BAA2B,CAAC;AAGpE,KAAK,QAAQ,GAAG;IACd,eAAe,EAAE,sBAAsB,CAAC,aAAa,CAAC,CAAC;IACvD,UAAU,EAAE,sBAAsB,CAAC,SAAS,CAAC,CAAC;IAC9C,WAAW,EAAE,sBAAsB,CAAC,UAAU,CAAC,CAAC;IAChD,gBAAgB,EAAE,QAAQ,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAmBF,QAAA,MAAM,GAAG;cAAwB,QAAQ;yCAAK,CAAC;AAupB/C,eAAe,GAAG,CAAC"}

package/dist/types/brain-resolver.d.ts

@@ -0,0 +1,32 @@
+import type { Brain } from '@positronic/core';
+export interface BrainMetadata {
+    filename: string;
+    path: string;
+    brain: Brain;
+}
+export interface BrainCandidate {
+    title: string;
+    filename: string;
+    path: string;
+    description?: string;
+}
+export interface ResolutionResult {
+    matchType: 'exact' | 'multiple' | 'none';
+    brain?: Brain;
+    candidates?: BrainCandidate[];
+}
+export declare class BrainResolver {
+    private enhancedManifest;
+    private metadataCache;
+    constructor(enhancedManifest: Record<string, BrainMetadata>);
+    resolve(identifier: string): ResolutionResult;
+    /**
+     * Get a brain by exact filename (used for backward compatibility)
+     */
+    getByFilename(filename: string): Brain | undefined;
+    /**
+     * List all available brains
+     */
+    list(): string[];
+}
+//# sourceMappingURL=brain-resolver.d.ts.map