flowcat 1.6.3 → 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

@@ -34,9 +34,6 @@ export type PluginsConfig = {
 
 export type AppConfig = {
   autoCommit?: boolean;
-  github?: {
-    token?: string;
-  };
   plugins?: PluginsConfig;
 };
 
@@ -90,21 +87,3 @@ export const resolveAutoCommitEnabled = async (workspaceRoot: string): Promise<b
   const globalConfig = await readConfigFile(resolveGlobalConfigPath());
   return globalConfig.autoCommit ?? false;
 };
-
-export const resolveGithubToken = async (workspaceRoot: string): Promise<string | null> => {
-  if (process.env.FLOWCAT_GITHUB_TOKEN) {
-    return process.env.FLOWCAT_GITHUB_TOKEN;
-  }
-
-  if (process.env.IL_GITHUB_TOKEN) {
-    return process.env.IL_GITHUB_TOKEN;
-  }
-
-  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/constants.ts

@@ -4,5 +4,6 @@ export const LOCK_DIR = ".lock";
 export const LOCK_FILE = "store.lock";
 export const TASKS_DIR = "tasks";
 export const PLUGINS_DIR = "plugins";
+export const ENV_FILE = ".env";
 
 export const STATUS_ORDER = ["backlog", "active", "paused", "completed", "cancelled"] as const;

package/core/gitignore.ts

@@ -3,7 +3,7 @@ import path from "node:path";
 
 import { APP_DIR } from "./constants";
 
-const ignoredEntries = [`${APP_DIR}/.lock/`, `${APP_DIR}/config.json`];
+const ignoredEntries = [`${APP_DIR}/.lock/`];
 
 export const ensureWorkspaceIgnored = async (repoRoot: string): Promise<boolean> => {
   const gitignorePath = path.join(repoRoot, ".gitignore");

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 = {

package/core/workspace.ts

@@ -1,9 +1,9 @@
-import { access, mkdir } from "node:fs/promises";
+import { access, mkdir, writeFile } 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 { APP_DIR, APP_NAME, ENV_FILE, LOCK_DIR, PLUGINS_DIR, STATUS_ORDER, TASKS_DIR } from "./constants";
 import { writeJsonAtomic } from "./json";
 
 export type WorkspaceKind = "explicit" | "global" | "repo";
@@ -106,22 +106,24 @@ export const ensureWorkspaceLayout = async (workspaceRoot: string): Promise<void
     ),
   );
 
-  // Create plugins/package.json if it doesn't exist
-  await ensurePluginsPackageJson(workspaceRoot);
+  // Create package.json for TypeScript plugin development
+  await ensureWorkspacePackageJson(workspaceRoot);
+  // Create .gitignore for workspace-local files
+  await ensureWorkspaceGitignore(workspaceRoot);
 };
 
 /**
- * Ensure plugins directory has a package.json for TypeScript plugin development
+ * Ensure workspace 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");
+export const ensureWorkspacePackageJson = async (workspaceRoot: string): Promise<void> => {
+  const packageJsonPath = path.join(workspaceRoot, "package.json");
 
   if (await exists(packageJsonPath)) {
     return;
   }
 
   const packageJson = {
-    name: "flowcat-plugins",
+    name: "flowcat-workspace",
     type: "module",
     private: true,
     dependencies: {
@@ -131,3 +133,21 @@ export const ensurePluginsPackageJson = async (workspaceRoot: string): Promise<v
 
   await writeJsonAtomic(packageJsonPath, packageJson);
 };
+
+/**
+ * Ensure workspace has a .gitignore for local files that shouldn't be committed
+ */
+export const ensureWorkspaceGitignore = async (workspaceRoot: string): Promise<void> => {
+  const gitignorePath = path.join(workspaceRoot, ".gitignore");
+
+  if (await exists(gitignorePath)) {
+    return;
+  }
+
+  const gitignoreContent = `# Flowcat workspace local files
+${ENV_FILE}
+${LOCK_DIR}/
+`;
+
+  await writeFile(gitignorePath, gitignoreContent, "utf8");
+};