@opencode-ai/core 0.0.0-beta-17498

package/dist/chunks/ripgrep-nc4xvjvt.js

@@ -0,0 +1,88 @@
+import {
+  exports_store
+} from "./ripgrep-3kbfazvv.js";
+import {
+  SessionEvent
+} from "./ripgrep-a83yvq99.js";
+import {
+  exports_location
+} from "./ripgrep-hcyadm03.js";
+import {
+  exports_bus
+} from "./ripgrep-6wnd6t4j.js";
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/instructions.ts
+var exports_instructions = {};
+__export(exports_instructions, {
+  node: () => node,
+  SessionInstructions: () => exports_instructions,
+  Service: () => Service
+});
+import { relative } from "path";
+import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
+import { makeLocationNode } from "@opencode-ai/util/effect/app-node";
+import { FSUtil } from "@opencode-ai/util/fs-util";
+var InjectedMetadata = Schema.Struct({
+  instruction: Schema.Struct({ paths: Schema.Array(Schema.String) })
+});
+
+class Service extends Context.Service()("@opencode/SessionInstructions") {
+}
+var layer = Layer.effect(Service, Effect.gen(function* () {
+  const bus = yield* exports_bus.Service;
+  const fs = yield* FSUtil.Service;
+  const store = yield* exports_store.Service;
+  const location = yield* exports_location.Service;
+  const root = yield* fs.resolve(location.project.directory);
+  const injected = yield* Ref.make(new Map);
+  const load = Effect.fn("SessionInstructions.load")(function* (input) {
+    const claimed = yield* Ref.modify(injected, (map) => {
+      const existing = map.get(input.sessionID) ?? new Set;
+      const newlyClaimed = input.paths.filter((path) => !existing.has(path));
+      if (newlyClaimed.length === 0)
+        return [newlyClaimed, map];
+      const next = new Map(map);
+      next.set(input.sessionID, new Set([...existing, ...newlyClaimed]));
+      return [newlyClaimed, next];
+    });
+    if (claimed.length === 0)
+      return;
+    const alreadyInjected = yield* previouslyInjected(store, input.sessionID);
+    const toInject = claimed.filter((path) => !alreadyInjected.has(path));
+    if (toInject.length === 0)
+      return;
+    const files = yield* Effect.forEach(toInject, (path) => fs.readFileStringSafe(path).pipe(Effect.map((content) => content === undefined ? undefined : { path, content })), { concurrency: "unbounded" });
+    const readable = files.filter((file) => file !== undefined);
+    if (readable.length === 0)
+      return;
+    yield* bus.publish(SessionEvent.Synthetic, {
+      sessionID: input.sessionID,
+      text: readable.map((file) => `Instructions from: ${file.path}
+${file.content}`).join(`
+
+`),
+      description: `Loaded ${readable.map((file) => describePath(root, file.path)).join(", ")}`,
+      metadata: { instruction: { paths: readable.map((file) => file.path) } }
+    });
+  });
+  return Service.of({ load });
+}));
+function previouslyInjected(store, sessionID) {
+  return Effect.gen(function* () {
+    const history = yield* store.context(sessionID);
+    return new Set(history.filter((message) => message.type === "synthetic").flatMap((message) => Option.getOrUndefined(Schema.decodeUnknownOption(InjectedMetadata)(message.metadata))?.instruction.paths ?? []));
+  });
+}
+function describePath(root, path) {
+  return FSUtil.contains(root, path) ? relative(root, path) : path;
+}
+var node = makeLocationNode({
+  name: "session-instructions",
+  layer,
+  deps: [exports_bus.node, FSUtil.node, exports_location.node, exports_store.node]
+});
+
+export { Service, node, exports_instructions };

package/dist/chunks/ripgrep-nesb2rcz.js

@@ -0,0 +1,18 @@
+import {
+  ProjectTable
+} from "./ripgrep-88jbfw8z.js";
+import {
+  Timestamps
+} from "./ripgrep-sem2g21k.js";
+
+// src/permission/sql.ts
+import { sqliteTable, text, uniqueIndex } from "drizzle-orm/sqlite-core";
+var PermissionTable = sqliteTable("permission", {
+  id: text().$type().primaryKey(),
+  project_id: text().$type().notNull().references(() => ProjectTable.id, { onDelete: "cascade" }),
+  action: text().notNull(),
+  resource: text().notNull(),
+  ...Timestamps
+}, (table) => [uniqueIndex("permission_project_action_resource_idx").on(table.project_id, table.action, table.resource)]);
+
+export { PermissionTable };

package/dist/chunks/ripgrep-nj1s64cz.js

@@ -0,0 +1,112 @@
+import {
+  __export
+} from "./ripgrep-rvfvac9x.js";
+
+// src/session/run-coordinator.ts
+var exports_run_coordinator = {};
+__export(exports_run_coordinator, {
+  make: () => make,
+  SessionRunCoordinator: () => exports_run_coordinator
+});
+import { Deferred, Effect, Fiber, FiberSet } from "effect";
+var make = (options) => Effect.gen(function* () {
+  const executions = new Map;
+  const fork = yield* FiberSet.makeRuntime();
+  const loop = (key, execution, force) => Effect.suspend(() => options.drain(key, force, execution.request)).pipe(Effect.flatMap(() => Effect.suspend(() => {
+    if (execution.stopping || execution.pendingWake === undefined)
+      return Effect.void;
+    execution.request = execution.pendingWake;
+    execution.pendingWake = undefined;
+    return Effect.yieldNow.pipe(Effect.andThen(loop(key, execution, false)));
+  })));
+  const start = (key, force, request) => {
+    const execution = {
+      done: Deferred.makeUnsafe(),
+      request,
+      stopping: false
+    };
+    executions.set(key, execution);
+    execution.owner = fork(Effect.yieldNow.pipe(Effect.andThen(Effect.uninterruptible(options.started?.(key) ?? Effect.void)), Effect.andThen(loop(key, execution, force)), Effect.onExit((exit) => Effect.sync(() => {
+      execution.owner = undefined;
+    }).pipe(Effect.andThen(options.settled?.(key, exit, execution.interruptionReason) ?? Effect.void))), Effect.onExit((exit) => finish(key, execution, exit)), Effect.exit, Effect.asVoid));
+    return execution;
+  };
+  const settle = (key, execution, exit, resume) => {
+    if (resume && execution.continuation)
+      start(key, false, execution.continuation.request);
+    else if (execution.pendingWake)
+      start(key, false, execution.pendingWake);
+    else
+      executions.delete(key);
+    Deferred.doneUnsafe(execution.done, exit);
+  };
+  const finish = (key, execution, exit) => {
+    if (!execution.continuation)
+      return Effect.sync(() => settle(key, execution, exit, false));
+    return execution.continuation.when.pipe(Effect.flatMap((ready) => Effect.sync(() => settle(key, execution, exit, ready || execution.continuation?.signaled === true))));
+  };
+  const run = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution !== undefined) {
+      if (execution.stopping)
+        return Deferred.await(execution.done).pipe(Effect.andThen(run(key)));
+      return Deferred.await(execution.done);
+    }
+    return Deferred.await(start(key, true, "input").done);
+  });
+  const wake = (key, request = "input") => Effect.sync(() => {
+    const execution = executions.get(key);
+    if (execution !== undefined) {
+      if (execution.stopping) {
+        if (execution.continuation)
+          execution.continuation.signaled = true;
+        else
+          execution.continuation = { request, when: Effect.succeed(true), signaled: true };
+        return;
+      }
+      execution.pendingWake = execution.pendingWake === "input" ? "input" : request;
+      return;
+    }
+    start(key, false, request);
+  });
+  const wakeActive = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    return execution ? wake(key, execution.request) : Effect.void;
+  });
+  const interrupt = (key, reason, options2) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution === undefined)
+      return Effect.void;
+    if (execution.stopping) {
+      if (options2?.continue)
+        execution.continuation = {
+          ...options2.continue,
+          signaled: execution.continuation?.signaled ?? false
+        };
+      return Deferred.await(execution.done).pipe(Effect.exit, Effect.asVoid);
+    }
+    if (execution.owner === undefined) {
+      if (!options2?.continue)
+        return Effect.void;
+      execution.stopping = true;
+      execution.pendingWake = undefined;
+      execution.continuation = { ...options2.continue, signaled: false };
+      return Deferred.await(execution.done).pipe(Effect.exit, Effect.asVoid);
+    }
+    execution.stopping = true;
+    execution.pendingWake = undefined;
+    execution.interruptionReason = reason;
+    if (options2?.continue)
+      execution.continuation = { ...options2.continue, signaled: false };
+    return Fiber.interrupt(execution.owner);
+  });
+  const awaitIdle = (key) => Effect.suspend(() => {
+    const execution = executions.get(key);
+    if (execution === undefined)
+      return Effect.void;
+    return Deferred.await(execution.done).pipe(Effect.exit, Effect.andThen(awaitIdle(key)));
+  });
+  return { active: Effect.sync(() => new Set(executions.keys())), run, wake, wakeActive, interrupt, awaitIdle };
+});
+
+export { make, exports_run_coordinator };

package/dist/chunks/ripgrep-nkm1m8dz.js

@@ -0,0 +1,25 @@
+// src/database/migration/20260213144116_wakeful_the_professor.ts
+import { Effect } from "effect";
+var migration = {
+  id: "20260213144116_wakeful_the_professor",
+  up(tx) {
+    return Effect.gen(function* () {
+      yield* tx.run(`
+        CREATE TABLE \`control_account\` (
+          \`email\` text NOT NULL,
+          \`url\` text NOT NULL,
+          \`access_token\` text NOT NULL,
+          \`refresh_token\` text NOT NULL,
+          \`token_expiry\` integer,
+          \`active\` integer NOT NULL,
+          \`time_created\` integer NOT NULL,
+          \`time_updated\` integer NOT NULL,
+          CONSTRAINT \`control_account_pk\` PRIMARY KEY(\`email\`, \`url\`)
+        );
+      `);
+    });
+  }
+};
+var _20260213144116_wakeful_the_professor_default = migration;
+
+export { _20260213144116_wakeful_the_professor_default };