@my-life-buddies/cli 0.24.1 → 0.25.0

package/dist/bin/preview.js

@@ -178,6 +178,495 @@ ${line}`;
   }
 };
 
+// apps/preview/src/project-inspection.ts
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, extname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { parse } from "acorn";
+var Unknown = class {
+  constructor(reason = "\u914D\u7F6E\u4F9D\u8D56\u8FD0\u884C\u65F6\u4FE1\u606F\u6216\u6682\u4E0D\u652F\u6301\u7684\u8868\u8FBE\u5F0F\u3002", textPrefix) {
+    this.reason = reason;
+    this.textPrefix = textPrefix;
+  }
+  reason;
+  textPrefix;
+};
+var Api = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+};
+var PlatformTool = class {
+  constructor(name) {
+    this.name = name;
+  }
+  name;
+};
+var Fn = class {
+  constructor(node, scope) {
+    this.node = node;
+    this.scope = scope;
+  }
+  node;
+  scope;
+};
+var Fields = class _Fields {
+  constructor(entries, optional = false) {
+    this.entries = entries;
+    this.optional = optional;
+  }
+  entries;
+  optional;
+  get(key) {
+    for (let i = this.entries.length - 1; i >= 0; i--) {
+      const entry = this.entries[i];
+      if (entry.key !== void 0) {
+        if (entry.key === key) return entry.value();
+      } else {
+        const spread = entry.value();
+        if (!(spread instanceof _Fields)) return new Unknown("\u5BF9\u8C61\u5305\u542B\u52A8\u6001\u5C55\u5F00\uFF0C\u65E0\u6CD5\u786E\u5B9A\u6700\u7EC8\u914D\u7F6E\u3002");
+        const keys = spread.keys();
+        if (!keys || keys.includes(key)) return spread.get(key);
+      }
+    }
+    return void 0;
+  }
+  keys() {
+    const keys = /* @__PURE__ */ new Set();
+    for (const entry of this.entries) {
+      if (entry.key !== void 0) keys.add(entry.key);
+      else {
+        const spread = entry.value(), nested = spread instanceof _Fields ? spread.keys() : void 0;
+        if (!nested) return void 0;
+        nested.forEach((key) => keys.add(key));
+      }
+    }
+    return [...keys];
+  }
+};
+var fields = (data) => new Fields(Object.entries(data).map(([key, value]) => ({ key, value: () => value })));
+var unknown = () => new Unknown();
+var isPrimitive = (value) => value === null || value === void 0 || ["string", "number", "boolean"].includes(typeof value);
+var Scope = class {
+  constructor(file, parent) {
+    this.file = file;
+    this.parent = parent;
+  }
+  file;
+  parent;
+  bindings = /* @__PURE__ */ new Map();
+  mutable = /* @__PURE__ */ new Set();
+  get(name) {
+    if (this.mutable.has(name)) return new Unknown("\u914D\u7F6E\u5305\u542B\u53EF\u53D8\u503C\u6216\u540E\u7EED\u4FEE\u6539\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+    const binding = this.bindings.get(name);
+    return binding ? binding() : this.parent?.get(name) ?? new Unknown();
+  }
+};
+var within = (root, file) => {
+  const path = relative(root, file);
+  return !isAbsolute(path) && path !== ".." && !path.startsWith(`..${sep}`);
+};
+var keyOf = (node, computed = false) => !computed && node.type === "Identifier" ? node.name : node.type === "Literal" && ["string", "number"].includes(typeof node.value) ? String(node.value) : void 0;
+var unwrap = (node) => node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration" ? node.declaration ?? node : node;
+function walk(node, visit, functions = false) {
+  visit(node);
+  if (!functions && /^(?:Function|ArrowFunction)/u.test(node.type)) return;
+  for (const value of Object.values(node)) {
+    if (Array.isArray(value)) {
+      for (const child of value) if (child?.type) walk(child, visit, functions);
+    } else if (value && typeof value === "object" && value.type) walk(value, visit, functions);
+  }
+}
+var Reader = class {
+  sources = /* @__PURE__ */ new Map();
+  dependencies = /* @__PURE__ */ new Map();
+  root;
+  runtimeRoot;
+  bytes = 0;
+  steps = 0;
+  depth = 0;
+  constructor(root) {
+    this.root = realpathSync(root);
+  }
+  tick() {
+    if (++this.steps > 5e4) throw new Error("inspection budget");
+  }
+  lazy(read) {
+    let state = 0, result;
+    return () => {
+      this.tick();
+      if (state === 1) return new Unknown("\u914D\u7F6E\u5B58\u5728\u5FAA\u73AF\u5F15\u7528\u3002");
+      if (state === 2) return result;
+      state = 1;
+      try {
+        result = read();
+      } catch {
+        result = new Unknown("\u914D\u7F6E\u65E0\u6CD5\u9759\u6001\u8BFB\u53D6\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+      }
+      state = 2;
+      return result;
+    };
+  }
+  source(path) {
+    if (!this.dependencies.has(path)) this.dependencies.set(path, fingerprint(path));
+    const file = realpathSync(path);
+    const inRuntime = this.runtimeRoot && within(this.runtimeRoot, file);
+    if ((!within(this.root, file) || relative(this.root, file).split(sep).includes("node_modules")) && !inRuntime) throw new Error("outside project");
+    if (![".js", ".mjs", ".cjs"].includes(extname(file))) throw new Error("unsupported source");
+    const existing = this.sources.get(file);
+    if (existing) return existing;
+    const size = statSync(file).size;
+    if (this.sources.size >= 80 || size > 512e3 || (this.bytes += size) > 3e6) throw new Error("inspection size");
+    const tree = parse(readFileSync(file, "utf8"), { ecmaVersion: "latest", sourceType: "module" });
+    const scope = new Scope(file), exports = /* @__PURE__ */ new Map();
+    const result = { tree, scope, exports };
+    this.sources.set(file, result);
+    this.bind(tree.body, scope);
+    for (const statement of tree.body) {
+      if (statement.type === "ImportDeclaration") {
+        for (const specifier of statement.specifiers) {
+          const name = specifier.type === "ImportDefaultSpecifier" ? "default" : specifier.type === "ImportNamespaceSpecifier" ? "*" : keyOf(specifier.imported);
+          scope.bindings.set(specifier.local.name, this.lazy(() => this.imported(scope.file, statement.source.value, name ?? "")));
+        }
+      } else if (statement.type === "ExportDefaultDeclaration") {
+        exports.set("default", this.lazy(() => this.expression(statement.declaration, scope)));
+      } else if (statement.type === "ExportNamedDeclaration") {
+        const declaration = statement.declaration;
+        if (declaration?.type === "FunctionDeclaration") exports.set(declaration.id.name, () => scope.get(declaration.id.name));
+        if (declaration?.type === "VariableDeclaration") {
+          for (const item of declaration.declarations) if (item.id.type === "Identifier") exports.set(item.id.name, () => scope.get(item.id.name));
+        }
+        for (const specifier of statement.specifiers) {
+          const name = keyOf(specifier.exported), local = keyOf(specifier.local);
+          exports.set(name, this.lazy(() => statement.source ? this.imported(file, statement.source.value, local) : scope.get(local)));
+        }
+      }
+    }
+    return result;
+  }
+  imported(file, specifier, name) {
+    if (["typebox", "@sinclair/typebox"].includes(specifier) && name === "Type") return new Api("Type");
+    if (specifier === "@my-life-buddies/buddy-runtime" && name === "BuddyServer") return new Api("BuddyServer");
+    if (!specifier.startsWith("./") && !specifier.startsWith("../")) return new Unknown("\u914D\u7F6E\u6765\u81EA\u5916\u90E8\u4F9D\u8D56\uFF0C\u65E0\u6CD5\u9759\u6001\u786E\u5B9A\u3002");
+    const target = resolve(dirname(file), specifier);
+    for (const candidate of [target, `${target}.mjs`, `${target}.js`, join(target, "index.js")]) {
+      try {
+        const source = this.source(candidate);
+        return name === "*" ? new Fields([...source.exports].map(([key, value]) => ({ key, value }))) : source.exports.get(name)?.() ?? unknown();
+      } catch {
+      }
+    }
+    return new Unknown("\u5F15\u7528\u7684\u672C\u5730\u6E90\u6587\u4EF6\u65E0\u6CD5\u8BFB\u53D6\u6216\u4E0D\u652F\u6301\u9759\u6001\u5206\u6790\u3002");
+  }
+  bind(statements, scope) {
+    const aliases = /* @__PURE__ */ new Map();
+    const localValues = /* @__PURE__ */ new Set();
+    for (const item of statements) {
+      const statement = unwrap(item);
+      if (statement.type === "FunctionDeclaration" && statement.id) scope.bindings.set(statement.id.name, () => new Fn(statement, scope));
+      if (statement.type === "VariableDeclaration") for (const declaration of statement.declarations) {
+        this.pattern(declaration.id, this.lazy(() => this.expression(declaration.init, scope)), scope);
+        if (declaration.id.type === "Identifier") localValues.add(declaration.id.name);
+        let source = declaration.init;
+        while (source?.type === "MemberExpression") source = source.object;
+        if (declaration.id.type === "Identifier" && source?.type === "Identifier") aliases.set(declaration.id.name, source.name);
+        if (statement.kind !== "const") walk(declaration.id, (node) => {
+          if (node.type === "Identifier") scope.mutable.add(node.name);
+        });
+      }
+    }
+    for (const item of statements) walk(item, (node) => {
+      if (node.type === "ExpressionStatement" && node.expression.type === "CallExpression") {
+        for (const argument of node.expression.arguments) {
+          let root = argument;
+          while (root.type === "MemberExpression") root = root.object;
+          if (root.type === "Identifier" && localValues.has(root.name)) scope.mutable.add(root.name);
+        }
+      }
+      let target;
+      if (node.type === "AssignmentExpression") target = node.left;
+      if (node.type === "UpdateExpression") target = node.argument;
+      if (node.type === "CallExpression" && node.callee.type === "MemberExpression" && ["push", "pop", "shift", "unshift", "splice", "sort", "reverse", "fill", "copyWithin", "assign", "defineProperty"].includes(keyOf(node.callee.property, node.callee.computed) ?? "")) target = node.callee.object.name === "Object" ? node.arguments[0] : node.callee.object;
+      while (target?.type === "MemberExpression") target = target.object;
+      if (target?.type === "Identifier") scope.mutable.add(target.name);
+    });
+    for (let changed = true; changed; ) {
+      changed = false;
+      for (const [alias, original] of aliases) if (scope.mutable.has(alias) && !scope.mutable.has(original)) {
+        scope.mutable.add(original);
+        changed = true;
+      }
+    }
+  }
+  pattern(pattern, value, scope) {
+    if (pattern.type === "Identifier") scope.bindings.set(pattern.name, value);
+    else if (pattern.type === "ObjectPattern") for (const property of pattern.properties) {
+      if (property.type !== "Property") continue;
+      const key = keyOf(property.key, property.computed);
+      this.pattern(property.value, this.lazy(() => key === void 0 ? unknown() : this.member(value(), key)), scope);
+    }
+    else if (pattern.type === "ArrayPattern") pattern.elements.forEach((item, index) => {
+      if (item) this.pattern(item, this.lazy(() => this.member(value(), String(index))), scope);
+    });
+    else if (pattern.type === "AssignmentPattern") this.pattern(pattern.left, this.lazy(() => {
+      const item = value();
+      return item === void 0 ? this.expression(pattern.right, scope) : item;
+    }), scope);
+  }
+  functionScope(fn, args) {
+    const scope = new Scope(fn.scope.file, fn.scope);
+    fn.node.params.forEach((param, index) => this.pattern(param, () => args[index], scope));
+    if (fn.node.body.type === "BlockStatement") this.bind(fn.node.body.body, scope);
+    return scope;
+  }
+  call(fn, args) {
+    if (fn instanceof Api && fn.name.startsWith("Type.")) return this.schema(fn.name.slice(5), args);
+    if (!(fn instanceof Fn)) return new Unknown("\u51FD\u6570\u8C03\u7528\u7684\u7ED3\u679C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+    if (++this.depth > 32) {
+      this.depth--;
+      return unknown();
+    }
+    try {
+      const scope = this.functionScope(fn, args), body = fn.node.body;
+      if (body.type !== "BlockStatement") return this.expression(body, scope);
+      for (const statement of body.body) {
+        if (statement.type === "ReturnStatement") return this.expression(statement.argument, scope);
+        let conditionalReturn = false;
+        walk(statement, (node) => {
+          if (node.type === "ReturnStatement") conditionalReturn = true;
+        });
+        if (conditionalReturn) return new Unknown("\u914D\u7F6E\u5DE5\u5382\u5305\u542B\u6761\u4EF6\u8FD4\u56DE\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+      }
+      return unknown();
+    } finally {
+      this.depth--;
+    }
+  }
+  member(object3, key) {
+    if (object3 instanceof Fields) return object3.get(key);
+    if (object3 instanceof Api) return object3.name === "conversation.tools" ? new PlatformTool(key) : new Api(`${object3.name}.${key}`);
+    if (Array.isArray(object3)) return key === "length" ? object3.length : /^\d+$/u.test(key) ? object3[Number(key)] : unknown();
+    return object3 instanceof Unknown ? object3 : unknown();
+  }
+  expression(node, scope) {
+    this.tick();
+    if (!node) return void 0;
+    switch (node.type) {
+      case "Literal":
+        return node.regex || node.bigint ? unknown() : node.value;
+      case "Identifier":
+        return node.name === "undefined" ? void 0 : scope.get(node.name);
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        return new Fn(node, scope);
+      case "AwaitExpression":
+      case "ChainExpression":
+        return this.expression(node.argument ?? node.expression, scope);
+      case "ObjectExpression":
+        return new Fields(node.properties.map((property) => ({ key: property.type === "SpreadElement" ? void 0 : keyOf(property.key, property.computed), value: this.lazy(() => property.type === "SpreadElement" ? this.expression(property.argument, scope) : property.kind === "get" || property.kind === "set" ? unknown() : property.computed && keyOf(property.key, true) === void 0 ? unknown() : this.expression(property.value, scope)) })));
+      case "ArrayExpression": {
+        const values = [];
+        for (const element of node.elements) {
+          if (element?.type === "SpreadElement") {
+            const value = this.expression(element.argument, scope);
+            values.push(...Array.isArray(value) ? value : [value instanceof Unknown ? value : unknown()]);
+          } else values.push(this.expression(element, scope));
+        }
+        return values;
+      }
+      case "MemberExpression": {
+        const key = node.computed ? this.expression(node.property, scope) : node.property.name;
+        return typeof key === "string" || typeof key === "number" ? this.member(this.expression(node.object, scope), String(key)) : unknown();
+      }
+      case "CallExpression": {
+        if (node.callee.type === "MemberExpression" && keyOf(node.callee.property, node.callee.computed) === "map") {
+          const values = this.expression(node.callee.object, scope), fn = this.expression(node.arguments[0], scope);
+          return Array.isArray(values) ? values.map((value, index) => this.call(fn, [value, index])) : unknown();
+        }
+        return this.call(this.expression(node.callee, scope), node.arguments.map((arg) => this.expression(arg, scope)));
+      }
+      case "ConditionalExpression": {
+        const test = this.expression(node.test, scope);
+        return isPrimitive(test) ? this.expression(test ? node.consequent : node.alternate, scope) : new Unknown("\u914D\u7F6E\u6839\u636E\u73AF\u5883\u6216\u4F1A\u8BDD\u52A8\u6001\u9009\u62E9\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002");
+      }
+      case "LogicalExpression": {
+        const left = this.expression(node.left, scope);
+        if (left instanceof Unknown) return left;
+        if (node.operator === "??") return left == null ? this.expression(node.right, scope) : left;
+        return (node.operator === "&&" ? Boolean(left) : !left) ? this.expression(node.right, scope) : left;
+      }
+      case "BinaryExpression": {
+        const left = this.expression(node.left, scope), right = this.expression(node.right, scope);
+        if (!isPrimitive(left) || !isPrimitive(right)) return node.operator === "+" && typeof left === "string" ? new Unknown("\u63CF\u8FF0\u5305\u542B\u52A8\u6001\u5185\u5BB9\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002", left) : unknown();
+        if (node.operator === "+" && (typeof left === "string" || typeof right === "string")) return `${left}${right}`;
+        if (node.operator === "===") return left === right;
+        if (node.operator === "!==") return left !== right;
+        return unknown();
+      }
+      case "UnaryExpression": {
+        const value = this.expression(node.argument, scope);
+        if (!isPrimitive(value)) return unknown();
+        return node.operator === "!" ? !value : node.operator === "-" && typeof value === "number" ? -value : unknown();
+      }
+      case "TemplateLiteral": {
+        let result = "";
+        for (let i = 0; i < node.quasis.length; i++) {
+          result += node.quasis[i].value.cooked;
+          if (i < node.expressions.length) {
+            const value = this.expression(node.expressions[i], scope);
+            if (!isPrimitive(value)) return new Unknown("\u63CF\u8FF0\u5305\u542B\u52A8\u6001\u5185\u5BB9\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002", result);
+            result += String(value);
+          }
+        }
+        return result;
+      }
+      default:
+        return unknown();
+    }
+  }
+  schema(name, args) {
+    const first = args[0];
+    if (name === "Optional") return first instanceof Fields ? new Fields(first.entries, true) : unknown();
+    const scalar = { String: "string", Number: "number", Integer: "integer", Boolean: "boolean", Null: "null" };
+    let schema, options;
+    if (scalar[name]) {
+      schema = fields({ type: scalar[name] });
+      options = first;
+    } else if (name === "Object" && first instanceof Fields) {
+      const keys = first.keys();
+      if (!keys) return unknown();
+      const required = [];
+      for (const key of keys) {
+        const value = first.get(key);
+        if (!(value instanceof Fields)) return unknown();
+        if (!value.optional) required.push(key);
+      }
+      schema = fields({ type: "object", properties: first, ...required.length ? { required } : {} });
+      options = args[1];
+    } else if (name === "Array") {
+      schema = fields({ type: "array", items: first });
+      options = args[1];
+    } else if (name === "Literal" && isPrimitive(first) && first !== void 0) {
+      schema = fields({ const: first, type: first === null ? "null" : typeof first });
+      options = args[1];
+    } else if (name === "Union" && Array.isArray(first)) {
+      schema = first.length === 1 && first[0] instanceof Fields ? first[0] : fields({ anyOf: first });
+      options = args[1];
+    } else if (name === "Any" || name === "Unknown") {
+      schema = fields({});
+      options = first;
+    } else return new Unknown("\u53C2\u6570\u4F7F\u7528\u6682\u4E0D\u652F\u6301\u7684 Schema \u6784\u9020\u65B9\u6CD5\u3002");
+    return options === void 0 ? schema : options instanceof Fields ? new Fields([...schema.entries, { value: () => options }]) : unknown();
+  }
+  json(value, depth = 0) {
+    this.tick();
+    if (depth > 30) throw new Error("schema depth");
+    if (isPrimitive(value)) return value;
+    if (Array.isArray(value)) return value.map((item) => this.json(item, depth + 1));
+    if (value instanceof Fields) {
+      const keys = value.keys();
+      if (!keys) throw new Error("dynamic schema");
+      return Object.fromEntries(keys.map((key) => [key, this.json(value.get(key), depth + 1)]));
+    }
+    throw new Error("dynamic schema");
+  }
+  runtime() {
+    try {
+      const path = createRequire(join(this.root, "package.json")).resolve("@my-life-buddies/buddy-runtime/package.json");
+      this.dependencies.set(path, fingerprint(path));
+      const manifest = JSON.parse(readFileSync(path, "utf8"));
+      if (manifest.name !== "@my-life-buddies/buddy-runtime") throw new Error("runtime package");
+      this.runtimeRoot = realpathSync(dirname(path));
+      const source = this.source(join(this.runtimeRoot, "dist/conversation/agent.js"));
+      const factory = source.exports.get("createAgent")?.();
+      const scope = factory instanceof Fn ? this.functionScope(factory, [unknown()]) : void 0;
+      return { tools: scope?.get("platformTools") ?? unknown(), builtin: source.exports.has("builtinTools") };
+    } catch {
+      return { tools: unknown(), builtin: true };
+    }
+  }
+  inspect() {
+    const source = this.source(join(this.root, "start.mjs"));
+    const starts = [];
+    walk(source.tree, (node) => {
+      if (node.type !== "CallExpression" || node.callee.type !== "MemberExpression") return;
+      if (keyOf(node.callee.property, node.callee.computed) !== "start") return;
+      const owner = this.expression(node.callee.object, source.scope);
+      if (owner instanceof Api && owner.name === "BuddyServer") starts.push(node);
+    });
+    const conversation = new Fields([{ value: () => new Unknown("\u914D\u7F6E\u4F9D\u8D56\u5F53\u524D\u4F1A\u8BDD\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002") }, { key: "tools", value: () => new Api("conversation.tools") }]);
+    const options = starts.length === 1 ? this.call(this.expression(starts[0].arguments[0], source.scope), [conversation]) : new Unknown("\u672A\u8BC6\u522B\u5230\u552F\u4E00\u7684 BuddyServer.start \u5DE5\u5382\u5165\u53E3\u3002");
+    const initial = this.member(options, "initialState"), model = this.member(initial, "model");
+    const toolValues = this.member(initial, "tools"), runtime = this.runtime();
+    const tools = [], unresolved = [];
+    const list = toolValues === void 0 && initial instanceof Fields ? [] : Array.isArray(toolValues) ? toolValues : [toolValues];
+    let payloadSize = 0;
+    for (const item of list) {
+      if (tools.length + unresolved.length >= 128 || payloadSize > 25e4) {
+        unresolved.push({ reason: "\u914D\u7F6E\u6E05\u5355\u8D85\u51FA\u9759\u6001\u5C55\u793A\u4E0A\u9650\uFF0C\u5176\u4F59\u5DE5\u5177\u8BF7\u5728\u6A21\u578B\u8BF7\u6C42\u4E2D\u67E5\u770B\u3002" });
+        break;
+      }
+      const origin = item instanceof PlatformTool ? "platform" : "custom";
+      const value = item instanceof PlatformTool ? this.member(runtime.tools, item.name) : item;
+      if (item instanceof PlatformTool && value === void 0) {
+        unresolved.push({ name: item.name, reason: "\u5F53\u524D\u5B89\u88C5\u7684 Runtime \u672A\u63D0\u4F9B\u6B64\u5E73\u53F0\u5DE5\u5177\uFF0C\u8BF7\u68C0\u67E5\u6CE8\u518C\u914D\u7F6E\u3002" });
+        continue;
+      }
+      const name = item instanceof PlatformTool ? item.name : this.member(value, "name");
+      if (typeof name !== "string" || !/^[\w.-]{1,128}$/u.test(name)) {
+        unresolved.push({ reason: value instanceof Unknown ? value.reason : "\u5DE5\u5177\u540D\u79F0\u6216\u6CE8\u518C\u5173\u7CFB\u65E0\u6CD5\u9759\u6001\u786E\u5B9A\u3002" });
+        continue;
+      }
+      const description = this.member(value, "description"), parameters = this.member(value, "parameters");
+      let schema;
+      try {
+        const json2 = this.json(parameters);
+        if (json2 && typeof json2 === "object" && !Array.isArray(json2) && JSON.stringify(json2).length <= 32768) schema = json2;
+      } catch {
+      }
+      const reason = [typeof description !== "string" ? description instanceof Unknown && description.textPrefix ? "\u63CF\u8FF0\u542B\u52A8\u6001\u5185\u5BB9\uFF0C\u5F53\u524D\u4EC5\u5C55\u793A\u53EF\u8BFB\u53D6\u90E8\u5206\u3002" : "\u5DE5\u5177\u63CF\u8FF0\u5C1A\u672A\u9759\u6001\u8BFB\u53D6\u3002" : "", !schema ? "\u53C2\u6570\u5B9A\u4E49\u5C1A\u672A\u9759\u6001\u8BFB\u53D6\u3002" : ""].join("");
+      const descriptionText = typeof description === "string" ? description : description instanceof Unknown ? description.textPrefix : void 0;
+      const tool = { name, origin, ...descriptionText ? { description: descriptionText.slice(0, 4096) } : {}, ...schema ? { parameters: schema } : {}, ...reason ? { reason } : {} };
+      payloadSize += Buffer.byteLength(JSON.stringify(tool));
+      tools.push(tool);
+    }
+    if (runtime.builtin) unresolved.push({ name: "Runtime \u5185\u7F6E\u5DE5\u5177", reason: "Runtime \u53EF\u80FD\u6309\u6A21\u578B\u80FD\u529B\u8FFD\u52A0\u5DE5\u5177\uFF1B\u662F\u5426\u542F\u7528\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\uFF0C\u53EF\u5728\u6A21\u578B\u8BF7\u6C42\u4E2D\u67E5\u770B\u3002" });
+    const seen = /* @__PURE__ */ new Set();
+    for (const tool of tools) {
+      if (seen.has(tool.name)) unresolved.push({ name: tool.name, reason: "\u6CE8\u518C\u5217\u8868\u4E2D\u5B58\u5728\u540C\u540D\u5DE5\u5177\uFF0C\u8BF7\u68C0\u67E5\u5DE5\u7A0B\u914D\u7F6E\u3002" });
+      seen.add(tool.name);
+    }
+    return { status: unresolved.length || tools.some((tool) => tool.reason) ? "partial" : "complete", model: typeof model === "string" && model.length > 0 && model.length <= 128 ? { status: "known", value: model } : { status: "dynamic", reason: model instanceof Unknown ? model.reason : "\u6A21\u578B\u914D\u7F6E\u65E0\u6CD5\u9759\u6001\u786E\u5B9A\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002" }, tools, unresolved };
+  }
+};
+var fingerprint = (path) => {
+  try {
+    const stat = statSync(path);
+    return `${realpathSync(path)}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
+  } catch {
+    return "missing";
+  }
+};
+function createProjectInspector(projectRoot) {
+  let cached;
+  let files = /* @__PURE__ */ new Map();
+  return async () => {
+    if (cached && [...files].every(([path, stamp]) => fingerprint(path) === stamp)) return cached;
+    let reader;
+    try {
+      reader = new Reader(projectRoot);
+      cached = reader.inspect();
+    } catch {
+      cached = { status: "partial", model: { status: "dynamic", reason: "\u5DE5\u7A0B\u5165\u53E3\u65E0\u6CD5\u9759\u6001\u8BFB\u53D6\uFF0C\u9700\u8FD0\u884C\u65F6\u786E\u8BA4\u3002" }, tools: [], unresolved: [{ reason: "\u5DE5\u5177\u6CE8\u518C\u5173\u7CFB\u5C1A\u672A\u8BFB\u53D6\uFF1B\u8BF7\u786E\u8BA4\u5165\u53E3\u53CA\u5F15\u7528\u6587\u4EF6\u5B58\u5728\u4E14\u8BED\u6CD5\u6709\u6548\u3002" }] };
+    }
+    files = new Map([join(projectRoot, "start.mjs"), join(projectRoot, "node_modules/@my-life-buddies/buddy-runtime/package.json")].map((path) => [path, fingerprint(path)]));
+    for (const [path, stamp] of reader?.dependencies ?? []) files.set(path, stamp);
+    return cached;
+  };
+}
+
 // apps/preview/src/controller.ts
 var TERMINAL_RUN_STATUSES = /* @__PURE__ */ new Set(["completed", "failed", "cancelled"]);
 function publicFailure(cause) {
@@ -193,6 +682,8 @@ var PreviewController = class {
   #readConfig;
   #readBuddyDetails;
   #now;
+  #readInspection;
+  #inspectionPromise;
   #listeners = /* @__PURE__ */ new Set();
   #simulatorListeners = /* @__PURE__ */ new Set();
   #runs = /* @__PURE__ */ new Map();
@@ -225,6 +716,7 @@ var PreviewController = class {
     this.#readConfig = options.readConfig ?? ((root) => readBuddyConfig(root));
     this.#readBuddyDetails = options.readBuddyDetails;
     this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.#readInspection = options.readInspection ?? createProjectInspector(options.projectRoot);
   }
   get projectRoot() {
     return this.#projectRoot;
@@ -232,6 +724,18 @@ var PreviewController = class {
   state() {
     return this.#state;
   }
+  async refreshInspection() {
+    if (this.#closed) return;
+    if (this.#inspectionPromise) return this.#inspectionPromise;
+    this.#inspectionPromise = this.#readInspection().then((inspection) => {
+      if (!this.#closed && JSON.stringify(inspection) !== JSON.stringify(this.#state.inspection)) {
+        this.#setState({ ...this.#state, inspection });
+      }
+    }).finally(() => {
+      this.#inspectionPromise = void 0;
+    });
+    return this.#inspectionPromise;
+  }
   async project() {
     return this.#readConfig(this.#projectRoot);
   }
@@ -275,6 +779,7 @@ var PreviewController = class {
         }
         this.#record({ channel: "dev", type: `dev.${phase}`, summary: phase === "reloading" ? "\u672C\u5730\u6587\u4EF6\u5DF2\u4FEE\u6539\uFF0C\u6B63\u5728\u91CD\u8F7D\uFF1B\u5F53\u524D\u56DE\u590D\u53EF\u80FD\u4E2D\u65AD" : phase === "reload_failed" ? error?.message ?? "\u91CD\u8F7D\u5931\u8D25\uFF0C\u4FEE\u6B63\u6587\u4EF6\u540E\u81EA\u52A8\u91CD\u8BD5" : "\u91CD\u8F7D\u5B8C\u6210\uFF0CDEV \u5DF2\u5C31\u7EEA" });
         this.#setState({ phase, ready: this.#state.ready, ...error ? { error } : {} });
+        void this.refreshInspection();
       },
       onLog: ({ source, text: text2 }) => {
         if (controller.signal.aborted) return;
@@ -835,7 +1340,7 @@ var PreviewController = class {
     if (this.#events.length > 300) this.#events.splice(0, this.#events.length - 300);
   }
   #setState(next) {
-    this.#state = Object.freeze({ ...next, revision: this.#state.revision + 1 });
+    this.#state = Object.freeze({ ...this.#state.inspection ? { inspection: this.#state.inspection } : {}, ...next, revision: this.#state.revision + 1 });
     for (const listener of this.#listeners) {
       try {
         listener(this.#state);
@@ -848,54 +1353,56 @@ var PreviewController = class {
 
 // apps/preview/src/server.ts
 import { randomBytes, timingSafeEqual } from "node:crypto";
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { createServer } from "node:http";
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 import QRCode from "qrcode";
 var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["127.0.0.1", "::1", "localhost"]);
 var SESSION_COOKIE_PREFIX = "buddy_preview_session";
-var require2 = createRequire(import.meta.url);
+var require2 = createRequire2(import.meta.url);
 var BRAND_ICON = Buffer.from(
-  readFileSync(new URL("../web/assets/developer-platform-icon.png.base64", import.meta.url), "utf8").trim(),
+  readFileSync2(new URL("../web/assets/developer-platform-icon.png.base64", import.meta.url), "utf8").trim(),
   "base64"
 );
 var WEB_ASSETS = Object.freeze(/* @__PURE__ */ new Map([
   ["/", {
     contentType: "text/html; charset=utf-8",
-    body: readFileSync(new URL("../web/index.html", import.meta.url))
+    body: readFileSync2(new URL("../web/index.html", import.meta.url))
   }],
   ["/assets/app.css", {
     contentType: "text/css; charset=utf-8",
-    body: readFileSync(new URL("../web/app.css", import.meta.url))
+    body: readFileSync2(new URL("../web/app.css", import.meta.url))
   }],
   ["/assets/tokens.css", {
     contentType: "text/css; charset=utf-8",
-    body: readFileSync(new URL("../web/tokens.css", import.meta.url))
+    body: readFileSync2(new URL("../web/tokens.css", import.meta.url))
   }],
   ["/assets/brand.css", {
     contentType: "text/css; charset=utf-8",
-    body: readFileSync(new URL("../web/brand.css", import.meta.url))
+    body: readFileSync2(new URL("../web/brand.css", import.meta.url))
   }],
-  ["/assets/widgets.js", { contentType: "text/javascript; charset=utf-8", body: readFileSync(new URL("../web/widgets.js", import.meta.url)) }],
-  ["/assets/widgets.css", { contentType: "text/css; charset=utf-8", body: readFileSync(new URL("../web/widgets.css", import.meta.url)) }],
+  ["/assets/widgets.js", { contentType: "text/javascript; charset=utf-8", body: readFileSync2(new URL("../web/widgets.js", import.meta.url)) }],
+  ["/assets/widgets.css", { contentType: "text/css; charset=utf-8", body: readFileSync2(new URL("../web/widgets.css", import.meta.url)) }],
   ["/assets/app.js", {
     contentType: "text/javascript; charset=utf-8",
-    body: readFileSync(new URL("../web/app.js", import.meta.url))
+    body: readFileSync2(new URL("../web/app.js", import.meta.url))
   }],
-  ["/assets/diagnostics.js", { contentType: "text/javascript; charset=utf-8", body: readFileSync(new URL("../web/diagnostics.js", import.meta.url)) }],
+  ["/assets/diagnostics.js", { contentType: "text/javascript; charset=utf-8", body: readFileSync2(new URL("../web/diagnostics.js", import.meta.url)) }],
+  ["/assets/tool-inventory.js", { contentType: "text/javascript; charset=utf-8", body: readFileSync2(new URL("../web/tool-inventory.js", import.meta.url)) }],
+  ["/assets/chat-markdown.js", { contentType: "text/javascript; charset=utf-8", body: readFileSync2(new URL("../web/chat-markdown.js", import.meta.url)) }],
   ["/assets/developer-platform-icon.png", {
     contentType: "image/png",
     body: BRAND_ICON
   }],
   ["/assets/iphone-16-max.js", {
     contentType: "text/javascript; charset=utf-8",
-    body: readFileSync(require2.resolve("@sneas/telephone/iphone-16-max.js"))
+    body: readFileSync2(require2.resolve("@sneas/telephone/iphone-16-max.js"))
   }]
 ]));
 function closeServer(server) {
   if (!server.listening) return Promise.resolve();
-  return new Promise((resolve, reject) => {
-    server.close((error) => error ? reject(error) : resolve());
+  return new Promise((resolve2, reject) => {
+    server.close((error) => error ? reject(error) : resolve2());
   });
 }
 function writeHeaders(response) {
@@ -967,7 +1474,7 @@ function widgetDocument(response, html, render, state = "ready", status = 200) {
   response.setHeader("Content-Security-Policy", "sandbox allow-scripts; default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data:; connect-src 'none'; frame-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'self'");
   response.setHeader("Content-Type", "text/html; charset=utf-8");
   if (validWidgetRender(render)) {
-    const script = state === "ready" ? readFileSync(new URL("../web/widget-document.js", import.meta.url), "utf8").replace("__WIDGET_RENDER__", JSON.stringify(render)) : `window.addEventListener('load',()=>parent.postMessage({channel:'buddy-widget-document',render:${JSON.stringify(render)},state:'error'},'*'),{once:true})`;
+    const script = state === "ready" ? readFileSync2(new URL("../web/widget-document.js", import.meta.url), "utf8").replace("__WIDGET_RENDER__", JSON.stringify(render)) : `window.addEventListener('load',()=>parent.postMessage({channel:'buddy-widget-document',render:${JSON.stringify(render)},state:'error'},'*'),{once:true})`;
     const signal = `<script>${script}</script>`;
     if (/<!doctype[^>]*>/iu.test(html)) html = html.replace(/<!doctype[^>]*>/iu, (match) => match + signal);
     else html = signal + html;
@@ -1082,12 +1589,14 @@ data: ${JSON.stringify(value)}
     }
     if (request.method === "GET" && url.pathname === "/api/project") {
       try {
-        return json(response, 200, { project: publicProject(await options.controller.project()) });
+        await options.controller.refreshInspection();
+        return json(response, 200, { project: { ...publicProject(await options.controller.project()), inspection: options.controller.state().inspection } });
       } catch {
         return apiError(response, 422, "PROJECT_CONFIG_INVALID", "\u9879\u76EE\u914D\u7F6E\u65E0\u6CD5\u8BFB\u53D6\u6216\u6821\u9A8C\u5931\u8D25");
       }
     }
     if (request.method === "GET" && url.pathname === "/api/dev") {
+      await options.controller.refreshInspection();
       return json(response, 200, { state: options.controller.state() });
     }
     if (request.method === "GET" && url.pathname === "/api/buddy") {
@@ -1248,11 +1757,11 @@ data: ${JSON.stringify({
     return apiError(response, 404, "NOT_FOUND", "\u63A5\u53E3\u4E0D\u5B58\u5728");
   });
   try {
-    await new Promise((resolve, reject) => {
+    await new Promise((resolve2, reject) => {
       server.once("error", reject);
       server.listen(port, host, () => {
         server.off("error", reject);
-        resolve();
+        resolve2();
       });
     });
     const address = server.address();
@@ -1515,7 +2024,7 @@ async function mlbAppCommand(url, token, method, params, options = {}) {
   if (options.signal?.aborted) throw options.signal.reason;
   const requestId = randomUUID2();
   const socket = appSocket(url, token);
-  return await new Promise((resolve, reject) => {
+  return await new Promise((resolve2, reject) => {
     let settled = false;
     let ready = false;
     let sent = false;
@@ -1528,7 +2037,7 @@ async function mlbAppCommand(url, token, method, params, options = {}) {
       if (settled) return;
       settled = true;
       cleanup();
-      resolve(value);
+      resolve2(value);
     };
     const fail = (cause) => {
       if (settled) return;
@@ -1658,8 +2167,8 @@ async function* mlbAppEvents(url, token, options = {}) {
         queuedBytes -= item.bytes;
         yield item.frame;
       } else {
-        await new Promise((resolve) => {
-          wake = resolve;
+        await new Promise((resolve2) => {
+          wake = resolve2;
         });
         wake = void 0;
       }
@@ -1808,14 +2317,14 @@ function localReceipt(prefix, value) {
 }
 function waitForRetry(milliseconds, signal) {
   if (signal?.aborted) return Promise.reject(signal.reason);
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const abort = () => {
       clearTimeout(timer);
       reject(signal?.reason);
     };
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", abort);
-      resolve();
+      resolve2();
     }, milliseconds);
     signal?.addEventListener("abort", abort, { once: true });
   });