lalph 0.1.112 → 0.1.114

package/dist/cli.mjs

@@ -142414,6 +142414,26 @@ const LinearIssueSource = effect$1(IssueSource, gen(function* () {
 			const linearIssueId = identifierMap.get(issueId);
 			yield* linear.use((c) => c.updateIssue(linearIssueId, { stateId: canceledState.id }));
 		}, mapError$2((cause) => new IssueSourceError({ cause }))),
+		status: gen(function* () {
+			const label = labelId;
+			const autoMergeLabel = autoMergeLabelId;
+			const teams = yield* runCollect(linear.stream(() => project.teams()));
+			const labels = yield* runCollect(linear.labels);
+			const teamName = teams.find((team) => team.id === teamId)?.name ?? teamId;
+			const resolveLabel = (value) => match$7(value, {
+				onNone: () => "None",
+				onSome: (id) => labels.find((label) => label.id === id)?.name ?? id
+			});
+			const resolveAutoMergeLabel = (value) => match$7(value, {
+				onNone: () => "Disabled",
+				onSome: (id) => labels.find((label) => label.id === id)?.name ?? id
+			});
+			console.log(`Issue source: Linear`);
+			console.log(`Project: ${project.name}`);
+			console.log(`Team: ${teamName}`);
+			console.log(`Label filter: ${resolveLabel(label)}`);
+			console.log(`Auto-merge label: ${resolveAutoMergeLabel(autoMergeLabel)}`);
+		}).pipe(mapError$2((cause) => new IssueSourceError({ cause }))),
 		ensureInProgress: () => void_$1
 	});
 })).pipe(provide$3([Linear.layer, layer$17]));
@@ -148959,6 +148979,18 @@ const GithubIssueSource = effect$1(IssueSource, gen(function* () {
 				state: "closed"
 			});
 		}, mapError$2((cause) => new IssueSourceError({ cause }))),
+		status: sync(() => {
+			console.log(`Issue source: GitHub Issues`);
+			console.log(`Repository: ${cli.owner}/${cli.repo}`);
+			console.log(`Label filter: ${match$7(labelFilter, {
+				onNone: () => "None",
+				onSome: (value) => value
+			})}`);
+			console.log(`Auto-merge label: ${match$7(autoMergeLabelName, {
+				onNone: () => "Disabled",
+				onSome: (value) => value
+			})}`);
+		}),
 		ensureInProgress: fnUntraced(function* (issueId) {
 			const issueNumber = Number(issueId.slice(1));
 			yield* pipe(github.request((rest) => rest.issues.get({
@@ -149003,10 +149035,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 +149090,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* () {
@@ -149044,6 +149113,9 @@ const getOrSelectIssueSource = gen(function* () {
 const resetCurrentIssueSource = gen(function* () {
 	yield* (yield* getOrSelectIssueSource).reset;
 });
+const statusCurrentIssueSource = gen(function* () {
+	yield* (yield* IssueSource).status;
+});
 var CurrentIssueSource = class CurrentIssueSource extends Service()("lalph/CurrentIssueSource") {
 	static layer = effectServices(gen(function* () {
 		const source = yield* getOrSelectIssueSource;
@@ -149051,15 +149123,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 +149981,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;
@@ -150196,44 +150271,12 @@ const commandShell = make$34("shell").pipe(withDescription("Enter an interactive
 const commandSource = make$34("source").pipe(withDescription("Select the issue source to use"), withHandler(() => selectIssueSource), provide(Settings.layer));
 
 //#endregion
-//#region package.json
-var version = "0.1.112";
+//#region src/commands/status.ts
+const commandStatus = make$34("status").pipe(withDescription("Show the selected issue source options"), withHandler(() => statusCurrentIssueSource), provide(Settings.layer), provide(CurrentIssueSource.layer));
 
 //#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));
+//#region package.json
+var version = "0.1.114";
 
 //#endregion
 //#region src/cli.ts
@@ -150243,10 +150286,16 @@ commandRoot.pipe(withSubcommands([
 	commandEdit,
 	commandShell,
 	commandSource,
+	commandStatus,
 	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.112",
+  "version": "0.1.114",
   "publishConfig": {
     "access": "public"
   },

package/src/Github.ts

@@ -382,6 +382,22 @@ export const GithubIssueSource = Layer.effect(
         },
         Effect.mapError((cause) => new IssueSourceError({ cause })),
       ),
+      status: Effect.sync(() => {
+        console.log(`Issue source: GitHub Issues`)
+        console.log(`Repository: ${cli.owner}/${cli.repo}`)
+        console.log(
+          `Label filter: ${Option.match(labelFilter, {
+            onNone: () => "None",
+            onSome: (value) => value,
+          })}`,
+        )
+        console.log(
+          `Auto-merge label: ${Option.match(autoMergeLabelName, {
+            onNone: () => "Disabled",
+            onSome: (value) => value,
+          })}`,
+        )
+      }),
       ensureInProgress: Effect.fnUntraced(
         function* (issueId: string) {
           const issueNumber = Number(issueId.slice(1))

package/src/IssueSource.ts

@@ -24,6 +24,8 @@ export class IssueSource extends ServiceMap.Service<
       issueId: string,
     ) => Effect.Effect<void, IssueSourceError>
 
+    readonly status: Effect.Effect<void, IssueSourceError>
+
     readonly ensureInProgress: (
       issueId: string,
     ) => Effect.Effect<void, IssueSourceError>

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}`,
   },
 ]
 
@@ -57,6 +57,11 @@ export const resetCurrentIssueSource = Effect.gen(function* () {
   yield* source.reset
 })
 
+export const statusCurrentIssueSource = Effect.gen(function* () {
+  const service = yield* IssueSource
+  yield* service.status
+})
+
 export class CurrentIssueSource extends ServiceMap.Service<
   CurrentIssueSource,
   {
@@ -92,10 +97,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/Linear.ts

@@ -403,6 +403,33 @@ export const LinearIssueSource = Layer.effect(
         },
         Effect.mapError((cause) => new IssueSourceError({ cause })),
       ),
+      status: Effect.gen(function* () {
+        const label = labelId
+        const autoMergeLabel = autoMergeLabelId
+        const teams = yield* Stream.runCollect(
+          linear.stream(() => project.teams()),
+        )
+        const labels = yield* Stream.runCollect(linear.labels)
+        const teamName =
+          teams.find((team) => team.id === teamId)?.name ?? teamId
+        const resolveLabel = (value: Option.Option<string>) =>
+          Option.match(value, {
+            onNone: () => "None",
+            onSome: (id) => labels.find((label) => label.id === id)?.name ?? id,
+          })
+        const resolveAutoMergeLabel = (value: Option.Option<string>) =>
+          Option.match(value, {
+            onNone: () => "Disabled",
+            onSome: (id) => labels.find((label) => label.id === id)?.name ?? id,
+          })
+        console.log(`Issue source: Linear`)
+        console.log(`Project: ${project.name}`)
+        console.log(`Team: ${teamName}`)
+        console.log(`Label filter: ${resolveLabel(label)}`)
+        console.log(
+          `Auto-merge label: ${resolveAutoMergeLabel(autoMergeLabel)}`,
+        )
+      }).pipe(Effect.mapError((cause) => new IssueSourceError({ cause }))),
       // linear api writes and reflected immediately in reads, so no-op
       ensureInProgress: () => Effect.void,
     })

package/src/cli.ts

@@ -10,12 +10,13 @@ import { commandIssue } from "./commands/issue.ts"
 import { commandEdit } from "./commands/edit.ts"
 import { commandShell } from "./commands/shell.ts"
 import { commandSource } from "./commands/source.ts"
+import { commandStatus } from "./commands/status.ts"
 import { commandAgent } from "./commands/agent.ts"
 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(
@@ -25,6 +26,7 @@ commandRoot.pipe(
     commandEdit,
     commandShell,
     commandSource,
+    commandStatus,
     commandAgent,
   ]),
   // Common flags are handled here
@@ -37,13 +39,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/commands/status.ts

@@ -0,0 +1,13 @@
+import { Command } from "effect/unstable/cli"
+import {
+  CurrentIssueSource,
+  statusCurrentIssueSource,
+} from "../IssueSources.ts"
+import { Settings } from "../Settings.ts"
+
+export const commandStatus = Command.make("status").pipe(
+  Command.withDescription("Show the selected issue source options"),
+  Command.withHandler(() => statusCurrentIssueSource),
+  Command.provide(Settings.layer),
+  Command.provide(CurrentIssueSource.layer),
+)

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)