t3code-cli 0.5.1 → 0.6.0

package/src/domain/helpers.ts

@@ -1,27 +1,38 @@
-import type * as Path from "effect/Path";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
 import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "#t3tools/contracts";
 
-import { ProjectLookupError } from "./error.ts";
+export type ResolvedProjectScope = {
+  readonly project: OrchestrationProjectShell;
+  readonly inferredWorktreePath?: string;
+};
 
-export function resolveProject(
+export const resolveProjectScope = Effect.fn("resolveProjectScope")(function* (
   snapshot: OrchestrationShellSnapshot,
-  ref: string,
-  path: Path.Path,
-  cwd: string,
+  input: {
+    readonly ref: string;
+    readonly cwd: string;
+  },
 ) {
-  const byId = findProjectById(snapshot, ref);
+  const absoluteRef = yield* resolveAbsolutePath(input.ref, input.cwd);
+
+  const byId = findProjectById(snapshot, input.ref);
   if (byId !== null) {
-    return byId;
+    return { project: byId };
   }
-  const absolute = path.resolve(cwd, ref);
-  const byPath = snapshot.projects.find(
-    (project) => path.resolve(cwd, project.workspaceRoot) === absolute,
-  );
-  if (byPath !== undefined) {
-    return byPath;
+
+  const byExactPath = yield* findProjectByWorkspaceRoot(snapshot, absoluteRef, input.cwd);
+  if (byExactPath !== undefined) {
+    return { project: byExactPath };
   }
-  throw new ProjectLookupError({ message: `project not found: ${ref}`, ref });
-}
+
+  const byAncestor = yield* findProjectByAncestorPath(snapshot, absoluteRef, input.cwd);
+  if (byAncestor !== undefined) {
+    return byAncestor;
+  }
+
+  return yield* findProjectByKnownWorktreePath(snapshot, absoluteRef, input.cwd);
+});
 
 export function findProjectById(
   snapshot: OrchestrationShellSnapshot,
@@ -29,3 +40,112 @@ export function findProjectById(
 ): OrchestrationProjectShell | null {
   return snapshot.projects.find((project) => project.id === projectId) ?? null;
 }
+
+const resolveAbsolutePath = Effect.fn("resolveAbsolutePath")(function* (ref: string, cwd: string) {
+  const path = yield* Path.Path;
+  return path.isAbsolute(ref) ? path.normalize(ref) : path.normalize(path.resolve(cwd, ref));
+});
+
+const isDescendantPath = Effect.fn("isDescendantPath")(function* (parent: string, child: string) {
+  const path = yield* Path.Path;
+  if (child === parent) {
+    return true;
+  }
+  const relative = path.relative(parent, child);
+  return relative.length > 0 && !relative.startsWith("..") && !path.isAbsolute(relative);
+});
+
+const findProjectByWorkspaceRoot = Effect.fn("findProjectByWorkspaceRoot")(function* (
+  snapshot: OrchestrationShellSnapshot,
+  absolutePath: string,
+  cwd: string,
+) {
+  for (const project of snapshot.projects) {
+    const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
+    if (workspaceRoot === absolutePath) {
+      return project;
+    }
+  }
+  return undefined;
+});
+
+const findProjectByAncestorPath = Effect.fn("findProjectByAncestorPath")(function* (
+  snapshot: OrchestrationShellSnapshot,
+  absolutePath: string,
+  cwd: string,
+) {
+  let bestProject: OrchestrationProjectShell | undefined;
+  let bestWorkspaceRoot = "";
+
+  for (const project of snapshot.projects) {
+    const workspaceRoot = yield* resolveAbsolutePath(project.workspaceRoot, cwd);
+    if (!(yield* isDescendantPath(workspaceRoot, absolutePath))) {
+      continue;
+    }
+    if (workspaceRoot.length > bestWorkspaceRoot.length) {
+      bestProject = project;
+      bestWorkspaceRoot = workspaceRoot;
+    }
+  }
+
+  if (bestProject === undefined) {
+    return undefined;
+  }
+
+  if (absolutePath === bestWorkspaceRoot) {
+    return { project: bestProject };
+  }
+
+  return {
+    project: bestProject,
+    inferredWorktreePath: absolutePath,
+  };
+});
+
+const findProjectByKnownWorktreePath = Effect.fn("findProjectByKnownWorktreePath")(function* (
+  snapshot: OrchestrationShellSnapshot,
+  absolutePath: string,
+  cwd: string,
+) {
+  const projectsById = new Map(snapshot.projects.map((project) => [project.id, project]));
+  let bestProject: OrchestrationProjectShell | undefined;
+  let bestKnownPath = "";
+
+  for (const thread of snapshot.threads) {
+    if (thread.worktreePath === null) {
+      continue;
+    }
+    const project = projectsById.get(thread.projectId);
+    if (project === undefined) {
+      continue;
+    }
+    const knownPath = yield* resolveAbsolutePath(thread.worktreePath, cwd);
+    if (!(yield* isDescendantPath(knownPath, absolutePath))) {
+      continue;
+    }
+    if (knownPath.length > bestKnownPath.length) {
+      bestProject = project;
+      bestKnownPath = knownPath;
+    }
+  }
+
+  if (bestProject === undefined) {
+    return undefined;
+  }
+
+  const workspaceRoot = yield* resolveAbsolutePath(bestProject.workspaceRoot, cwd);
+  if (absolutePath === workspaceRoot) {
+    return { project: bestProject };
+  }
+
+  if (absolutePath === bestKnownPath) {
+    return bestKnownPath === workspaceRoot
+      ? { project: bestProject }
+      : { project: bestProject, inferredWorktreePath: bestKnownPath };
+  }
+
+  return {
+    project: bestProject,
+    inferredWorktreePath: absolutePath,
+  };
+});

package/src/index.ts

@@ -1,92 +1,9 @@
-export { T3Application } from "./application/service.ts";
+export { T3Application } from "./application/index.ts";
 export type {
   SendThreadInput,
   StartThreadInput,
   StartThreadPolicy,
   WaitEvent,
-} from "./application/service.ts";
-export type { ApplicationError } from "./application/error.ts";
-export { T3Auth } from "./auth/service.ts";
-export { T3AuthLive, makeT3Auth } from "./auth/layer.ts";
-export { T3LocalAuth, T3LocalAuthLive, makeT3LocalAuth } from "./auth/local.ts";
-export {
-  T3LocalAuthOrigin,
-  T3LocalAuthOriginLive,
-  makeT3LocalAuthOrigin,
-} from "./auth/local-origin.ts";
-export {
-  T3LocalAuthToken,
-  T3LocalAuthTokenLive,
-  makeT3LocalAuthToken,
-} from "./auth/local-token.ts";
-export {
-  T3AuthPairing,
-  T3AuthPairingLive,
-  makeT3AuthPairing,
-  parsePairingUrl,
-} from "./auth/pairing.ts";
-export {
-  AuthConfigError,
-  AuthLocalDatabaseError,
-  AuthLocalError,
-  AuthLocalSecretError,
-  AuthLocalSigningError,
-  AuthPairingUrlError,
-  AuthTransportError,
-} from "./auth/error.ts";
-export type { AuthError } from "./auth/error.ts";
-export type { AuthSessionState, AuthWebSocketTicketResult } from "./auth/schema.ts";
-export type {
-  AuthConfigInput,
-  AuthSessionRole,
-  LocalAuthInput,
-  LocalAuthOriginInput,
-  LocalAuthResult,
-  LocalAuthTokenInput,
-  LocalAuthTokenResult,
-  PairingUrl,
-  PairResult,
-} from "./auth/type.ts";
-export { T3Config } from "./config/service.ts";
-export type { ResolvedConfig, StoredConfig } from "./config/service.ts";
-export { T3ConfigLive, makeT3Config } from "./config/layer.ts";
-export { ConfigError, UrlError } from "./config/error.ts";
-export type { ConfigServiceError } from "./config/error.ts";
-export {
-  makeT3CodeConnectionProvider,
-  makeT3CodeRpcLayer,
-  T3CodeConnectionProvider,
-  T3CodeConnectionProviderLive,
-  T3CodeNodeRpcLayer,
-  T3CodeRpcLayer,
-  T3CodeConnectionError,
-} from "./connection.ts";
-export type { T3CodeAuth, T3CodeConnection, T3CodeOrigin } from "./connection.ts";
-export { Environment } from "./environment/service.ts";
-export type { EnvironmentShape } from "./environment/service.ts";
-export { NodeEnvironmentLive } from "./environment/layer.ts";
-export {
-  AppLayer,
-  AuthAppLayer,
-  T3AuthLayer,
-  T3AuthPairingLayer,
-  T3AuthTransportLayer,
-  T3LocalAuthLayer,
-  T3LocalAuthOriginLayer,
-  T3LocalAuthTokenLayer,
-} from "./runtime.ts";
-export { SqlClientFactory } from "./sql/service.ts";
-export type { SqlClientFactoryShape, SqliteClientConfig } from "./sql/service.ts";
-export {
-  NodeSqlClientFactoryLive,
-  NodeSqliteClientLive,
-  makeNodeSqliteClient,
-} from "./sql/node-sqlite-client.ts";
-export type {
-  OrchestrationMessage,
-  OrchestrationProjectShell,
-  OrchestrationShellSnapshot,
-  OrchestrationThread,
-  OrchestrationThreadShell,
-  ServerProvider,
-} from "#t3tools/contracts";
+} from "./application/index.ts";
+export type { ApplicationError } from "./application/index.ts";
+export { AppLayer, AuthAppLayer } from "./runtime/index.ts";

package/src/layout/base-dir.ts

@@ -0,0 +1,35 @@
+import { homedir } from "node:os";
+import * as Effect from "effect/Effect";
+import * as Path from "effect/Path";
+
+export type T3Layout = {
+  readonly cwd: string;
+  readonly homeDir: string;
+  readonly t3codeHome?: string | undefined;
+};
+
+export function readT3LayoutFromNodeProcess(): T3Layout {
+  return {
+    cwd: process.cwd(),
+    homeDir: homedir(),
+    t3codeHome: process.env["T3CODE_HOME"],
+  };
+}
+
+export const resolveT3BaseDir = Effect.fn("resolveT3BaseDir")(function* (input: {
+  readonly layout: T3Layout;
+  readonly baseDir?: string | undefined;
+}) {
+  const path = yield* Path.Path;
+  const raw = input.baseDir ?? input.layout.t3codeHome;
+  if (raw === undefined || raw.length === 0) {
+    return path.join(input.layout.homeDir, ".t3");
+  }
+  if (raw === "~") {
+    return input.layout.homeDir;
+  }
+  if (raw.startsWith("~/") || raw.startsWith("~\\")) {
+    return path.join(input.layout.homeDir, raw.slice(2));
+  }
+  return path.resolve(input.layout.cwd, raw);
+});

package/src/layout/index.ts

@@ -0,0 +1 @@
+export { readT3LayoutFromNodeProcess, resolveT3BaseDir, type T3Layout } from "./base-dir.ts";

package/src/orchestration/index.ts

@@ -0,0 +1,7 @@
+export {
+  T3Orchestration,
+  type OpenThread,
+  type Orchestration,
+  type OrchestrationError,
+} from "./service.ts";
+export { T3OrchestrationLayer } from "../runtime/layer.ts";

package/src/rpc/index.ts

@@ -0,0 +1 @@
+export { RpcError, type OrchestrationError } from "./error.ts";

package/src/runtime/index.ts

@@ -0,0 +1,12 @@
+export {
+  AppLayer,
+  AuthAppLayer,
+  T3AuthLayer,
+  T3AuthPairingLayer,
+  T3AuthTransportLayer,
+  T3LocalAuthLayer,
+  T3LocalAuthOriginLayer,
+  T3LocalAuthTokenLayer,
+  T3OrchestrationLayer,
+} from "./layer.ts";
+export { NodeEnvironmentLive } from "../environment/layer.ts";

package/src/{runtime.ts → runtime/layer.ts}

@@ -3,20 +3,20 @@ import * as Layer from "effect/Layer";
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as NodeSocket from "@effect/platform-node/NodeSocket";
 
-import { T3AuthLive } from "./auth/layer.ts";
-import { T3LocalAuthLive } from "./auth/local.ts";
-import { T3LocalAuthOriginLive } from "./auth/local-origin.ts";
-import { T3LocalAuthTokenLive } from "./auth/local-token.ts";
-import { T3AuthPairingLive } from "./auth/pairing.ts";
-import { T3AuthTransportLive } from "./auth/transport.ts";
-import { T3CodeConnectionError } from "./connection/error.ts";
-import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "./connection/service.ts";
-import { T3ConfigLive } from "./config/layer.ts";
-import { T3Config } from "./config/service.ts";
-import { T3ApplicationLive } from "./application/layer.ts";
-import { T3OrchestrationLive } from "./orchestration/layer.ts";
-import { T3RpcLive } from "./rpc/layer.ts";
-import { NodeSqlClientFactoryLive } from "./sql/node-sqlite-client.ts";
+import { T3ApplicationLive } from "../application/layer.ts";
+import { T3AuthLive } from "../auth/layer.ts";
+import { T3LocalAuthLive } from "../auth/local.ts";
+import { T3LocalAuthOriginLive } from "../auth/local-origin.ts";
+import { T3LocalAuthTokenLive } from "../auth/local-token.ts";
+import { T3AuthPairingLive } from "../auth/pairing.ts";
+import { T3AuthTransportLive } from "../auth/transport.ts";
+import { T3ConfigLive } from "../config/layer.ts";
+import { T3Config } from "../config/service.ts";
+import { T3CodeConnectionError } from "../connection/error.ts";
+import { T3CodeConnectionProvider, makeT3CodeConnectionProvider } from "../connection/service.ts";
+import { T3OrchestrationLive } from "../orchestration/layer.ts";
+import { T3RpcLive } from "../rpc/layer.ts";
+import { NodeSqlClientFactoryLive } from "../sql/node-sqlite-client.ts";
 
 export const T3AuthTransportLayer = T3AuthTransportLive.pipe(
   Layer.provide(NodeHttpClient.layerUndici),
@@ -65,7 +65,7 @@ const T3RpcLayer = T3RpcLive.pipe(
     ),
   ),
 );
-const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
+export const T3OrchestrationLayer = T3OrchestrationLive.pipe(Layer.provide(T3RpcLayer));
 const T3ApplicationLayer = T3ApplicationLive.pipe(Layer.provide(T3OrchestrationLayer));
 
 export const AuthAppLayer = Layer.mergeAll(T3ConfigLive, T3AuthLayer);

package/src/scope/index.ts

@@ -0,0 +1,6 @@
+export {
+  resolveCommandProjectRef,
+  resolveProjectRef,
+  resolveThreadId,
+  resolveWorktreePath,
+} from "./resolve.ts";

package/src/scope/resolve.ts

@@ -0,0 +1,62 @@
+export function resolveProjectRef(input: {
+  readonly value: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}): string | undefined {
+  if (input.value !== undefined && input.value.length > 0) {
+    return input.value;
+  }
+  const fromRoot = input.env.T3CODE_PROJECT_ROOT;
+  if (fromRoot !== undefined && fromRoot.length > 0) {
+    return fromRoot;
+  }
+  const fromId = input.env.T3CODE_PROJECT_ID;
+  if (fromId !== undefined && fromId.length > 0) {
+    return fromId;
+  }
+  return undefined;
+}
+
+export function resolveCommandProjectRef(input: {
+  readonly value: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly cwd: string;
+  readonly isLocal?: boolean;
+}): string | undefined {
+  const explicit = resolveProjectRef({ value: input.value, env: input.env });
+  if (explicit !== undefined) {
+    return explicit;
+  }
+  if (input.isLocal ?? false) {
+    return input.cwd;
+  }
+  return undefined;
+}
+
+export function resolveWorktreePath(input: {
+  readonly value: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+  readonly inferred?: string;
+}): string | undefined {
+  if (input.value !== undefined && input.value.length > 0) {
+    return input.value;
+  }
+  const fromEnv = input.env.T3CODE_WORKTREE_PATH;
+  if (fromEnv !== undefined && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return input.inferred;
+}
+
+export function resolveThreadId(input: {
+  readonly value: string | undefined;
+  readonly env: Readonly<Record<string, string | undefined>>;
+}): string | undefined {
+  if (input.value !== undefined && input.value.length > 0) {
+    return input.value;
+  }
+  const fromEnv = input.env.T3CODE_THREAD_ID;
+  if (fromEnv !== undefined && fromEnv.length > 0) {
+    return fromEnv;
+  }
+  return undefined;
+}

package/src/t3tools/index.ts

@@ -0,0 +1 @@
+export * from "#t3tools/contracts";