flowcat 1.3.0 → 1.4.4

package/core/workspace.ts

@@ -0,0 +1,133 @@
+import { access, mkdir } from "node:fs/promises";
+import { homedir } from "node:os";
+import path from "node:path";
+
+import { configFileExists, resolveGlobalConfigPath, resolveWorkspaceConfigPath } from "./config";
+import { APP_DIR, APP_NAME, LOCK_DIR, PLUGINS_DIR, STATUS_ORDER, TASKS_DIR } from "./constants";
+import { writeJsonAtomic } from "./json";
+
+export type WorkspaceKind = "explicit" | "global" | "repo";
+
+export type Workspace = {
+  root: string;
+  kind: WorkspaceKind;
+};
+
+const exists = async (filePath: string): Promise<boolean> => {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export const findGitRoot = async (startDir: string): Promise<string | null> => {
+  let current = path.resolve(startDir);
+
+  while (true) {
+    if (await exists(path.join(current, ".git"))) {
+      return current;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+
+    current = parent;
+  }
+};
+
+export const resolveGlobalWorkspaceRoot = (): string => {
+  const dataHome = process.env.XDG_DATA_HOME ?? path.join(homedir(), ".local", "share");
+  return path.join(dataHome, APP_NAME);
+};
+
+export type WorkspaceOptions = {
+  store?: string;
+  global?: boolean;
+  repo?: boolean;
+  cwd?: string;
+};
+
+export const resolveWorkspace = async (options: WorkspaceOptions): Promise<Workspace> => {
+  if (options.store) {
+    return { root: path.resolve(options.store), kind: "explicit" };
+  }
+
+  const cwd = options.cwd ?? process.cwd();
+  const repoRoot = await findGitRoot(cwd);
+
+  if (options.repo) {
+    if (!repoRoot) {
+      throw new Error("Not inside a git repository");
+    }
+
+    return { root: path.join(repoRoot, APP_DIR), kind: "repo" };
+  }
+
+  if (options.global) {
+    return { root: resolveGlobalWorkspaceRoot(), kind: "global" };
+  }
+
+  if (repoRoot) {
+    const repoWorkspace = path.join(repoRoot, APP_DIR);
+    if (await exists(repoWorkspace)) {
+      return { root: repoWorkspace, kind: "repo" };
+    }
+  }
+
+  return { root: resolveGlobalWorkspaceRoot(), kind: "global" };
+};
+
+export const isWorkspaceInitialized = async (workspace: Workspace): Promise<boolean> => {
+  const tasksPath = path.join(workspace.root, TASKS_DIR);
+  const hasTasksDir = await exists(tasksPath);
+  if (!hasTasksDir) {
+    return false;
+  }
+
+  const configPath =
+    workspace.kind === "global"
+      ? resolveGlobalConfigPath()
+      : resolveWorkspaceConfigPath(workspace.root);
+  return configFileExists(configPath);
+};
+
+export const ensureWorkspaceLayout = async (workspaceRoot: string): Promise<void> => {
+  await mkdir(path.join(workspaceRoot, TASKS_DIR), { recursive: true });
+  await mkdir(path.join(workspaceRoot, LOCK_DIR), { recursive: true });
+  await mkdir(path.join(workspaceRoot, PLUGINS_DIR), { recursive: true });
+
+  await Promise.all(
+    STATUS_ORDER.map((status) =>
+      mkdir(path.join(workspaceRoot, TASKS_DIR, status), { recursive: true }),
+    ),
+  );
+
+  // Create plugins/package.json if it doesn't exist
+  await ensurePluginsPackageJson(workspaceRoot);
+};
+
+/**
+ * Ensure plugins directory has a package.json for TypeScript plugin development
+ */
+export const ensurePluginsPackageJson = async (workspaceRoot: string): Promise<void> => {
+  const packageJsonPath = path.join(workspaceRoot, PLUGINS_DIR, "package.json");
+
+  if (await exists(packageJsonPath)) {
+    return;
+  }
+
+  const packageJson = {
+    name: "flowcat-plugins",
+    type: "module",
+    private: true,
+    dependencies: {
+      flowcat: "^1.4.0",
+    },
+  };
+
+  await writeJsonAtomic(packageJsonPath, packageJson);
+};