lalph 0.1.111 → 0.1.113

package/dist/cli.mjs

@@ -65770,7 +65770,7 @@ const opencode = new CliAgent({
 	name: "opencode",
 	command: ({ prompt, prdFilePath }) => make$23({
 		extendEnv: true,
-		env: { OPENCODE_PERMISSION: "{\"*\":\"allow\"}" },
+		env: { OPENCODE_PERMISSION: "{\"*\":\"allow\", \"question\":\"deny\"}" },
 		stdout: "pipe",
 		stderr: "pipe",
 		stdin: "inherit"
@@ -149003,10 +149003,47 @@ const getOrSelectAutoMergeLabel = gen(function* () {
 const resetGithub = labelFilter.set(none$3()).pipe(andThen(autoMergeLabel.set(none$3())));
 const maybeNextPage = (page, linkHeader) => pipe(fromNullishOr$2(linkHeader), filter$8((_) => _.includes(`rel="next"`)), as$2(page + 1));
 
+//#endregion
+//#region src/Tracing.ts
+const TracingLayer = unwrap$3(gen(function* () {
+	const logLevel = yield* MinimumLogLevel;
+	if (isLessThan$1("Trace", logLevel)) return empty$14;
+	return TracerLogger;
+}));
+const TracerLogger = gen(function* () {
+	const loggers = yield* CurrentLoggers;
+	const tracer = yield* Tracer;
+	const fiber = getCurrent();
+	const log = (message, time) => {
+		const options = {
+			message,
+			fiber,
+			date: new Date(Number(time / BigInt(1e6))),
+			logLevel: "Trace",
+			cause: empty$13
+		};
+		loggers.forEach((logger) => {
+			logger.log(options);
+		});
+	};
+	return make$55({ span(name, parent, annotations, links, startTime, kind, options) {
+		const span = tracer.span(name, parent, annotations, links, startTime, kind, options);
+		log(`${name}: started`, startTime);
+		const oldEnd = span.end;
+		span.end = (endTime, cause) => {
+			const duration = nanos(endTime - span.status.startTime);
+			log(`${name}: completed. Took ${format$2(duration)}`, endTime);
+			return oldEnd.call(span, endTime, cause);
+		};
+		return span;
+	} });
+}).pipe(effect$1(Tracer));
+
 //#endregion
 //#region src/shared/runtime.ts
 const lalphMemoMap = makeMemoMapUnsafe();
-const makeAtomRuntime = context({ memoMap: lalphMemoMap });
+const atomRuntime = context({ memoMap: lalphMemoMap });
+atomRuntime.addGlobalLayer(TracingLayer);
 
 //#endregion
 //#region src/IssueSources.ts
@@ -149021,7 +149058,7 @@ const issueSources = [{
 	name: "GitHub Issues",
 	layer: GithubIssueSource,
 	reset: resetGithub,
-	githubPrInstructions: `At the start of your PR description, include a line that closes the issue, like: Closes {task id}.`
+	githubPrInstructions: `At the start of your PR description, include a line that closes the issue: Closes {task id}`
 }];
 const selectedIssueSource = new Setting("issueSource", Literals(issueSources.map((s) => s.id)));
 const selectIssueSource = gen(function* () {
@@ -149051,15 +149088,15 @@ var CurrentIssueSource = class CurrentIssueSource extends Service()("lalph/Curre
 		return add$5(services, CurrentIssueSource, source);
 	})).pipe(provide$3([Settings.layer, PlatformServices]));
 };
-const issueSourceRuntime = makeAtomRuntime(CurrentIssueSource.layer.pipe(orDie$3));
+const issueSourceRuntime = atomRuntime(CurrentIssueSource.layer.pipe(orDie$3));
 const currentIssuesAtom = pipe(issueSourceRuntime.atom(fnUntraced(function* (get) {
-	const issues = yield* (yield* IssueSource).issues;
+	const issues = yield* (yield* IssueSource).issues.pipe(withSpan("currentIssuesAtom.refresh"));
 	const handle = setTimeout(() => {
 		get.refreshSelf();
 	}, 3e4);
 	get.addFinalizer(() => clearTimeout(handle));
 	return issues;
-})), makeAtomRuntime.withReactivity(["issues"]), keepAlive);
+})), atomRuntime.withReactivity(["issues"]), keepAlive);
 const getCurrentIssues = getResult(currentIssuesAtom, { suspendOnWaiting: true });
 const checkForWork = gen(function* () {
 	if (!(yield* getCurrentIssues).some((issue) => issue.state === "todo" && issue.blockedBy.length === 0)) return yield* new NoMoreWork({});
@@ -149909,7 +149946,10 @@ const run = fnUntraced(function* (options) {
 			yield* worktree.exec`git push -u ${parsed.remote} ${parsed.branch}`;
 		}
 	}
-	if (gitFlow.branch) yield* worktree.exec`git checkout -b ${gitFlow.branch}`;
+	if (gitFlow.branch) {
+		yield* worktree.exec`git branch -D ${gitFlow.branch}`;
+		yield* worktree.exec`git checkout -b ${gitFlow.branch}`;
+	}
 	yield* addFinalizer(fnUntraced(function* () {
 		const currentBranchName = yield* worktree.currentBranch(worktree.directory).pipe(option$1, map$8(getOrUndefined));
 		if (!currentBranchName) return;
@@ -150197,43 +150237,7 @@ const commandSource = make$34("source").pipe(withDescription("Select the issue s
 
 //#endregion
 //#region package.json
-var version = "0.1.111";
-
-//#endregion
-//#region src/Tracing.ts
-const TracingLayer = unwrap$3(gen(function* () {
-	const logLevel = yield* MinimumLogLevel;
-	if (isLessThan$1("Trace", logLevel)) return empty$14;
-	return TracerLogger;
-}));
-const TracerLogger = gen(function* () {
-	const loggers = yield* CurrentLoggers;
-	const tracer = yield* Tracer;
-	const fiber = getCurrent();
-	const log = (message, time) => {
-		const options = {
-			message,
-			fiber,
-			date: new Date(Number(time / BigInt(1e6))),
-			logLevel: "Trace",
-			cause: empty$13
-		};
-		loggers.forEach((logger) => {
-			logger.log(options);
-		});
-	};
-	return make$55({ span(name, parent, annotations, links, startTime, kind, options) {
-		const span = tracer.span(name, parent, annotations, links, startTime, kind, options);
-		log(`${name}: started`, startTime);
-		const oldEnd = span.end;
-		span.end = (endTime, cause) => {
-			const duration = nanos(endTime - span.status.startTime);
-			log(`${name}: completed. Took ${format$2(duration)}`, endTime);
-			return oldEnd.call(span, endTime, cause);
-		};
-		return span;
-	} });
-}).pipe(effect$1(Tracer));
+var version = "0.1.113";
 
 //#endregion
 //#region src/cli.ts
@@ -150246,7 +150250,12 @@ commandRoot.pipe(withSubcommands([
 	commandAgent
 ]), provideEffectDiscard(fnUntraced(function* (options) {
 	if (options.reset) yield* resetCurrentIssueSource;
-})), provide(Settings.layer), provide(TracingLayer), provide(({ verbose }) => verbose ? succeed$2(MinimumLogLevel, "All") : empty$14), (_) => run$4(_, { version }), provide$1(PlatformServices), provideService(CurrentMemoMap, lalphMemoMap), runMain);
+})), provide(Settings.layer), provide(TracingLayer), provide(({ verbose }) => {
+	if (!verbose) return empty$14;
+	const logLevel = succeed$2(MinimumLogLevel, "All");
+	atomRuntime.addGlobalLayer(logLevel);
+	return logLevel;
+}), run$4({ version }), provide$1(PlatformServices), provideService(CurrentMemoMap, lalphMemoMap), runMain);
 
 //#endregion
 export {  };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "lalph",
   "type": "module",
-  "version": "0.1.111",
+  "version": "0.1.113",
   "publishConfig": {
     "access": "public"
   },

package/src/IssueSources.ts

@@ -5,7 +5,7 @@ import { Prompt } from "effect/unstable/cli"
 import { GithubIssueSource, resetGithub } from "./Github.ts"
 import { IssueSource } from "./IssueSource.ts"
 import { PlatformServices } from "./shared/platform.ts"
-import { makeAtomRuntime as atomRuntime } from "./shared/runtime.ts"
+import { atomRuntime } from "./shared/runtime.ts"
 import { Atom, Reactivity } from "effect/unstable/reactivity"
 import type { PrdIssue } from "./domain/PrdIssue.ts"
 
@@ -22,7 +22,7 @@ const issueSources: ReadonlyArray<typeof CurrentIssueSource.Service> = [
     name: "GitHub Issues",
     layer: GithubIssueSource,
     reset: resetGithub,
-    githubPrInstructions: `At the start of your PR description, include a line that closes the issue, like: Closes {task id}.`,
+    githubPrInstructions: `At the start of your PR description, include a line that closes the issue: Closes {task id}`,
   },
 ]
 
@@ -92,10 +92,12 @@ export const currentIssuesAtom = pipe(
   issueSourceRuntime.atom(
     Effect.fnUntraced(function* (get) {
       const source = yield* IssueSource
-      const issues = yield* source.issues
+      const issues = yield* source.issues.pipe(
+        Effect.withSpan("currentIssuesAtom.refresh"),
+      )
       const handle = setTimeout(() => {
         get.refreshSelf()
-      }, 30000)
+      }, 30_000)
       get.addFinalizer(() => clearTimeout(handle))
       return issues
     }),

package/src/cli.ts

@@ -15,7 +15,7 @@ import PackageJson from "../package.json" with { type: "json" }
 import { resetCurrentIssueSource } from "./IssueSources.ts"
 import { TracingLayer } from "./Tracing.ts"
 import { MinimumLogLevel } from "effect/References"
-import { lalphMemoMap } from "./shared/runtime.ts"
+import { atomRuntime, lalphMemoMap } from "./shared/runtime.ts"
 import { PlatformServices } from "./shared/platform.ts"
 
 commandRoot.pipe(
@@ -37,13 +37,15 @@ commandRoot.pipe(
   ),
   Command.provide(Settings.layer),
   Command.provide(TracingLayer),
-  Command.provide(({ verbose }) =>
-    verbose ? Layer.succeed(MinimumLogLevel, "All") : Layer.empty,
-  ),
-  (_) =>
-    Command.run(_, {
-      version: PackageJson.version,
-    }),
+  Command.provide(({ verbose }) => {
+    if (!verbose) return Layer.empty
+    const logLevel = Layer.succeed(MinimumLogLevel, "All")
+    atomRuntime.addGlobalLayer(logLevel)
+    return logLevel
+  }),
+  Command.run({
+    version: PackageJson.version,
+  }),
   Effect.provide(PlatformServices),
   Effect.provideService(Layer.CurrentMemoMap, lalphMemoMap),
   NodeRuntime.runMain,

package/src/commands/root.ts

@@ -74,6 +74,7 @@ const run = Effect.fnUntraced(
       }
     }
     if (gitFlow.branch) {
+      yield* worktree.exec`git branch -D ${gitFlow.branch}`
       yield* worktree.exec`git checkout -b ${gitFlow.branch}`
     }
 

package/src/domain/CliAgent.ts

@@ -28,7 +28,7 @@ const opencode = new CliAgent({
     ChildProcess.make({
       extendEnv: true,
       env: {
-        OPENCODE_PERMISSION: '{"*":"allow"}',
+        OPENCODE_PERMISSION: '{"*":"allow", "question":"deny"}',
       },
       stdout: "pipe",
       stderr: "pipe",

package/src/shared/runtime.ts

@@ -1,6 +1,9 @@
 import { Layer } from "effect"
 import { Atom } from "effect/unstable/reactivity"
+import { TracingLayer } from "../Tracing.ts"
 
 export const lalphMemoMap = Layer.makeMemoMapUnsafe()
 
-export const makeAtomRuntime = Atom.context({ memoMap: lalphMemoMap })
+export const atomRuntime = Atom.context({ memoMap: lalphMemoMap })
+
+atomRuntime.addGlobalLayer(TracingLayer)