flowcat 1.3.0 → 1.5.0

package/core/time.ts

@@ -0,0 +1,63 @@
+import { DateTime } from "luxon";
+
+const DEFAULT_ZONE = "Europe/Paris";
+
+type ListDateScope = "today" | "yesterday" | "this_week" | "last_week";
+
+const toIsoDate = (value: DateTime, label: string): string => {
+  const date = value.toISODate();
+  if (!date) {
+    throw new Error(`Failed to generate ${label} date`);
+  }
+  return date;
+};
+
+const buildDateRange = (start: DateTime, end: DateTime): string[] => {
+  const dates: string[] = [];
+  let cursor = start.startOf("day");
+  const final = end.startOf("day");
+
+  while (cursor <= final) {
+    dates.push(toIsoDate(cursor, "range"));
+    cursor = cursor.plus({ days: 1 });
+  }
+
+  return dates;
+};
+
+export const nowIso = (): string => {
+  const value = DateTime.now().setZone(DEFAULT_ZONE).toISO();
+  if (!value) {
+    throw new Error("Failed to generate timestamp");
+  }
+  return value;
+};
+
+export const todayDate = (date?: string): string => {
+  const value = date
+    ? DateTime.fromISO(date, { zone: DEFAULT_ZONE }).toISODate()
+    : DateTime.now().setZone(DEFAULT_ZONE).toISODate();
+
+  if (!value) {
+    throw new Error("Failed to generate date");
+  }
+
+  return value;
+};
+
+export const listDatesForScope = (scope: ListDateScope): string[] => {
+  const now = DateTime.now().setZone(DEFAULT_ZONE);
+
+  switch (scope) {
+    case "today":
+      return [toIsoDate(now, "today")];
+    case "yesterday":
+      return [toIsoDate(now.minus({ days: 1 }), "yesterday")];
+    case "this_week":
+      return buildDateRange(now.startOf("week"), now.endOf("week"));
+    case "last_week": {
+      const lastWeek = now.minus({ weeks: 1 });
+      return buildDateRange(lastWeek.startOf("week"), lastWeek.endOf("week"));
+    }
+  }
+};

package/core/types.ts

@@ -0,0 +1,7 @@
+export const taskStatuses = ["backlog", "active", "paused", "completed", "cancelled"] as const;
+export const taskTypes = ["regular", "review"] as const;
+export const taskActions = ["start", "pause", "complete", "cancel"] as const;
+
+export type TaskStatus = (typeof taskStatuses)[number];
+export type TaskType = (typeof taskTypes)[number];
+export type TaskAction = (typeof taskActions)[number];

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);
+};