flowcat 1.7.0 → 1.8.0

package/core/addTask.ts

@@ -1,10 +1,8 @@
 import { z } from "zod";
 
-import { resolveGithubToken } from "./config";
 import { withWorkspaceLock } from "./lock";
 import { emitHook } from "./pluginManager";
 import { buildPrAttachment, fetchGitHubPr, parseGitHubPrUrl } from "./pr";
-import type { PrFetched } from "./schemas/pr";
 import type { Task } from "./schemas/task";
 import { taskSchema } from "./schemas/task";
 import { buildTask } from "./taskFactory";
@@ -59,15 +57,7 @@ export const addTask = async (input: AddTaskInput): Promise<AddTaskResult> => {
     if (parsedInput.url) {
       const parsed = parseGitHubPrUrl(parsedInput.url);
       if (parsed) {
-        const token = await resolveGithubToken(parsedInput.workspaceRoot);
-        let fetched: PrFetched | null = null;
-        if (token) {
-          try {
-            fetched = await fetchGitHubPr(parsed, token);
-          } catch {
-            fetched = null;
-          }
-        }
+        const fetched = await fetchGitHubPr(parsed);
         prAttachment = buildPrAttachment(parsed, fetched ?? undefined);
         prTitle = fetched?.title ?? `PR #${parsed.number} ${parsed.repo.owner}/${parsed.repo.name}`;
       } else {

package/core/config.ts

@@ -1,10 +1,8 @@
-import { access, mkdir, readFile } from "node:fs/promises";
+import { access, mkdir } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 
-import { parse as parseEnv } from "dotenv";
-
-import { APP_NAME, ENV_FILE } from "./constants";
+import { APP_NAME } from "./constants";
 import { readJsonFile, writeJsonAtomic } from "./json";
 
 export type PluginEntry = {
@@ -36,9 +34,6 @@ export type PluginsConfig = {
 
 export type AppConfig = {
   autoCommit?: boolean;
-  github?: {
-    token?: string;
-  };
   plugins?: PluginsConfig;
 };
 
@@ -92,60 +87,3 @@ export const resolveAutoCommitEnabled = async (workspaceRoot: string): Promise<b
   const globalConfig = await readConfigFile(resolveGlobalConfigPath());
   return globalConfig.autoCommit ?? false;
 };
-
-export const resolveWorkspaceEnvPath = (workspaceRoot: string): string => {
-  return path.join(workspaceRoot, ENV_FILE);
-};
-
-export const resolveGlobalEnvPath = (): string => {
-  const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homedir(), ".config");
-  return path.join(configHome, APP_NAME, ENV_FILE);
-};
-
-/**
- * Read and parse an env file, returning empty object if file doesn't exist
- */
-export const readEnvFile = async (filePath: string): Promise<Record<string, string>> => {
-  if (!(await configFileExists(filePath))) {
-    return {};
-  }
-
-  try {
-    const content = await readFile(filePath, "utf8");
-    return parseEnv(content);
-  } catch {
-    return {};
-  }
-};
-
-export const resolveGithubToken = async (workspaceRoot: string): Promise<string | null> => {
-  // 1. Check environment variables first
-  if (process.env.FLOWCAT_GITHUB_TOKEN) {
-    return process.env.FLOWCAT_GITHUB_TOKEN;
-  }
-
-  if (process.env.IL_GITHUB_TOKEN) {
-    return process.env.IL_GITHUB_TOKEN;
-  }
-
-  // 2. Check workspace .env file
-  const workspaceEnv = await readEnvFile(resolveWorkspaceEnvPath(workspaceRoot));
-  if (workspaceEnv.GITHUB_TOKEN) {
-    return workspaceEnv.GITHUB_TOKEN;
-  }
-
-  // 3. Check global .env file
-  const globalEnv = await readEnvFile(resolveGlobalEnvPath());
-  if (globalEnv.GITHUB_TOKEN) {
-    return globalEnv.GITHUB_TOKEN;
-  }
-
-  // 4. Fallback to config.json (for backwards compatibility)
-  const workspaceConfig = await readConfigFile(resolveWorkspaceConfigPath(workspaceRoot));
-  if (workspaceConfig.github?.token) {
-    return workspaceConfig.github.token;
-  }
-
-  const globalConfig = await readConfigFile(resolveGlobalConfigPath());
-  return globalConfig.github?.token ?? null;
-};

package/core/initFlow.ts

@@ -101,17 +101,12 @@ export const runInitFlow = async (options: InitFlowOptions): Promise<InitChoice>
   const currentConfig = await readConfigFile(configPath);
 
   const autoCommit = currentConfig.autoCommit ?? false;
-  const githubToken = currentConfig.github?.token ?? null;
 
   await ensureWorkspaceLayout(choice.workspaceRoot);
 
   await updateConfigFile(configPath, (current) => ({
     ...current,
     autoCommit,
-    github: {
-      ...current.github,
-      ...(githubToken ? { token: githubToken } : {}),
-    },
   }));
 
   if (choice.kind === "repo" && choice.repoRoot) {

package/core/pr.ts

@@ -1,8 +1,11 @@
-import { Octokit } from "octokit";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
 
 import type { PrAttachment, PrFetched } from "./schemas/pr";
 import { nowIso } from "./time";
 
+const execAsync = promisify(exec);
+
 export type ParsedPr = {
   url: string;
   provider: "github";
@@ -54,36 +57,31 @@ export const buildPrAttachment = (parsed: ParsedPr, fetched?: PrFetched): PrAtta
   };
 };
 
-export const fetchGitHubPr = async (
-  parsed: ParsedPr,
-  token?: string | null,
-): Promise<PrFetched | null> => {
+export const fetchGitHubPr = async (parsed: ParsedPr): Promise<PrFetched | null> => {
   if (!parsed.repo || !parsed.number) {
     return null;
   }
 
-  if (!token) {
-    return null;
-  }
-
-  const octokit = new Octokit({ auth: token });
-  const response = await octokit.rest.pulls.get({
-    owner: parsed.repo.owner,
-    repo: parsed.repo.name,
-    pull_number: parsed.number,
-  });
+  try {
+    const { stdout } = await execAsync(
+      `gh pr view ${parsed.url} --json title,author,state,isDraft,updatedAt`,
+    );
+    const data = JSON.parse(stdout);
 
-  const data = response.data;
-  const state = data.merged ? "merged" : data.state === "open" ? "open" : "closed";
+    // gh returns state as uppercase: "MERGED", "OPEN", "CLOSED"
+    const state = data.state.toLowerCase() as PrFetched["state"];
 
-  return {
-    at: nowIso(),
-    title: data.title,
-    author: {
-      login: data.user?.login ?? "unknown",
-    },
-    state,
-    draft: data.draft ?? false,
-    updated_at: data.updated_at,
-  };
+    return {
+      at: nowIso(),
+      title: data.title,
+      author: {
+        login: data.author.login,
+      },
+      state,
+      draft: data.isDraft,
+      updated_at: data.updatedAt,
+    };
+  } catch {
+    return null;
+  }
 };

package/core/prWorkflow.ts

@@ -1,4 +1,3 @@
-import { resolveGithubToken } from "./config";
 import { withWorkspaceLock } from "./lock";
 import { emitHook } from "./pluginManager";
 import { buildPrAttachment, fetchGitHubPr, parseGitHubPrUrl } from "./pr";
@@ -12,9 +11,9 @@ import { nowIso } from "./time";
 import type { TaskAction, TaskStatus } from "./types";
 
 export class PrWorkflowError extends Error {
-  code: "INVALID_PR_URL" | "MISSING_TOKEN";
+  code: "INVALID_PR_URL" | "FETCH_FAILED";
 
-  constructor(code: "INVALID_PR_URL" | "MISSING_TOKEN", message: string) {
+  constructor(code: "INVALID_PR_URL" | "FETCH_FAILED", message: string) {
     super(message);
     this.code = code;
     this.name = "PrWorkflowError";
@@ -69,15 +68,7 @@ export const attachPrToTask = async (input: {
       throw new PrWorkflowError("INVALID_PR_URL", "Invalid PR URL");
     }
 
-    const token = await resolveGithubToken(input.workspaceRoot);
-    let fetched: PrFetched | null = null;
-    if (token) {
-      try {
-        fetched = await fetchGitHubPr(parsed, token);
-      } catch {
-        fetched = null;
-      }
-    }
+    const fetched = await fetchGitHubPr(parsed);
     const stored = await resolveTask(input.workspaceRoot, input.identifier);
 
     const updated: Task = {
@@ -126,10 +117,12 @@ export const refreshPrForTask = async (input: {
       throw new Error("Invalid PR URL");
     }
 
-    const token = await resolveGithubToken(input.workspaceRoot);
-    const fetched = await fetchGitHubPr(parsed, token);
+    const fetched = await fetchGitHubPr(parsed);
     if (!fetched) {
-      throw new PrWorkflowError("MISSING_TOKEN", "No GitHub token configured");
+      throw new PrWorkflowError(
+        "FETCH_FAILED",
+        "Failed to fetch PR. Make sure gh CLI is installed and authenticated.",
+      );
     }
 
     const baseUpdated: Task = {