@cliangdev/flux-plugin 0.3.1-dev.ee3b5ee → 0.4.0-dev.0892a21

package/src/server/adapters/github/helpers/index-store.ts

@@ -21,11 +21,11 @@ async function fetchCurrentFile(
       encoding: string;
     };
     return { sha: data.sha, content: data.content };
-  } catch (err: any) {
-    if (err.status === 404) {
+  } catch (error: unknown) {
+    if ((error as { status?: number }).status === 404) {
       return null;
     }
-    throw err;
+    throw error;
   }
 }
 
@@ -63,13 +63,17 @@ export async function writeIndex(
   }
 
   try {
-    await client.rest.repos.createOrUpdateFileContents(params as any);
-  } catch (err: any) {
-    if (err.status === 409) {
+    await client.rest.repos.createOrUpdateFileContents(
+      params as Parameters<
+        typeof client.rest.repos.createOrUpdateFileContents
+      >[0],
+    );
+  } catch (error: unknown) {
+    if ((error as { status?: number }).status === 409) {
       throw new Error(
         "Index conflict: another operation modified the index concurrently. Retry the operation.",
       );
     }
-    throw err;
+    throw error;
   }
 }

package/src/server/adapters/linear/adapter.ts

@@ -10,6 +10,26 @@
  * - Task → Linear Issue child of Epic with "task" label
  */
 
+import type {
+  Attachment,
+  Issue,
+  IssueRelation,
+  WorkflowState,
+} from "@linear/sdk";
+import { IssueRelationType } from "@linear/sdk";
+
+interface RawIssue {
+  update(input: Record<string, unknown>): Promise<unknown>;
+  archive(): Promise<unknown>;
+  children(): Promise<{ nodes: Issue[] }>;
+  attachments(): Promise<{ nodes: ArchivableAttachment[] }>;
+  inverseRelations(): Promise<{ nodes: IssueRelation[] }>;
+}
+
+interface ArchivableAttachment extends Attachment {
+  archive(): Promise<unknown>;
+}
+
 import type {
   AcceptanceCriterion,
   AddCriterionInput,
@@ -70,8 +90,7 @@ export interface HydratedIssue {
   priority: number;
   createdAt: Date;
   updatedAt: Date;
-  // Raw issue for operations that need it (update, archive, etc.)
-  _raw: any;
+  _raw: unknown;
 }
 
 export class LinearAdapter implements BackendAdapter {
@@ -87,6 +106,10 @@ export class LinearAdapter implements BackendAdapter {
   // Helper Methods
   // -------------------------------------------------------------------------
 
+  private raw(issue: HydratedIssue): RawIssue {
+    return issue._raw as RawIssue;
+  }
+
   private extractIssueNumber(identifier: string): number {
     const match = identifier.match(/-(\d+)$/);
     if (!match) {
@@ -98,12 +121,16 @@ export class LinearAdapter implements BackendAdapter {
   /**
    * Hydrate a raw Linear issue by resolving all lazy-loaded fields in parallel.
    */
-  async hydrateIssue(issue: any): Promise<HydratedIssue> {
+  async hydrateIssue(issue: Issue): Promise<HydratedIssue> {
+    const statePromise = issue.state;
+    const parentPromise = issue.parent;
     const [state, labelsResult, parent] = await Promise.all([
-      this.client.execute<any>(() => issue.state),
-      this.client.execute<any>(() => issue.labels()),
-      issue.parent
-        ? this.client.execute<any>(() => issue.parent)
+      statePromise
+        ? this.client.execute<WorkflowState>(() => statePromise)
+        : Promise.resolve(undefined),
+      this.client.execute(() => issue.labels()),
+      parentPromise
+        ? this.client.execute<Issue>(() => parentPromise)
         : Promise.resolve(null),
     ]);
 
@@ -111,10 +138,10 @@ export class LinearAdapter implements BackendAdapter {
       id: issue.id,
       identifier: issue.identifier,
       title: issue.title,
-      description: issue.description,
+      description: issue.description ?? undefined,
       stateName: state?.name || "Backlog",
       stateType: state?.type,
-      labels: (labelsResult?.nodes || []).map((l: any) => l.name),
+      labels: (labelsResult?.nodes || []).map((l) => l.name),
       parentIdentifier: parent?.identifier,
       priority: issue.priority ?? 3,
       createdAt: issue.createdAt,
@@ -146,14 +173,15 @@ export class LinearAdapter implements BackendAdapter {
   /**
    * Fetch multiple issues with a filter and hydrate them.
    */
-  async fetchIssues(filter: any, limit: number): Promise<HydratedIssue[]> {
+  async fetchIssues(
+    filter: Record<string, unknown>,
+    limit: number,
+  ): Promise<HydratedIssue[]> {
     const result = await this.client.execute(() =>
       this.client.client.issues({ filter, first: limit }),
     );
 
-    return Promise.all(
-      result.nodes.map((issue: any) => this.hydrateIssue(issue)),
-    );
+    return Promise.all(result.nodes.map((issue) => this.hydrateIssue(issue)));
   }
 
   /**
@@ -185,7 +213,7 @@ export class LinearAdapter implements BackendAdapter {
       this.client.client.team(this.config.teamId),
     );
     const states = await this.client.execute(() => team.states());
-    const targetState = states.nodes.find((s: any) => s.name === stateName);
+    const targetState = states.nodes.find((s) => s.name === stateName);
     if (!targetState) {
       throw new Error(`Workflow state '${stateName}' not found`);
     }
@@ -274,8 +302,10 @@ export class LinearAdapter implements BackendAdapter {
       }),
     );
 
-    const rawIssue = await this.client.execute<any>(
-      () => (createResult as any).issue,
+    const rawIssue = await this.client.execute<Issue | undefined>(
+      () =>
+        (createResult as unknown as { issue: Promise<Issue | undefined> })
+          .issue,
     );
     if (!rawIssue) {
       throw new Error("Failed to create PRD issue");
@@ -290,7 +320,7 @@ export class LinearAdapter implements BackendAdapter {
     if (!issue) throw new Error(`PRD not found: ${ref}`);
     if (!this.isPrd(issue)) throw new Error(`Issue ${ref} is not a PRD`);
 
-    const updatePayload: any = {};
+    const updatePayload: Record<string, unknown> = {};
     if (input.title !== undefined) updatePayload.title = input.title;
     if (input.description !== undefined)
       updatePayload.description = input.description;
@@ -317,38 +347,13 @@ export class LinearAdapter implements BackendAdapter {
       );
     }
 
-    await this.client.execute(() => issue._raw.update(updatePayload));
+    await this.client.execute(() => this.raw(issue).update(updatePayload));
 
     const updated = await this.fetchIssue(ref);
     if (!updated) throw new Error(`Failed to fetch updated PRD: ${ref}`);
     return this.toPrd(updated);
   }
 
-  /**
-   * Build label IDs for a PRD status update.
-   * Keeps existing non-status labels, adds new status label if needed.
-   * @deprecated Use buildPrdLabelIdsWithTag for updates that may include tag changes
-   */
-  private async buildPrdLabelIds(
-    currentLabels: string[],
-    newStatus: import("../types.js").PrdStatus,
-  ): Promise<string[]> {
-    const statusLabels = getAllStatusLabels();
-    const newStatusLabel = getStatusLabelForPrdStatus(newStatus);
-
-    const labelsToKeep = currentLabels.filter((l) => !statusLabels.includes(l));
-    if (newStatusLabel) {
-      labelsToKeep.push(newStatusLabel);
-    }
-
-    const labelIds: string[] = [];
-    for (const labelName of labelsToKeep) {
-      const id = await this.getOrCreateLabel(labelName);
-      labelIds.push(id);
-    }
-    return labelIds;
-  }
-
   /**
    * Build label IDs for a PRD update, handling both status and tag changes.
    * Filters out status labels and milestone labels, then adds the appropriate ones back.
@@ -393,14 +398,20 @@ export class LinearAdapter implements BackendAdapter {
     try {
       return await this.getLabelId(labelName);
     } catch {
-      const result = await this.client.execute<any>(() =>
-        (this.client.client as any).createIssueLabel({
+      const result = await this.client.execute(() =>
+        this.client.client.createIssueLabel({
           name: labelName,
           teamId: this.config.teamId,
         }),
       );
-      // Linear SDK returns _issueLabel (with underscore prefix)
-      const labelId = result?._issueLabel?.id ?? result?.issueLabel?.id;
+      const labelPayload = result as unknown as Record<string, unknown>;
+      const issueLabelField = labelPayload._issueLabel as
+        | { id: string }
+        | undefined;
+      const issueLabelGetter = labelPayload.issueLabel as
+        | { id: string }
+        | undefined;
+      const labelId = issueLabelField?.id ?? issueLabelGetter?.id;
       if (!labelId || typeof labelId !== "string") {
         throw new Error(
           `Failed to create label: ${labelName}. Result: ${JSON.stringify(result)}`,
@@ -423,11 +434,10 @@ export class LinearAdapter implements BackendAdapter {
     const limit = pagination?.limit ?? 50;
     const offset = pagination?.offset ?? 0;
 
-    const linearFilter: any = {
+    const linearFilter: Record<string, unknown> = {
       project: { id: { eq: this.config.projectId } },
     };
 
-    // Build label filter - always include prd label, optionally include tag label
     if (filters?.tag) {
       linearFilter.labels = {
         and: [
@@ -464,8 +474,8 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(ref);
     if (!issue) throw new Error(`PRD not found: ${ref}`);
 
-    const childrenResult = await this.client.execute<any>(() =>
-      issue._raw.children(),
+    const childrenResult = await this.client.execute(() =>
+      this.raw(issue).children(),
     );
     const children = childrenResult.nodes || [];
 
@@ -475,19 +485,17 @@ export class LinearAdapter implements BackendAdapter {
     for (const child of children) {
       const hydratedChild = await this.hydrateIssue(child);
       if (this.isEpic(hydratedChild)) {
-        const epicChildren = await this.client.execute<any>(() =>
-          child.children(),
-        );
+        const epicChildren = await this.client.execute(() => child.children());
         for (const task of epicChildren.nodes || []) {
-          await this.client.execute<any>(() => task.archive());
+          await this.client.execute(() => task.archive());
           taskCount++;
         }
-        await this.client.execute<any>(() => child.archive());
+        await this.client.execute(() => child.archive());
         epicCount++;
       }
     }
 
-    await this.client.execute<any>(() => issue._raw.archive());
+    await this.client.execute(() => this.raw(issue).archive());
 
     return {
       deleted: ref,
@@ -529,8 +537,10 @@ export class LinearAdapter implements BackendAdapter {
       }),
     );
 
-    const rawIssue = await this.client.execute<any>(
-      () => (createResult as any).issue,
+    const rawIssue = await this.client.execute<Issue | undefined>(
+      () =>
+        (createResult as unknown as { issue: Promise<Issue | undefined> })
+          .issue,
     );
     if (!rawIssue) throw new Error("Failed to create Epic issue");
 
@@ -542,7 +552,7 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(ref);
     if (!issue) throw new Error(`Epic not found: ${ref}`);
 
-    const updatePayload: any = {};
+    const updatePayload: Record<string, unknown> = {};
     if (input.title !== undefined) updatePayload.title = input.title;
     if (input.description !== undefined)
       updatePayload.description = input.description;
@@ -552,8 +562,7 @@ export class LinearAdapter implements BackendAdapter {
       );
     }
 
-    await this.client.execute(() => issue._raw.update(updatePayload));
-    // Re-fetch to get the updated issue with all fields
+    await this.client.execute(() => this.raw(issue).update(updatePayload));
     const updated = await this.fetchIssue(ref);
     if (!updated) {
       throw new Error(`Failed to fetch updated Epic: ${ref}`);
@@ -574,7 +583,7 @@ export class LinearAdapter implements BackendAdapter {
     const limit = pagination?.limit ?? 50;
     const offset = pagination?.offset ?? 0;
 
-    const linearFilter: any = {
+    const linearFilter: Record<string, unknown> = {
       labels: { name: { eq: this.config.defaultLabels.epic } },
       project: { id: { eq: this.config.projectId } },
     };
@@ -609,16 +618,16 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(ref);
     if (!issue) throw new Error(`Epic not found: ${ref}`);
 
-    const childrenResult = await this.client.execute<any>(() =>
-      issue._raw.children(),
+    const childrenResult = await this.client.execute(() =>
+      this.raw(issue).children(),
     );
     const children = childrenResult.nodes || [];
 
     for (const child of children) {
-      await this.client.execute<any>(() => child.archive());
+      await this.client.execute(() => child.archive());
     }
 
-    await this.client.execute<any>(() => issue._raw.archive());
+    await this.client.execute(() => this.raw(issue).archive());
 
     return {
       deleted: ref,
@@ -659,8 +668,10 @@ export class LinearAdapter implements BackendAdapter {
       }),
     );
 
-    const rawIssue = await this.client.execute<any>(
-      () => (createResult as any).issue,
+    const rawIssue = await this.client.execute<Issue | undefined>(
+      () =>
+        (createResult as unknown as { issue: Promise<Issue | undefined> })
+          .issue,
     );
     if (!rawIssue) throw new Error("Failed to create Task issue");
 
@@ -672,7 +683,7 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(ref);
     if (!issue) throw new Error(`Task not found: ${ref}`);
 
-    const updatePayload: any = {};
+    const updatePayload: Record<string, unknown> = {};
     if (input.title !== undefined) updatePayload.title = input.title;
     if (input.description !== undefined)
       updatePayload.description = input.description;
@@ -684,11 +695,11 @@ export class LinearAdapter implements BackendAdapter {
         this.client.client.team(this.config.teamId),
       );
       const states = await this.client.execute(() => team.states());
-      const targetState = states.nodes.find((s: any) => s.name === stateName);
+      const targetState = states.nodes.find((s) => s.name === stateName);
       if (targetState) updatePayload.stateId = targetState.id;
     }
 
-    await this.client.execute(() => issue._raw.update(updatePayload));
+    await this.client.execute(() => this.raw(issue).update(updatePayload));
     // Re-fetch to get the updated issue with all fields
     const updated = await this.fetchIssue(ref);
     if (!updated) {
@@ -712,7 +723,7 @@ export class LinearAdapter implements BackendAdapter {
     const limit = pagination?.limit ?? 50;
     const offset = pagination?.offset ?? 0;
 
-    const linearFilter: any = {
+    const linearFilter: Record<string, unknown> = {
       labels: { name: { eq: this.config.defaultLabels.task } },
       project: { id: { eq: this.config.projectId } },
     };
@@ -731,7 +742,7 @@ export class LinearAdapter implements BackendAdapter {
     );
 
     const issues = await Promise.all(
-      result.nodes.map((i: any) => this.hydrateIssue(i)),
+      result.nodes.map((i) => this.hydrateIssue(i)),
     );
     const paginated = issues.slice(offset, offset + limit);
 
@@ -750,7 +761,7 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(ref);
     if (!issue) throw new Error(`Task not found: ${ref}`);
 
-    await this.client.execute(() => issue._raw.archive());
+    await this.client.execute(() => this.raw(issue).archive());
 
     return {
       deleted: ref,
@@ -774,8 +785,8 @@ export class LinearAdapter implements BackendAdapter {
       input.criteria,
     );
 
-    await this.client.execute<any>(() =>
-      issue._raw.update({ description: newDescription }),
+    await this.client.execute(() =>
+      this.raw(issue).update({ description: newDescription }),
     );
 
     return {
@@ -808,8 +819,8 @@ export class LinearAdapter implements BackendAdapter {
           true,
         );
 
-        await this.client.execute<any>(() =>
-          issue._raw.update({ description: newDescription }),
+        await this.client.execute(() =>
+          this.raw(issue).update({ description: newDescription }),
         );
 
         return {
@@ -869,11 +880,11 @@ export class LinearAdapter implements BackendAdapter {
       );
     }
 
-    await this.client.execute<any>(() =>
+    await this.client.execute(() =>
       this.client.client.createIssueRelation({
         issueId: blockerIssue.id,
         relatedIssueId: blockedIssue.id,
-        type: "blocks" as any,
+        type: IssueRelationType.Blocks,
       }),
     );
   }
@@ -887,13 +898,11 @@ export class LinearAdapter implements BackendAdapter {
     if (!blockedIssue) throw new Error(`Issue not found: ${ref}`);
     if (!blockerIssue) throw new Error(`Issue not found: ${dependsOnRef}`);
 
-    // Use inverseRelations to find relations where blockedIssue is the target
-    const relations = await this.client.execute<any>(() =>
-      blockedIssue._raw.inverseRelations(),
+    const relations = await this.client.execute(() =>
+      this.raw(blockedIssue).inverseRelations(),
     );
 
-    // Find the relation to delete - need to await rel.issue since it's lazy-loaded
-    let relationToDelete: any = null;
+    let relationToDelete: IssueRelation | null = null;
     for (const rel of relations.nodes) {
       if (rel.type === "blocks") {
         const relIssue = await rel.issue;
@@ -910,17 +919,15 @@ export class LinearAdapter implements BackendAdapter {
       );
     }
 
-    await this.client.execute<any>(() => relationToDelete.delete());
+    await this.client.execute(() => relationToDelete.delete());
   }
 
   async getDependencies(ref: string): Promise<string[]> {
     const issue = await this.fetchIssue(ref);
     if (!issue) throw new Error(`Issue not found: ${ref}`);
 
-    // Use inverseRelations to get relations where this issue is the target (relatedIssueId)
-    // This finds issues that block this one
-    const relations = await this.client.execute<any>(() =>
-      issue._raw.inverseRelations(),
+    const relations = await this.client.execute(() =>
+      this.raw(issue).inverseRelations(),
     );
 
     const blockingRefs: string[] = [];
@@ -952,21 +959,32 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(doc.prdRef);
     if (!issue) throw new Error(`PRD ${doc.prdRef} not found`);
 
-    const existingAttachments = await this.client.execute<any>(() =>
-      issue._raw.attachments(),
+    const existingAttachments = await this.client.execute(() =>
+      this.raw(issue).attachments(),
     );
     const existingAttachment = existingAttachments.nodes.find(
-      (att: any) => att.title === doc.filename,
+      (att) => att.title === doc.filename,
     );
 
     if (existingAttachment) {
-      await this.client.execute<any>(() => existingAttachment.archive());
+      await this.client.execute(() => existingAttachment.archive());
     }
 
     const contentUrl = `data:text/markdown;base64,${Buffer.from(doc.content).toString("base64")}`;
 
-    const attachResult = await this.client.execute<any>(() =>
-      (this.client.client as any).attachmentCreate({
+    const attachResult = await this.client.execute<{
+      success: boolean;
+      attachment?: { url: string };
+    }>(() =>
+      (
+        this.client.client as unknown as {
+          attachmentCreate(input: {
+            title: string;
+            url: string;
+            issueId: string;
+          }): Promise<{ success: boolean; attachment?: { url: string } }>;
+        }
+      ).attachmentCreate({
         title: doc.filename,
         url: contentUrl,
         issueId: issue.id,
@@ -989,8 +1007,8 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(prdRef);
     if (!issue) throw new Error(`PRD ${prdRef} not found`);
 
-    const attachments = await this.client.execute<any>(() =>
-      issue._raw.attachments(),
+    const attachments = await this.client.execute(() =>
+      this.raw(issue).attachments(),
     );
     const documents: Document[] = [];
 
@@ -1021,16 +1039,14 @@ export class LinearAdapter implements BackendAdapter {
     const issue = await this.fetchIssue(prdRef);
     if (!issue) throw new Error(`PRD ${prdRef} not found`);
 
-    const attachments = await this.client.execute<any>(() =>
-      issue._raw.attachments(),
-    );
-    const attachment = attachments.nodes.find(
-      (att: any) => att.title === filename,
+    const attachments = await this.client.execute(() =>
+      this.raw(issue).attachments(),
     );
+    const attachment = attachments.nodes.find((att) => att.title === filename);
 
     if (!attachment) throw new Error(`Document ${filename} not found`);
 
-    await this.client.execute<any>(() => attachment.archive());
+    await this.client.execute(() => attachment.archive());
   }
 
   // -------------------------------------------------------------------------

package/src/server/adapters/linear/client.ts

@@ -73,13 +73,20 @@ export class LinearClient {
     for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
       try {
         return await operation();
-      } catch (error: any) {
-        lastError = error;
+      } catch (error: unknown) {
+        const err = error as {
+          status?: number;
+          message?: string;
+          code?: string;
+        };
+        const asError =
+          error instanceof Error ? error : new Error(String(error));
+        lastError = asError;
 
         // Check if error is retryable
-        const isRateLimited = error.status === 429;
-        const isNetworkError = this.isNetworkError(error);
-        const isUnauthorized = error.status === 401;
+        const isRateLimited = err.status === 429;
+        const isNetworkError = this.isNetworkError(err);
+        const isUnauthorized = err.status === 401;
 
         // Throw immediately for unauthorized errors
         if (isUnauthorized) {
@@ -87,17 +94,17 @@ export class LinearClient {
             "Unauthorized: Invalid API key",
             "UNAUTHORIZED",
             401,
-            error,
+            asError,
           );
         }
 
         // Throw immediately for non-retryable errors
         if (!isRateLimited && !isNetworkError) {
           throw new LinearApiError(
-            error.message || "Linear API error",
+            err.message || "Linear API error",
             "API_ERROR",
-            error.status,
-            error,
+            err.status,
+            asError,
           );
         }
 
@@ -108,14 +115,14 @@ export class LinearClient {
               `Rate limited after ${this.maxRetries} retries`,
               "RATE_LIMITED",
               429,
-              error,
+              asError,
             );
           }
           throw new LinearApiError(
-            `Network error after ${this.maxRetries} retries: ${error.message}`,
+            `Network error after ${this.maxRetries} retries: ${asError.message}`,
             "NETWORK_ERROR",
             undefined,
-            error,
+            asError,
           );
         }
 
@@ -137,7 +144,7 @@ export class LinearClient {
   /**
    * Check if an error is a network error.
    */
-  private isNetworkError(error: any): boolean {
+  private isNetworkError(error: { code?: string; message?: string }): boolean {
     // Common network error codes
     const networkErrorCodes = [
       "ECONNRESET",
@@ -147,7 +154,7 @@ export class LinearClient {
       "ENETUNREACH",
     ];
 
-    return networkErrorCodes.includes(error.code);
+    return error.code !== undefined && networkErrorCodes.includes(error.code);
   }
 
   /**