@opencode-ai/core 0.0.0-dev-17471

package/dist/chunks/location-mutation-ayz2m2ag.js

@@ -0,0 +1,179 @@
+import {
+  exports_skill_file
+} from "./location-mutation-ae05h9nh.js";
+import {
+  exports_discovery
+} from "./location-mutation-a65h300v.js";
+import {
+  exports_skill
+} from "./location-mutation-js0qxxzx.js";
+import {
+  exports_config
+} from "./location-mutation-qvf5nvg0.js";
+import {
+  exports_watcher
+} from "./location-mutation-k6vwd7kr.js";
+import {
+  exports_location
+} from "./location-mutation-57ntp81p.js";
+import {
+  AbsolutePath
+} from "./location-mutation-j07kk359.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/config/plugin/skill.ts
+var exports_skill2 = {};
+__export(exports_skill2, {
+  Plugin: () => Plugin,
+  ConfigSkillPlugin: () => exports_skill2
+});
+import { define } from "@opencode-ai/plugin/effect/plugin";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+import { Global } from "@opencode-ai/util/global";
+import path from "path";
+import { Effect, FiberMap, PubSub, Semaphore, Stream } from "effect";
+var Plugin = define({
+  id: "opencode.config.skill",
+  effect: Effect.fn(function* (ctx) {
+    const config = yield* exports_config.Service;
+    const discovery = yield* exports_discovery.Service;
+    const fs = yield* FSUtil.Service;
+    const global = yield* Global.Service;
+    const location = yield* exports_location.Service;
+    const watcher = yield* exports_watcher.Service;
+    const loaded = {
+      entries: yield* config.entries(),
+      skills: []
+    };
+    const watches = yield* FiberMap.make();
+    const changes = yield* PubSub.sliding(1);
+    const lock = Semaphore.makeUnsafe(1);
+    const watch = Effect.fn("ConfigSkillPlugin.watch")(function* (directory, type) {
+      const target = path.resolve(directory);
+      const updates = yield* watcher.subscribe({ path: target, type });
+      yield* FiberMap.run(watches, `${type}:${target}`, updates.pipe(Stream.runForEach((update) => PubSub.publish(changes, update.path).pipe(Effect.asVoid))), { onlyIfMissing: true, startImmediately: true });
+    });
+    function firstMissing(target) {
+      const parent = path.dirname(target);
+      if (parent === target)
+        return Effect.succeed(undefined);
+      return fs.isDir(parent).pipe(Effect.flatMap((exists) => exists ? Effect.succeed(target) : firstMissing(parent)));
+    }
+    const watchDirectory = Effect.fn("ConfigSkillPlugin.watchDirectory")(function* (directory) {
+      const target = path.resolve(directory);
+      const resolved = yield* fs.realPath(directory).pipe(Effect.catch(() => Effect.succeed(undefined)));
+      if (resolved) {
+        yield* watch(resolved, "directory");
+        if (resolved !== target)
+          yield* watch(target, "file");
+        return resolved === target ? [target] : [target, resolved];
+      }
+      const missing = yield* firstMissing(target);
+      if (missing)
+        yield* watch(missing, "file");
+      if (yield* fs.realPath(directory).pipe(Effect.as(true), Effect.catch(() => Effect.succeed(false)))) {
+        if (missing)
+          yield* FiberMap.remove(watches, `file:${path.resolve(missing)}`);
+        return yield* watchDirectory(directory);
+      }
+      return [target];
+    });
+    const sources = () => {
+      const result = [];
+      const add = (source) => {
+        if (result.some((item) => exports_skill.Source.equals(item, source)))
+          return;
+        result.push(source);
+      };
+      const claude = loaded.entries.flatMap((entry) => entry.type === "claude" ? [entry.path] : []);
+      const agents = loaded.entries.flatMap((entry) => entry.type === "agents" ? [entry.path] : []);
+      const directories = loaded.entries.flatMap((entry) => entry.type === "directory" ? [entry.path] : []);
+      const items = loaded.entries.flatMap((entry) => entry.type === "document" ? entry.info.skills ?? [] : []);
+      for (const directory of [...claude, ...agents]) {
+        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }));
+      }
+      for (const directory of directories) {
+        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skill")) }));
+        add(exports_skill.DirectorySource.make({ type: "directory", path: AbsolutePath.make(path.join(directory, "skills")) }));
+      }
+      for (const item of items) {
+        if (URL.canParse(item) && /^(https?:)$/.test(new URL(item).protocol)) {
+          add(exports_skill.UrlSource.make({ type: "url", url: item }));
+          continue;
+        }
+        const expanded = item.startsWith("~/") ? path.join(global.home, item.slice(2)) : item;
+        add(exports_skill.DirectorySource.make({
+          type: "directory",
+          path: AbsolutePath.make(path.isAbsolute(expanded) ? expanded : path.join(location.directory, expanded))
+        }));
+      }
+      return result;
+    };
+    const load = Effect.fn("ConfigSkillPlugin.load")(function* (source) {
+      const directories = source.type === "directory" ? [source.path] : yield* discovery.pull(source.url).pipe(Effect.catchCause((cause) => Effect.logWarning("failed to load skill source", {
+        source: exports_skill.Source.key(source),
+        cause
+      }).pipe(Effect.as([]))));
+      const roots = (yield* Effect.forEach(directories, watchDirectory)).flat();
+      const skills = [];
+      for (const directory of directories) {
+        const files = yield* fs.scan("{*.md,**/SKILL.md}", { cwd: directory, absolute: true, include: "file", symlink: true, dot: true }).pipe(Effect.catch(() => Effect.succeed([])));
+        for (const filepath of files.toSorted()) {
+          const resolved = yield* fs.realPath(filepath).pipe(Effect.catch(() => Effect.succeed(filepath)));
+          if (!roots.some((root) => FSUtil.contains(root, resolved)))
+            yield* watch(path.dirname(resolved), "directory");
+          const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)));
+          if (!content)
+            continue;
+          const parsed = exports_skill_file.parse(directory, filepath, content);
+          if (parsed._tag === "Skipped") {
+            yield* Effect.logDebug("skill file skipped", {
+              filepath,
+              reason: parsed.reason,
+              ...parsed.reason === "frontmatter" ? { issue: parsed.issue } : {}
+            });
+            continue;
+          }
+          skills.push(parsed.skill);
+        }
+      }
+      yield* Effect.logDebug("skill source loaded", {
+        source: exports_skill.Source.key(source),
+        type: source.type,
+        directories,
+        skills: skills.map((skill) => skill.id)
+      });
+      return skills;
+    });
+    const refresh = Effect.fn("ConfigSkillPlugin.refresh")(function* (file) {
+      yield* lock.withPermit(Effect.gen(function* () {
+        yield* FiberMap.clear(watches);
+        const skills = new Map;
+        const current = sources();
+        for (const source of current) {
+          for (const skill of yield* load(source))
+            skills.set(skill.id, skill);
+        }
+        loaded.skills = Array.from(skills.values());
+        if (file) {
+          yield* Effect.logInfo("skills rescanned", {
+            file,
+            sources: current.map(exports_skill.Source.key),
+            skills: loaded.skills.map((skill) => skill.id)
+          });
+        }
+      }));
+    });
+    yield* Stream.fromPubSub(changes).pipe(Stream.runForEach((file) => refresh(file).pipe(Effect.andThen(ctx.skill.reload()))), Effect.forkScoped({ startImmediately: true }));
+    yield* refresh();
+    yield* ctx.skill.transform((draft) => {
+      for (const skill of loaded.skills)
+        draft.add(skill);
+    });
+    yield* ctx.event.subscribe().pipe(Stream.filter((event) => event.type === "config.updated"), Stream.runForEach(() => config.entries().pipe(Effect.tap((entries) => Effect.sync(() => loaded.entries = entries)), Effect.andThen(refresh()), Effect.andThen(ctx.skill.reload()))), Effect.forkScoped({ startImmediately: true }));
+  })
+});
+
+export { Plugin, exports_skill2 as exports_skill };

package/dist/chunks/location-mutation-b02txbh8.js

@@ -0,0 +1,22 @@
+// src/database/migration/20260602182828_add_project_directories.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260602182828_add_project_directories",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`project_directory\` (
+          \`project_id\` text NOT NULL,
+          \`directory\` text NOT NULL,
+          \`type\` text NOT NULL,
+          \`time_created\` integer NOT NULL,
+          CONSTRAINT \`project_directory_pk\` PRIMARY KEY(\`project_id\`, \`directory\`),
+          CONSTRAINT \`fk_project_directory_project_id_project_id_fk\` FOREIGN KEY (\`project_id\`) REFERENCES \`project\`(\`id\`) ON DELETE CASCADE
+        );
+      `);
+    });
+  }
+};
+var _20260602182828_add_project_directories_default = migration;
+
+export { _20260602182828_add_project_directories_default };

package/dist/chunks/location-mutation-bbqs2y60.js

@@ -0,0 +1,14 @@
+// src/github-copilot/chat/get-response-metadata.ts
+function getResponseMetadata({
+  id,
+  model,
+  created
+}) {
+  return {
+    id: id ?? undefined,
+    modelId: model ?? undefined,
+    timestamp: created != null ? new Date(created * 1000) : undefined
+  };
+}
+
+export { getResponseMetadata };

package/dist/chunks/location-mutation-bfgdprj0.js

@@ -0,0 +1,99 @@
+import {
+  exports_mcp as exports_mcp2
+} from "./location-mutation-m5sbqbmy.js";
+import {
+  exports_mcp
+} from "./location-mutation-ztvvzzvv.js";
+import {
+  exports_permission
+} from "./location-mutation-gjaba53s.js";
+import {
+  exports_instructions
+} from "./location-mutation-8k8ks5a6.js";
+import {
+  __export
+} from "./location-mutation-rvfvac9x.js";
+
+// src/mcp/instructions.ts
+var exports_instructions2 = {};
+__export(exports_instructions2, {
+  node: () => node,
+  layer: () => layer,
+  Service: () => Service,
+  McpInstructions: () => exports_instructions2
+});
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { Context, Effect, Layer, Schema } from "effect";
+var Summary = Schema.Struct({
+  server: Schema.String,
+  instructions: Schema.String,
+  codemode: Schema.optionalKey(Schema.Literal(false))
+});
+var entries = (servers) => servers.flatMap((server) => {
+  const result = [`  <server name="${server.server}">`];
+  if (server.codemode !== false)
+    result.push(`    Use tools from this server through \`execute\` under \`tools[${JSON.stringify(exports_mcp2.namespace(server.server))}]\`.`);
+  result.push(...server.instructions.split(`
+`).map((line) => `    ${line}`), "  </server>");
+  return result;
+});
+var render = (servers) => ["<mcp_instructions>", ...entries(servers), "</mcp_instructions>"].join(`
+`);
+var update = (previous, current) => {
+  const diff = exports_instructions.diffByKey(previous, current, (server) => server.server, (before, after) => before.instructions !== after.instructions || before.codemode !== after.codemode);
+  if (diff.changed.length > 0 || diff.added.length === 0 && diff.removed.length === 0)
+    return [
+      "The available MCP server instructions have changed. This list supersedes the previous one.",
+      render(current)
+    ].join(`
+`);
+  return [
+    ...diff.added.length === 0 ? [] : ["New MCP server instructions are available in addition to those previously listed:", ...entries(diff.added)],
+    ...diff.removed.length === 0 ? [] : [
+      `Instructions for the following MCP servers are no longer available: ${diff.removed.map((server) => server.server).join(", ")}.`
+    ]
+  ].join(`
+`);
+};
+
+class Service extends Context.Service()("@opencode/McpInstructions") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const mcp = yield* exports_mcp.Service;
+  return Service.of({
+    load: Effect.fn("McpInstructions.load")(function* (selection) {
+      const agent = selection.info;
+      if (!agent)
+        return exports_instructions.empty;
+      const source = (value) => exports_instructions.make({
+        key: exports_instructions.Key.make("core/mcp-guidance"),
+        codec: Schema.toCodecJson(Schema.Array(Summary)),
+        read: Effect.succeed(value),
+        render: {
+          initial: render,
+          changed: update,
+          removed: () => "MCP server instructions are no longer available."
+        }
+      });
+      const [instructions, tools] = yield* Effect.all([mcp.instructions(), mcp.tools()], {
+        concurrency: "unbounded"
+      });
+      const canExecute = exports_permission.evaluate("execute", "*", agent.permissions).effect !== "deny";
+      const visible = instructions.flatMap((item) => {
+        const owned = tools.filter((tool) => tool.server === item.server);
+        const codemode = owned[0]?.codemode !== false;
+        if (codemode && !canExecute)
+          return [];
+        if (!owned.some((tool) => exports_permission.evaluate(exports_mcp2.name(tool.server, tool.name), "*", agent.permissions).effect !== "deny"))
+          return [];
+        return [
+          codemode ? { server: item.server, instructions: item.instructions } : { server: item.server, instructions: item.instructions, codemode: false }
+        ];
+      }).toSorted((a, b) => a.server.localeCompare(b.server));
+      return source(visible.length === 0 ? exports_instructions.removed : visible);
+    })
+  });
+}));
+var node = makeLocationNode({ service: Service, layer, deps: [exports_mcp.node] });
+
+export { Service, layer, node, exports_instructions2 as exports_instructions };