@opencode/core 0.0.0-beta-19275

package/dist/chunks/worktree-m63snmdm.js

@@ -0,0 +1,182 @@
+import {
+  AbsolutePath2
+} from "./worktree-922hggd3.js";
+import {
+  Service76,
+  node81
+} from "./worktree-1e9w7pgh.js";
+import {
+  parse4,
+  validateBranch3,
+  cachePath2,
+  same2
+} from "./worktree-2402vzrj.js";
+import {
+  Service58,
+  node62
+} from "./worktree-madgwgkk.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/repository-cache.ts
+var exports_repository_cache = {};
+__export(exports_repository_cache, {
+  CacheOperationError: () => CacheOperationError2,
+  CheckoutFailedError: () => CheckoutFailedError2,
+  CloneFailedError: () => CloneFailedError2,
+  FetchFailedError: () => FetchFailedError2,
+  InvalidBranchError: () => InvalidBranchError2,
+  LockFailedError: () => LockFailedError2,
+  RepositoryCache: () => exports_repository_cache,
+  ResetFailedError: () => ResetFailedError2,
+  Service: () => Service42,
+  isError: () => isError2,
+  node: () => node45,
+  validateBranch: () => validateBranch2
+});
+import path from "path";
+import { Clock, Context, Duration, Effect, Layer, Option, Schema } from "effect";
+import { FSUtil } from "@opencode/util/fs-util";
+import { Global } from "@opencode/util/global";
+import { makeGlobalNode } from "@opencode/util/effect/app-node";
+import { EffectFlock } from "@opencode/util/effect-flock";
+var Refresh = Schema.Struct({
+  attemptedAt: Schema.Number
+});
+var refreshInterval = Duration.toMillis(Duration.days(1));
+
+class InvalidBranchError2 extends Schema.TaggedError()("RepositoryCacheInvalidBranchError", {
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CloneFailedError2 extends Schema.TaggedError()("RepositoryCacheCloneFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class FetchFailedError2 extends Schema.TaggedError()("RepositoryCacheFetchFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CheckoutFailedError2 extends Schema.TaggedError()("RepositoryCacheCheckoutFailedError", {
+  repository: Schema.String,
+  branch: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class ResetFailedError2 extends Schema.TaggedError()("RepositoryCacheResetFailedError", {
+  repository: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class LockFailedError2 extends Schema.TaggedError()("RepositoryCacheLockFailedError", {
+  localPath: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class CacheOperationError2 extends Schema.TaggedError()("RepositoryCacheOperationError", {
+  operation: Schema.String,
+  path: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class Service42 extends Context.Service()("@opencode/RepositoryCache") {
+}
+function isError2(error) {
+  return error instanceof InvalidBranchError2 || error instanceof CloneFailedError2 || error instanceof FetchFailedError2 || error instanceof CheckoutFailedError2 || error instanceof ResetFailedError2 || error instanceof LockFailedError2 || error instanceof CacheOperationError2;
+}
+var validateBranch2 = Effect.fn("RepositoryCache.validateBranch")(function* (branch) {
+  return yield* Effect.try({
+    try: () => validateBranch3(branch),
+    catch: (error) => new InvalidBranchError2({ branch, message: errorMessage(error) })
+  });
+});
+var layer = Layer.effect(Service42, Effect.gen(function* () {
+  const fs = yield* FSUtil.Service;
+  const git = yield* Service76;
+  const flock = yield* EffectFlock.Service;
+  const global = yield* Global.Service;
+  const kv = yield* Service58;
+  return Service42.of({
+    ensure: Effect.fn("RepositoryCache.ensure")(function* (input) {
+      if (input.branch)
+        yield* validateBranch2(input.branch);
+      const repository = input.reference.label;
+      const localPath = cachePath2(global.repos, input.reference, input.branch);
+      const key = `repository-cache:${localPath}`;
+      const cloneTarget = parse4(input.reference.remote) ?? input.reference;
+      return yield* flock.withLock(Effect.gen(function* () {
+        yield* cacheOperation(fs.ensureDir(path.dirname(localPath)), "ensure cache directory", localPath);
+        const existing = yield* git.repo.discover(AbsolutePath2.make(localPath));
+        const origin = existing ? yield* git.remote.get(existing) : undefined;
+        const originReference = origin ? parse4(origin) : undefined;
+        const worktree = existing ? yield* fs.resolve(localPath) : undefined;
+        const reuse = Boolean(existing && existing.worktree === worktree && originReference && same2(originReference, cloneTarget));
+        if (!reuse && (yield* fs.existsSafe(localPath))) {
+          yield* cacheOperation(fs.remove(localPath, { recursive: true }), "remove stale cache", localPath);
+        }
+        const now = yield* Clock.currentTimeMillis;
+        const previous = Option.getOrUndefined(Schema.decodeUnknownOption(Refresh)(yield* kv.get(key)));
+        const refresh = input.refresh === "daily" ? !previous || now - previous.attemptedAt >= refreshInterval : input.refresh;
+        const status = !reuse ? "cloned" : refresh ? "refreshed" : "cached";
+        if (status !== "cached") {
+          yield* kv.set(key, { attemptedAt: now });
+          if (status === "cloned") {
+            yield* git.repo.clone({
+              remote: input.reference.remote,
+              directory: AbsolutePath2.make(localPath),
+              branch: input.branch
+            }).pipe(Effect.mapError((error) => new CloneFailedError2({ repository, message: error.message })));
+          }
+          if (status === "refreshed") {
+            if (!existing)
+              return yield* new FetchFailedError2({ repository, message: "Repository is unavailable" });
+            yield* git.sync.fetchRemotes(existing).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
+            if (input.branch) {
+              yield* git.sync.fetchBranch(existing, { branch: input.branch }).pipe(Effect.mapError((error) => new FetchFailedError2({ repository, message: error.message })));
+            }
+            const branch = input.branch ?? (yield* git.history.defaultRemoteBranch(existing));
+            if (branch) {
+              yield* git.sync.checkoutRemoteBranch(existing, { branch }).pipe(Effect.mapError((error) => new CheckoutFailedError2({ repository, branch, message: error.message })));
+            }
+            const target = branch ?? (yield* git.history.branch(existing));
+            yield* git.sync.resetHard(existing, target ? `origin/${target}` : "HEAD").pipe(Effect.mapError((error) => new ResetFailedError2({ repository, message: error.message })));
+          }
+        }
+        const checkout = yield* git.repo.discover(AbsolutePath2.make(localPath));
+        return {
+          repository,
+          host: input.reference.host,
+          remote: input.reference.remote,
+          localPath,
+          status,
+          head: checkout ? yield* git.history.head(checkout) : undefined,
+          branch: checkout ? yield* git.history.branch(checkout) : undefined
+        };
+      }), key).pipe(Effect.mapError((error) => isError2(error) ? error : new LockFailedError2({ localPath, message: errorMessage(error) })));
+    })
+  });
+}));
+var node45 = makeGlobalNode({
+  service: Service42,
+  layer,
+  deps: [EffectFlock.node, FSUtil.node, node81, Global.node, node62]
+});
+function errorMessage(error) {
+  return error instanceof globalThis.Error ? error.message : String(error);
+}
+function cacheOperation(effect, operation, target) {
+  return effect.pipe(Effect.mapError((error) => new CacheOperationError2({ operation, path: target, message: errorMessage(error) })));
+}
+
+export { InvalidBranchError2, CloneFailedError2, FetchFailedError2, CheckoutFailedError2, ResetFailedError2, LockFailedError2, CacheOperationError2, Service42, isError2, validateBranch2, node45, exports_repository_cache };

package/dist/chunks/worktree-m6vfy410.js

@@ -0,0 +1,104 @@
+import {
+  Service79,
+  node84
+} from "./worktree-vrm5r67w.js";
+import {
+  Service74,
+  node79
+} from "./worktree-z82wee6n.js";
+import {
+  SessionEvent2
+} from "./worktree-ec1grn59.js";
+import {
+  Service72,
+  node77
+} from "./worktree-3bgy0jaw.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/session/instructions.ts
+var exports_instructions = {};
+__export(exports_instructions, {
+  Service: () => Service6,
+  SessionInstructions: () => exports_instructions,
+  node: () => node9
+});
+import { relative } from "path";
+import { Context, Effect, Layer, Option, Ref, Schema } from "effect";
+import { makeLocationNode } from "@opencode/util/effect/app-node";
+import { FSUtil } from "@opencode/util/fs-util";
+var InjectedMetadata = Schema.Struct({
+  instruction: Schema.Struct({ paths: Schema.Array(Schema.String) })
+});
+
+class Service6 extends Context.Service()("@opencode/SessionInstructions") {
+}
+var layer = Layer.effect(Service6, Effect.gen(function* () {
+  const bus = yield* Service79;
+  const fs = yield* FSUtil.Service;
+  const store = yield* Service72;
+  const location = yield* Service74;
+  const root = yield* fs.resolve(location.project.directory);
+  const inFlight = yield* Ref.make(new Map);
+  const load = Effect.fn("SessionInstructions.load")(function* (input) {
+    const claimed = yield* Ref.modify(inFlight, (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;
+    yield* Effect.gen(function* () {
+      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(SessionEvent2.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) } }
+      });
+    }).pipe(Effect.ensuring(Ref.update(inFlight, (map) => {
+      const existing = map.get(input.sessionID);
+      if (!existing)
+        return map;
+      const remaining = new Set([...existing].filter((path) => !claimed.includes(path)));
+      const next = new Map(map);
+      if (remaining.size === 0)
+        next.delete(input.sessionID);
+      else
+        next.set(input.sessionID, remaining);
+      return next;
+    })));
+  });
+  return Service6.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 node9 = makeLocationNode({
+  name: "session-instructions",
+  layer,
+  deps: [node84, FSUtil.node, node79, node77]
+});
+
+export { Service6, node9, exports_instructions };

package/dist/chunks/worktree-m9hyszwm.js

@@ -0,0 +1,341 @@
+import {
+  ps2
+} from "./worktree-w55j1d38.js";
+import {
+  lazy2
+} from "./worktree-88xbtdfr.js";
+import {
+  match2
+} from "./worktree-y1fvbwt7.js";
+import {
+  __export
+} from "./worktree-9rqn6x4v.js";
+
+// src/shell/parse.ts
+var exports_parse = {};
+__export(exports_parse, {
+  ShellParse: () => exports_parse,
+  scan: () => scan2,
+  scanPortable: () => scanPortable2
+});
+import { Effect } from "effect";
+import { fileURLToPath } from "url";
+import os from "os";
+import path from "path";
+import { shellParserWasm } from "#shell-parser-wasm";
+var CWD = new Set(["cd", "chdir", "popd", "pushd", "push-location", "set-location"]);
+var POWERSHELL_PATH_FLAGS = new Set(["-literalpath", "-path"]);
+var ARITY = {
+  cat: 1,
+  cd: 1,
+  chmod: 1,
+  chown: 1,
+  cp: 1,
+  echo: 1,
+  env: 1,
+  export: 1,
+  grep: 1,
+  kill: 1,
+  killall: 1,
+  ln: 1,
+  ls: 1,
+  mkdir: 1,
+  mv: 1,
+  ps: 1,
+  pwd: 1,
+  rm: 1,
+  rmdir: 1,
+  sleep: 1,
+  source: 1,
+  tail: 1,
+  touch: 1,
+  unset: 1,
+  which: 1,
+  aws: 3,
+  az: 3,
+  bazel: 2,
+  brew: 2,
+  bun: 2,
+  "bun run": 3,
+  "bun x": 3,
+  cargo: 2,
+  "cargo add": 3,
+  "cargo run": 3,
+  cdk: 2,
+  cf: 2,
+  cmake: 2,
+  composer: 2,
+  consul: 2,
+  "consul kv": 3,
+  crictl: 2,
+  deno: 2,
+  "deno task": 3,
+  doctl: 3,
+  docker: 2,
+  "docker builder": 3,
+  "docker compose": 3,
+  "docker container": 3,
+  "docker image": 3,
+  "docker network": 3,
+  "docker volume": 3,
+  eksctl: 2,
+  "eksctl create": 3,
+  firebase: 2,
+  flyctl: 2,
+  gcloud: 3,
+  gh: 3,
+  git: 2,
+  "git config": 3,
+  "git remote": 3,
+  "git stash": 3,
+  go: 2,
+  gradle: 2,
+  helm: 2,
+  heroku: 2,
+  hugo: 2,
+  ip: 2,
+  "ip addr": 3,
+  "ip link": 3,
+  "ip netns": 3,
+  "ip route": 3,
+  kind: 2,
+  "kind create": 3,
+  kubectl: 2,
+  "kubectl kustomize": 3,
+  "kubectl rollout": 3,
+  kustomize: 2,
+  make: 2,
+  mc: 2,
+  "mc admin": 3,
+  minikube: 2,
+  mongosh: 2,
+  mysql: 2,
+  mvn: 2,
+  ng: 2,
+  npm: 2,
+  "npm exec": 3,
+  "npm init": 3,
+  "npm run": 3,
+  "npm view": 3,
+  npx: 2,
+  nvm: 2,
+  nx: 2,
+  openssl: 2,
+  "openssl req": 3,
+  "openssl x509": 3,
+  pip: 2,
+  pipenv: 2,
+  pnpm: 2,
+  "pnpm dlx": 3,
+  "pnpm exec": 3,
+  "pnpm run": 3,
+  poetry: 2,
+  podman: 2,
+  "podman container": 3,
+  "podman image": 3,
+  psql: 2,
+  pulumi: 2,
+  "pulumi stack": 3,
+  python: 2,
+  pyenv: 2,
+  rake: 2,
+  rbenv: 2,
+  "redis-cli": 2,
+  rustup: 2,
+  serverless: 2,
+  sfdx: 3,
+  skaffold: 2,
+  sls: 2,
+  sst: 2,
+  swift: 2,
+  systemctl: 2,
+  terraform: 2,
+  "terraform workspace": 3,
+  tmux: 2,
+  turbo: 2,
+  ufw: 2,
+  vault: 2,
+  "vault auth": 3,
+  "vault kv": 3,
+  vercel: 2,
+  volta: 2,
+  wp: 2,
+  yarn: 2,
+  "yarn dlx": 3,
+  "yarn run": 3
+};
+var PREFIX_LENGTH = Math.max(...Object.values(ARITY));
+var scan2 = Effect.fnUntraced(function* (command, shell, cwd, options) {
+  if (options?.portable)
+    return yield* scanPortable2(command, shell, cwd);
+  return yield* scanLegacy(command, shell, cwd);
+});
+var scanLegacy = Effect.fnUntraced(function* (command, shell, cwd) {
+  const parsers = yield* Effect.promise(load);
+  const powershell = ps2(shell);
+  const tree = (powershell ? parsers.ps : parsers.bash).parse(command);
+  if (!tree)
+    return yield* Effect.fail(new Error("Failed to parse shell command"));
+  return yield* Effect.acquireUseRelease(Effect.succeed(tree), (tree) => Effect.sync(() => tree.rootNode.descendantsOfType("command").reduce((result, node) => {
+    if (!node)
+      return result;
+    const command = parts(node);
+    const tokens = command.map((part) => part.text);
+    if (tokens.length === 0)
+      return result;
+    const name = powershell ? tokens[0].toLowerCase() : tokens[0];
+    if (CWD.has(name)) {
+      result.directories.push(...directoryArgs(command, powershell, cwd, shell));
+      return result;
+    }
+    result.commands.push({
+      resource: (node.parent?.type === "redirected_statement" ? node.parent.text : node.text).trim(),
+      save: `${prefix(tokens).join(" ")} *`
+    });
+    return result;
+  }, { commands: [], directories: [] })), (tree) => Effect.sync(() => tree.delete()));
+});
+var scanPortable2 = Effect.fnUntraced(function* (command, shell, cwd) {
+  const { ShellScan } = yield* Effect.tryPromise({
+    try: () => import("../shell/scan.js"),
+    catch: (cause) => new Error(`Portable shell scanner failed to load: ${cause}`, { cause })
+  });
+  const powershell = ps2(shell);
+  const result = powershell ? ShellScan.scanPowerShell(command) : ShellScan.scan(command);
+  if (result.kind === "opaque")
+    return yield* Effect.fail(new Error(`Portable shell scanner cannot analyze command: ${result.reason}`));
+  const output = { commands: [], directories: [] };
+  for (const item of result.commands) {
+    if (item.declaration)
+      continue;
+    const words = item.redirectWordCount === undefined ? item.rawWords : item.rawWords.slice(0, item.redirectWordCount);
+    if (powershell && item.statementHead && /^foreach(?:-|$)/i.test(words[0] ?? ""))
+      continue;
+    const name = powershell ? words[0]?.toLowerCase() : words[0];
+    if (CWD.has(name)) {
+      output.directories.push(...directoryArgs(words.flatMap((text) => {
+        const parameter = powershell ? /^(-(?:literalpath|path)):(.*)$/i.exec(text) : undefined;
+        if (parameter)
+          return [
+            { type: "command_parameter", text: parameter[1] },
+            { type: "word", text: parameter[2] }
+          ];
+        return [{ type: powershell && text.startsWith("-") ? "command_parameter" : "word", text }];
+      }), powershell, cwd, shell));
+      continue;
+    }
+    const selected = prefix(words.slice(0, PREFIX_LENGTH));
+    const conventional = `${selected.join(" ")} *`;
+    const end = item.wordEnds?.[selected.length - 1];
+    const save = !powershell || end === undefined || match2(item.resource, conventional) ? conventional : (() => {
+      const boundary = item.wordEnds?.find((value) => value >= end && (value >= item.resource.length || /\s/.test(item.resource[value]))) ?? end;
+      const separator = /^\s+(?:`(?:\r\n|\r|\n)\s*)?/.exec(item.resource.slice(boundary))?.[0];
+      return `${item.resource.slice(0, boundary)}${separator ?? " "}*`;
+    })();
+    output.commands.push({
+      resource: item.resource,
+      save
+    });
+  }
+  return output;
+});
+function parts(node) {
+  return Array.from({ length: node.childCount }).flatMap((_, index) => {
+    const child = node.child(index);
+    if (!child)
+      return [];
+    if (child.type === "command_elements")
+      return Array.from({ length: child.childCount }).flatMap((_, itemIndex) => {
+        const item = child.child(itemIndex);
+        if (!item || item.type === "command_argument_sep" || item.type === "redirection")
+          return [];
+        return [{ type: item.type, text: item.text }];
+      });
+    if (!["command_name", "command_name_expr", "word", "string", "raw_string", "concatenation"].includes(child.type))
+      return [];
+    return [{ type: child.type, text: child.text }];
+  });
+}
+function directoryArgs(command, powershell, cwd, shell) {
+  if (!powershell)
+    return command.slice(1).filter((part) => !part.text.startsWith("-")).map((part) => directoryArgument(part.text, powershell, cwd, shell)).filter((part) => part !== undefined);
+  const directories = [];
+  let path2 = false;
+  for (const part of command.slice(1)) {
+    if (path2) {
+      const value = directoryArgument(part.text, powershell, cwd, shell);
+      if (value)
+        directories.push(value);
+      path2 = false;
+      continue;
+    }
+    if (part.type === "command_parameter") {
+      path2 = POWERSHELL_PATH_FLAGS.has(part.text.toLowerCase());
+      continue;
+    }
+    const value = directoryArgument(part.text, powershell, cwd, shell);
+    if (value)
+      directories.push(value);
+  }
+  return directories;
+}
+function directoryArgument(value, powershell, cwd, shell) {
+  const quote = value[0];
+  const text = (quote === '"' || quote === "'") && value.at(-1) === quote ? value.slice(1, -1) : value;
+  if (!powershell)
+    return expandKnownDirectory(text);
+  return expandKnownDirectory(text.replace(/\$\{env:([^}]+)\}/gi, (_, key) => environment(key) ?? "").replace(/\$env:([A-Za-z_][A-Za-z0-9_]*)/gi, (_, key) => environment(key) ?? "").replace(/\$(HOME|PWD|PSHOME)(?=$|[\\/])/gi, (_, key) => {
+    if (key.toUpperCase() === "HOME")
+      return os.homedir();
+    if (key.toUpperCase() === "PWD")
+      return cwd;
+    return path.dirname(shell);
+  }));
+}
+function expandKnownDirectory(value) {
+  if (value.includes("$") || value.includes("`") || value.startsWith("("))
+    return;
+  if (value === "~")
+    return os.homedir();
+  if (value.startsWith("~/") || process.platform === "win32" && value.startsWith("~\\")) {
+    return path.join(os.homedir(), value.slice(2));
+  }
+  return value;
+}
+function environment(key) {
+  if (process.platform !== "win32")
+    return process.env[key];
+  const name = Object.keys(process.env).find((item) => item.toLowerCase() === key.toLowerCase());
+  return name ? process.env[name] : undefined;
+}
+function prefix(tokens) {
+  for (let length = tokens.length;length > 0; length--) {
+    const arity = ARITY[tokens.slice(0, length).join(" ")];
+    if (arity !== undefined)
+      return tokens.slice(0, arity);
+  }
+  return tokens.slice(0, 1);
+}
+function resolve(asset) {
+  if (asset.startsWith("file://"))
+    return fileURLToPath(asset);
+  if (path.isAbsolute(asset))
+    return asset;
+  return fileURLToPath(new URL(asset, import.meta.url));
+}
+var load = lazy2(initialize);
+async function initialize() {
+  const { Parser, Language } = await import("web-tree-sitter");
+  await Parser.init({ locateFile: () => resolve(shellParserWasm.runtime) });
+  const [bashLanguage, psLanguage] = await Promise.all([
+    Language.load(resolve(shellParserWasm.bash)),
+    Language.load(resolve(shellParserWasm.powershell))
+  ]);
+  const bash = new Parser;
+  bash.setLanguage(bashLanguage);
+  const ps = new Parser;
+  ps.setLanguage(psLanguage);
+  return { bash, ps };
+}
+
+export { scan2, scanPortable2, exports_parse };