@jonit-dev/night-watch-cli 1.7.96 → 1.7.97

package/dist/cli.js

@@ -1599,17 +1599,14 @@ var init_github_graphql = __esm({
   }
 });
 
-// ../core/dist/board/providers/github-projects.js
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var execFileAsync2, GitHubProjectsProvider;
-var init_github_projects = __esm({
-  "../core/dist/board/providers/github-projects.js"() {
+// ../core/dist/board/providers/github-projects-base.js
+var GitHubProjectsBase;
+var init_github_projects_base = __esm({
+  "../core/dist/board/providers/github-projects-base.js"() {
     "use strict";
     init_types2();
     init_github_graphql();
-    execFileAsync2 = promisify2(execFile2);
-    GitHubProjectsProvider = class {
+    GitHubProjectsBase = class {
       config;
       cwd;
       cachedProjectId = null;
@@ -1617,15 +1614,19 @@ var init_github_projects = __esm({
       cachedOptionIds = /* @__PURE__ */ new Map();
       cachedOwner = null;
       cachedRepositoryId = null;
+      cachedRepoNameWithOwner = null;
       constructor(config, cwd) {
         this.config = config;
         this.cwd = cwd;
       }
       // -------------------------------------------------------------------------
-      // Helpers
+      // Repo resolution
       // -------------------------------------------------------------------------
       async getRepo() {
-        return this.config.repo ?? getRepoNwo(this.cwd);
+        if (this.cachedRepoNameWithOwner)
+          return this.cachedRepoNameWithOwner;
+        this.cachedRepoNameWithOwner = this.config.repo ?? await getRepoNwo(this.cwd);
+        return this.cachedRepoNameWithOwner;
       }
       async getRepoParts() {
         const repo = await this.getRepo();
@@ -1635,131 +1636,102 @@ var init_github_projects = __esm({
         }
         return { owner, name };
       }
+      normalizeRepoName(repo) {
+        return repo.trim().toLowerCase();
+      }
+      isCurrentRepoItem(content, repo) {
+        const repoNameWithOwner = content?.repository?.nameWithOwner;
+        if (!repoNameWithOwner)
+          return true;
+        return this.normalizeRepoName(repoNameWithOwner) === this.normalizeRepoName(repo);
+      }
       async getRepoOwnerLogin() {
         return (await this.getRepoParts()).owner;
       }
       async getRepoOwner() {
-        if (this.cachedOwner && this.cachedRepositoryId) {
+        if (this.cachedOwner && this.cachedRepositoryId)
           return this.cachedOwner;
-        }
         const { owner, name } = await this.getRepoParts();
         const data = await graphql(`query ResolveRepoOwner($owner: String!, $name: String!) {
         repository(owner: $owner, name: $name) {
           id
-          owner {
-            __typename
-            id
-            login
-          }
+          owner { __typename id login }
         }
       }`, { owner, name }, this.cwd);
-        if (!data.repository) {
+        if (!data.repository)
           throw new Error(`Repository ${owner}/${name} not found.`);
-        }
         const ownerNode = data.repository.owner;
         if (!ownerNode || ownerNode.__typename !== "User" && ownerNode.__typename !== "Organization") {
           throw new Error(`Failed to resolve repository owner for ${owner}/${name}.`);
         }
         this.cachedRepositoryId = data.repository.id;
-        this.cachedOwner = {
-          id: ownerNode.id,
-          login: ownerNode.login,
-          type: ownerNode.__typename
-        };
+        this.cachedOwner = { id: ownerNode.id, login: ownerNode.login, type: ownerNode.__typename };
         return this.cachedOwner;
       }
       async getRepositoryNodeId() {
-        if (this.cachedRepositoryId) {
+        if (this.cachedRepositoryId)
           return this.cachedRepositoryId;
-        }
         await this.getRepoOwner();
         if (!this.cachedRepositoryId) {
           throw new Error(`Failed to resolve repository ID for ${await this.getRepo()}.`);
         }
         return this.cachedRepositoryId;
       }
-      async linkProjectToRepository(projectId) {
-        const repositoryId = await this.getRepositoryNodeId();
+      // -------------------------------------------------------------------------
+      // Project discovery & caching
+      // -------------------------------------------------------------------------
+      async resolveProjectNode(projectNumber) {
+        const ownerLogins = /* @__PURE__ */ new Set([await this.getRepoOwnerLogin()]);
         try {
-          await graphql(`mutation LinkProjectToRepository($projectId: ID!, $repositoryId: ID!) {
-          linkProjectV2ToRepository(input: { projectId: $projectId, repositoryId: $repositoryId }) {
-            repository {
-              id
-            }
-          }
-        }`, { projectId, repositoryId }, this.cwd);
-        } catch (err) {
-          const message = err instanceof Error ? err.message : String(err);
-          const normalized = message.toLowerCase();
-          if (normalized.includes("already") && normalized.includes("project")) {
-            return;
-          }
-          throw err;
+          ownerLogins.add(await getViewerLogin(this.cwd));
+        } catch {
         }
+        for (const login of ownerLogins) {
+          const node = await this.fetchProjectNode(login, projectNumber);
+          if (node)
+            return node;
+        }
+        return null;
       }
-      async fetchStatusField(projectId) {
-        const fieldData = await graphql(`query GetStatusField($projectId: ID!) {
-        node(id: $projectId) {
-          ... on ProjectV2 {
-            field(name: "Status") {
-              ... on ProjectV2SingleSelectField {
-                id
-                options {
-                  id
-                  name
-                }
-              }
-            }
+      /** Try user query first, fall back to org query. */
+      async fetchProjectNode(login, projectNumber) {
+        try {
+          const userData = await graphql(`query GetProject($login: String!, $number: Int!) {
+          user(login: $login) {
+            projectV2(number: $number) { id number title url }
           }
+        }`, { login, number: projectNumber }, this.cwd);
+          if (userData.user?.projectV2)
+            return userData.user.projectV2;
+        } catch {
         }
-      }`, { projectId }, this.cwd);
-        const field = fieldData.node?.field;
-        if (!field) {
-          throw new Error(`Status field not found on project ${projectId}. Run \`night-watch board setup\` to create it.`);
+        try {
+          const orgData = await graphql(`query GetOrgProject($login: String!, $number: Int!) {
+          organization(login: $login) {
+            projectV2(number: $number) { id number title url }
+          }
+        }`, { login, number: projectNumber }, this.cwd);
+          if (orgData.organization?.projectV2)
+            return orgData.organization.projectV2;
+        } catch {
         }
-        return {
-          fieldId: field.id,
-          optionIds: new Map(field.options.map((o) => [o.name, o.id]))
-        };
+        return null;
       }
-      /**
-       * Fetch and cache the project node ID, Status field ID, and option IDs.
-       * Throws if the project cannot be found or has no Status field.
-       */
       async ensureProjectCache() {
         if (this.cachedProjectId !== null && this.cachedFieldId !== null && this.cachedOptionIds.size > 0) {
-          return {
-            projectId: this.cachedProjectId,
-            fieldId: this.cachedFieldId,
-            optionIds: this.cachedOptionIds
-          };
+          return { projectId: this.cachedProjectId, fieldId: this.cachedFieldId, optionIds: this.cachedOptionIds };
         }
         if (this.cachedProjectId !== null) {
           const statusField2 = await this.fetchStatusField(this.cachedProjectId);
           this.cachedFieldId = statusField2.fieldId;
           this.cachedOptionIds = statusField2.optionIds;
-          return {
-            projectId: this.cachedProjectId,
-            fieldId: this.cachedFieldId,
-            optionIds: this.cachedOptionIds
-          };
+          return { projectId: this.cachedProjectId, fieldId: this.cachedFieldId, optionIds: this.cachedOptionIds };
         }
         const projectNumber = this.config.projectNumber;
         if (!projectNumber) {
           throw new Error("No projectNumber configured. Run `night-watch board setup` first.");
         }
-        const ownerLogins = /* @__PURE__ */ new Set([await this.getRepoOwnerLogin()]);
-        try {
-          ownerLogins.add(await getViewerLogin(this.cwd));
-        } catch {
-        }
-        let projectNode = null;
-        for (const login of ownerLogins) {
-          projectNode = await this.fetchProjectNode(login, projectNumber);
-          if (projectNode) {
-            break;
-          }
-        }
+        const projectNode = await this.resolveProjectNode(projectNumber);
         if (!projectNode) {
           throw new Error(`GitHub Project #${projectNumber} not found for repository owner "${await this.getRepoOwnerLogin()}".`);
         }
@@ -1767,129 +1739,92 @@ var init_github_projects = __esm({
         const statusField = await this.fetchStatusField(projectNode.id);
         this.cachedFieldId = statusField.fieldId;
         this.cachedOptionIds = statusField.optionIds;
-        return {
-          projectId: this.cachedProjectId,
-          fieldId: this.cachedFieldId,
-          optionIds: this.cachedOptionIds
-        };
+        return { projectId: this.cachedProjectId, fieldId: this.cachedFieldId, optionIds: this.cachedOptionIds };
       }
-      /** Try user query first, fall back to org query. */
-      async fetchProjectNode(login, projectNumber) {
-        try {
-          const userData = await graphql(`query GetProject($login: String!, $number: Int!) {
-          user(login: $login) {
-            projectV2(number: $number) {
-              id
-              number
-              title
-              url
+      // -------------------------------------------------------------------------
+      // Status field management
+      // -------------------------------------------------------------------------
+      async fetchStatusField(projectId) {
+        const fieldData = await graphql(`query GetStatusField($projectId: ID!) {
+        node(id: $projectId) {
+          ... on ProjectV2 {
+            field(name: "Status") {
+              ... on ProjectV2SingleSelectField {
+                id
+                options { id name }
+              }
             }
           }
-        }`, { login, number: projectNumber }, this.cwd);
-          if (userData.user?.projectV2) {
-            return userData.user.projectV2;
-          }
-        } catch {
         }
-        try {
-          const orgData = await graphql(`query GetOrgProject($login: String!, $number: Int!) {
-          organization(login: $login) {
-            projectV2(number: $number) {
-              id
-              number
-              title
-              url
+      }`, { projectId }, this.cwd);
+        const field = fieldData.node?.field;
+        if (!field) {
+          throw new Error(`Status field not found on project ${projectId}. Run \`night-watch board setup\` to create it.`);
+        }
+        return { fieldId: field.id, optionIds: new Map(field.options.map((o) => [o.name, o.id])) };
+      }
+      async ensureStatusColumns(projectId) {
+        const fieldData = await graphql(`query GetStatusField($projectId: ID!) {
+        node(id: $projectId) {
+          ... on ProjectV2 {
+            field(name: "Status") {
+              ... on ProjectV2SingleSelectField {
+                id
+                options { id name }
+              }
             }
           }
-        }`, { login, number: projectNumber }, this.cwd);
-          if (orgData.organization?.projectV2) {
-            return orgData.organization.projectV2;
+        }
+      }`, { projectId }, this.cwd);
+        const field = fieldData.node?.field;
+        if (!field)
+          return;
+        const existing = new Set(field.options.map((o) => o.name));
+        const required = ["Draft", "Ready", "In Progress", "Review", "Done"];
+        if (required.every((n) => existing.has(n)))
+          return;
+        await graphql(`mutation UpdateField($fieldId: ID!) {
+        updateProjectV2Field(input: {
+          fieldId: $fieldId
+          singleSelectOptions: [
+            { name: "Draft",       color: GRAY,   description: "" }
+            { name: "Ready",       color: BLUE,   description: "" }
+            { name: "In Progress", color: YELLOW, description: "" }
+            { name: "Review",      color: ORANGE, description: "" }
+            { name: "Done",        color: GREEN,  description: "" }
+          ]
+        }) {
+          projectV2Field {
+            ... on ProjectV2SingleSelectField { id options { id name } }
           }
-        } catch {
         }
-        return null;
+      }`, { fieldId: field.id }, this.cwd);
       }
-      /**
-       * Parse a raw project item node into IBoardIssue, returning null for items
-       * that are not issues.
-       */
-      parseItem(item) {
-        const content = item.content;
-        if (!content || content.number === void 0) {
-          return null;
-        }
-        let column = null;
-        for (const fv of item.fieldValues.nodes) {
-          if (fv.field?.name === "Status" && fv.name) {
-            const candidate = fv.name;
-            if (BOARD_COLUMNS.includes(candidate)) {
-              column = candidate;
-            }
+      async linkProjectToRepository(projectId) {
+        const repositoryId = await this.getRepositoryNodeId();
+        try {
+          await graphql(`mutation LinkProjectToRepository($projectId: ID!, $repositoryId: ID!) {
+          linkProjectV2ToRepository(input: { projectId: $projectId, repositoryId: $repositoryId }) {
+            repository { id }
           }
+        }`, { projectId, repositoryId }, this.cwd);
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          if (message.toLowerCase().includes("already") && message.toLowerCase().includes("project"))
+            return;
+          throw err;
         }
-        return {
-          id: content.id ?? item.id,
-          number: content.number,
-          title: content.title ?? "",
-          body: content.body ?? "",
-          url: content.url ?? "",
-          column,
-          labels: content.labels?.nodes.map((l) => l.name) ?? [],
-          assignees: content.assignees?.nodes.map((a) => a.login) ?? []
-        };
       }
-      /**
-       * Fetch ALL items from a GitHub ProjectV2 using cursor-based pagination.
-       *
-       * The API caps each page at 100 items.  We loop until `hasNextPage` is false,
-       * accumulating every item node so callers never see a truncated board.
-       */
-      async fetchAllProjectItems(projectId) {
+      // -------------------------------------------------------------------------
+      // Project items
+      // -------------------------------------------------------------------------
+      async paginateProjectItems(query, projectId) {
         const allNodes = [];
         let cursor = null;
-        const query = `query GetProjectItems($projectId: ID!, $cursor: String) {
-      node(id: $projectId) {
-        ... on ProjectV2 {
-          items(first: 100, after: $cursor) {
-            pageInfo {
-              hasNextPage
-              endCursor
-            }
-            nodes {
-              id
-              content {
-                ... on Issue {
-                  number
-                  title
-                  body
-                  url
-                  id
-                  labels(first: 10) { nodes { name } }
-                  assignees(first: 10) { nodes { login } }
-                }
-              }
-              fieldValues(first: 10) {
-                nodes {
-                  ... on ProjectV2ItemFieldSingleSelectValue {
-                    name
-                    field {
-                      ... on ProjectV2SingleSelectField {
-                        name
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }`;
         do {
           const variables = { projectId };
-          if (cursor !== null) {
+          if (cursor !== null)
             variables.cursor = cursor;
-          }
           const data = await graphql(query, variables, this.cwd);
           const page = data.node.items;
           allNodes.push(...page.nodes);
@@ -1897,37 +1832,27 @@ var init_github_projects = __esm({
         } while (cursor !== null);
         return allNodes;
       }
-      /**
-       * Fetch project items for moveIssue — only needs id, content.number, and
-       * fieldValues.  Uses the same paginated approach to ensure items beyond
-       * position 100 are reachable.
-       */
-      async fetchAllProjectItemsForMove(projectId) {
-        const allNodes = [];
-        let cursor = null;
-        const query = `query GetProjectItemsForMove($projectId: ID!, $cursor: String) {
-      node(id: $projectId) {
-        ... on ProjectV2 {
-          items(first: 100, after: $cursor) {
-            pageInfo {
-              hasNextPage
-              endCursor
-            }
-            nodes {
-              id
-              content {
-                ... on Issue {
-                  number
+      async fetchAllProjectItems(projectId) {
+        return this.paginateProjectItems(`query GetProjectItems($projectId: ID!, $cursor: String) {
+        node(id: $projectId) {
+          ... on ProjectV2 {
+            items(first: 100, after: $cursor) {
+              pageInfo { hasNextPage endCursor }
+              nodes {
+                id
+                content {
+                  ... on Issue {
+                    number title body url id
+                    repository { nameWithOwner }
+                    labels(first: 10) { nodes { name } }
+                    assignees(first: 10) { nodes { login } }
+                  }
                 }
-              }
-              fieldValues(first: 10) {
-                nodes {
-                  ... on ProjectV2ItemFieldSingleSelectValue {
-                    name
-                    field {
-                      ... on ProjectV2SingleSelectField {
-                        name
-                      }
+                fieldValues(first: 10) {
+                  nodes {
+                    ... on ProjectV2ItemFieldSingleSelectValue {
+                      name
+                      field { ... on ProjectV2SingleSelectField { name } }
                     }
                   }
                 }
@@ -1935,44 +1860,61 @@ var init_github_projects = __esm({
             }
           }
         }
+      }`, projectId);
       }
-    }`;
-        do {
-          const variables = { projectId };
-          if (cursor !== null) {
-            variables.cursor = cursor;
+      parseItem(item, repo) {
+        const content = item.content;
+        if (!content || content.number === void 0)
+          return null;
+        if (!this.isCurrentRepoItem(content, repo))
+          return null;
+        let column = null;
+        for (const fv of item.fieldValues.nodes) {
+          if (fv.field?.name === "Status" && fv.name) {
+            const candidate = fv.name;
+            if (BOARD_COLUMNS.includes(candidate))
+              column = candidate;
           }
-          const data = await graphql(query, variables, this.cwd);
-          const page = data.node.items;
-          allNodes.push(...page.nodes);
-          cursor = page.pageInfo.hasNextPage ? page.pageInfo.endCursor : null;
-        } while (cursor !== null);
-        return allNodes;
+        }
+        return {
+          id: content.id ?? item.id,
+          number: content.number,
+          title: content.title ?? "",
+          body: content.body ?? "",
+          url: content.url ?? "",
+          column,
+          labels: content.labels?.nodes.map((l) => l.name) ?? [],
+          assignees: content.assignees?.nodes.map((a) => a.login) ?? []
+        };
+      }
+      async setItemStatus(projectId, itemId, fieldId, optionId) {
+        await graphql(`mutation UpdateItemField($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {
+        updateProjectV2ItemFieldValue(input: {
+          projectId: $projectId
+          itemId: $itemId
+          fieldId: $fieldId
+          value: { singleSelectOptionId: $optionId }
+        }) {
+          projectV2Item { id }
+        }
+      }`, { projectId, itemId, fieldId, optionId }, this.cwd);
       }
       // -------------------------------------------------------------------------
-      // IBoardProvider implementation
+      // Project listing
       // -------------------------------------------------------------------------
-      /**
-       * Find an existing project by title among the repository owner's first 50 projects.
-       * Returns null if not found.
-       */
       async findExistingProject(owner, title) {
         try {
           if (owner.type === "User") {
             const data2 = await graphql(`query ListUserProjects($login: String!) {
             user(login: $login) {
-              projectsV2(first: 50) {
-                nodes { id number title url }
-              }
+              projectsV2(first: 50) { nodes { id number title url } }
             }
           }`, { login: owner.login }, this.cwd);
             return data2.user?.projectsV2.nodes.find((p) => p.title === title) ?? null;
           }
           const data = await graphql(`query ListOrgProjects($login: String!) {
           organization(login: $login) {
-            projectsV2(first: 50) {
-              nodes { id number title url }
-            }
+            projectsV2(first: 50) { nodes { id number title url } }
           }
         }`, { login: owner.login }, this.cwd);
           return data.organization?.projectsV2.nodes.find((p) => p.title === title) ?? null;
@@ -1980,63 +1922,22 @@ var init_github_projects = __esm({
           return null;
         }
       }
-      /**
-       * Ensure the Status field on an existing project has all five Night Watch
-       * lifecycle columns, updating it via GraphQL if any are missing.
-       */
-      async ensureStatusColumns(projectId) {
-        const fieldData = await graphql(`query GetStatusField($projectId: ID!) {
-        node(id: $projectId) {
-          ... on ProjectV2 {
-            field(name: "Status") {
-              ... on ProjectV2SingleSelectField {
-                id
-                options { id name }
-              }
-            }
-          }
-        }
-      }`, { projectId }, this.cwd);
-        const field = fieldData.node?.field;
-        if (!field)
-          return;
-        const existing = new Set(field.options.map((o) => o.name));
-        const required = ["Draft", "Ready", "In Progress", "Review", "Done"];
-        const missing = required.filter((n) => !existing.has(n));
-        if (missing.length === 0)
-          return;
-        const colorMap = {
-          Draft: "GRAY",
-          Ready: "BLUE",
-          "In Progress": "YELLOW",
-          Review: "ORANGE",
-          Done: "GREEN"
-        };
-        const allOptions = required.map((name) => ({
-          name,
-          color: colorMap[name],
-          description: ""
-        }));
-        await graphql(`mutation UpdateField($fieldId: ID!) {
-        updateProjectV2Field(input: {
-          fieldId: $fieldId,
-          singleSelectOptions: [
-            { name: "Draft",       color: GRAY,   description: "" },
-            { name: "Ready",       color: BLUE,   description: "" },
-            { name: "In Progress", color: YELLOW, description: "" },
-            { name: "Review",      color: ORANGE, description: "" },
-            { name: "Done",        color: GREEN,  description: "" }
-          ]
-        }) {
-          projectV2Field {
-            ... on ProjectV2SingleSelectField {
-              id
-              options { id name }
-            }
-          }
-        }
-      }`, { fieldId: field.id, allOptions }, this.cwd);
-      }
+    };
+  }
+});
+
+// ../core/dist/board/providers/github-projects.js
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2, GitHubProjectsProvider;
+var init_github_projects = __esm({
+  "../core/dist/board/providers/github-projects.js"() {
+    "use strict";
+    init_types2();
+    init_github_graphql();
+    init_github_projects_base();
+    execFileAsync2 = promisify2(execFile2);
+    GitHubProjectsProvider = class extends GitHubProjectsBase {
       async setupBoard(title) {
         const owner = await this.getRepoOwner();
         const existing = await this.findExistingProject(owner, title);
@@ -2048,12 +1949,7 @@ var init_github_projects = __esm({
         }
         const createData = await graphql(`mutation CreateProject($ownerId: ID!, $title: String!) {
         createProjectV2(input: { ownerId: $ownerId, title: $title }) {
-          projectV2 {
-            id
-            number
-            url
-            title
-          }
+          projectV2 { id number url title }
         }
       }`, { ownerId: owner.id, title }, this.cwd);
         const project = createData.createProjectV2.projectV2;
@@ -2069,27 +1965,23 @@ var init_github_projects = __esm({
           this.cachedOptionIds = refreshed.optionIds;
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
-          if (!message.includes("Status field not found")) {
+          if (!message.includes("Status field not found"))
             throw err;
-          }
           const createFieldData = await graphql(`mutation CreateStatusField($projectId: ID!) {
           createProjectV2Field(input: {
-            projectId: $projectId,
-            dataType: SINGLE_SELECT,
-            name: "Status",
+            projectId: $projectId
+            dataType: SINGLE_SELECT
+            name: "Status"
             singleSelectOptions: [
-              { name: "Draft",       color: GRAY,   description: "" },
-              { name: "Ready",       color: BLUE,   description: "" },
-              { name: "In Progress", color: YELLOW, description: "" },
-              { name: "Review",      color: ORANGE, description: "" },
+              { name: "Draft",       color: GRAY,   description: "" }
+              { name: "Ready",       color: BLUE,   description: "" }
+              { name: "In Progress", color: YELLOW, description: "" }
+              { name: "Review",      color: ORANGE, description: "" }
               { name: "Done",        color: GREEN,  description: "" }
             ]
           }) {
             projectV2Field {
-              ... on ProjectV2SingleSelectField {
-                id
-                options { id name }
-              }
+              ... on ProjectV2SingleSelectField { id options { id name } }
             }
           }
         }`, { projectId: project.id }, this.cwd);
@@ -2101,25 +1993,12 @@ var init_github_projects = __esm({
       }
       async getBoard() {
         const projectNumber = this.config.projectNumber;
-        if (!projectNumber) {
+        if (!projectNumber)
           return null;
-        }
         try {
-          const ownerLogins = /* @__PURE__ */ new Set([await this.getRepoOwnerLogin()]);
-          try {
-            ownerLogins.add(await getViewerLogin(this.cwd));
-          } catch {
-          }
-          let node = null;
-          for (const login of ownerLogins) {
-            node = await this.fetchProjectNode(login, projectNumber);
-            if (node) {
-              break;
-            }
-          }
-          if (!node) {
+          const node = await this.resolveProjectNode(projectNumber);
+          if (!node)
             return null;
-          }
           return { id: node.id, number: node.number, title: node.title, url: node.url };
         } catch {
           return null;
@@ -2127,73 +2006,36 @@ var init_github_projects = __esm({
       }
       async getColumns() {
         const { fieldId, optionIds } = await this.ensureProjectCache();
-        return BOARD_COLUMNS.map((name) => ({
-          id: optionIds.get(name) ?? fieldId,
-          name
-        }));
+        return BOARD_COLUMNS.map((name) => ({ id: optionIds.get(name) ?? fieldId, name }));
       }
       async createIssue(input) {
         const repo = await this.getRepo();
         const { projectId, fieldId, optionIds } = await this.ensureProjectCache();
-        const issueArgs = [
-          "issue",
-          "create",
-          "--title",
-          input.title,
-          "--body",
-          input.body,
-          "--repo",
-          repo
-        ];
+        const issueArgs = ["issue", "create", "--title", input.title, "--body", input.body, "--repo", repo];
         if (input.labels && input.labels.length > 0) {
           issueArgs.push("--label", input.labels.join(","));
         }
-        const { stdout: issueUrlRaw } = await execFileAsync2("gh", issueArgs, {
-          cwd: this.cwd,
-          encoding: "utf-8"
-        });
+        const { stdout: issueUrlRaw } = await execFileAsync2("gh", issueArgs, { cwd: this.cwd, encoding: "utf-8" });
         const issueUrl = issueUrlRaw.trim();
         const issueNumber = parseInt(issueUrl.split("/").pop() ?? "", 10);
-        if (!issueNumber) {
+        if (!issueNumber)
           throw new Error(`Failed to parse issue number from URL: ${issueUrl}`);
-        }
         const [owner, repoName] = repo.split("/");
         const { stdout: nodeIdRaw } = await execFileAsync2("gh", ["api", `repos/${owner}/${repoName}/issues/${issueNumber}`, "--jq", ".node_id"], { cwd: this.cwd, encoding: "utf-8" });
-        const nodeIdOutput = nodeIdRaw.trim();
-        const issueJson = { number: issueNumber, id: nodeIdOutput, url: issueUrl };
+        const issueJson = { number: issueNumber, id: nodeIdRaw.trim(), url: issueUrl };
         const addData = await graphql(`mutation AddProjectItem($projectId: ID!, $contentId: ID!) {
         addProjectV2ItemById(input: { projectId: $projectId, contentId: $contentId }) {
-          item {
-            id
-          }
+          item { id }
         }
       }`, { projectId, contentId: issueJson.id }, this.cwd);
         const itemId = addData.addProjectV2ItemById.item.id;
         const targetColumn = input.column ?? "Draft";
         const optionId = optionIds.get(targetColumn);
-        if (optionId) {
-          await graphql(`mutation UpdateItemField(
-          $projectId: ID!,
-          $itemId: ID!,
-          $fieldId: ID!,
-          $optionId: String!
-        ) {
-          updateProjectV2ItemFieldValue(input: {
-            projectId: $projectId,
-            itemId: $itemId,
-            fieldId: $fieldId,
-            value: { singleSelectOptionId: $optionId }
-          }) {
-            projectV2Item {
-              id
-            }
-          }
-        }`, { projectId, itemId, fieldId, optionId }, this.cwd);
-        }
+        if (optionId)
+          await this.setItemStatus(projectId, itemId, fieldId, optionId);
         const fullIssue = await this.getIssue(issueJson.number);
-        if (fullIssue) {
+        if (fullIssue)
           return { ...fullIssue, column: targetColumn };
-        }
         return {
           id: issueJson.id,
           number: issueJson.number,
@@ -2209,26 +2051,16 @@ var init_github_projects = __esm({
         const repo = await this.getRepo();
         let rawIssue;
         try {
-          const { stdout: output } = await execFileAsync2("gh", [
-            "issue",
-            "view",
-            String(issueNumber),
-            "--repo",
-            repo,
-            "--json",
-            "number,title,body,url,id,labels,assignees"
-          ], { cwd: this.cwd, encoding: "utf-8" });
+          const { stdout: output } = await execFileAsync2("gh", ["issue", "view", String(issueNumber), "--repo", repo, "--json", "number,title,body,url,id,labels,assignees"], { cwd: this.cwd, encoding: "utf-8" });
           rawIssue = JSON.parse(output);
         } catch {
           return null;
         }
         let column = null;
         try {
-          const allIssues = await this.getAllIssues();
-          const match = allIssues.find((i) => i.number === issueNumber);
-          if (match) {
+          const match = (await this.getAllIssues()).find((i) => i.number === issueNumber);
+          if (match)
             column = match.column;
-          }
         } catch {
         }
         return {
@@ -2243,53 +2075,36 @@ var init_github_projects = __esm({
         };
       }
       async getIssuesByColumn(column) {
-        const all = await this.getAllIssues();
-        return all.filter((issue) => issue.column === column);
+        return (await this.getAllIssues()).filter((issue) => issue.column === column);
       }
       async getAllIssues() {
+        const repo = await this.getRepo();
         const { projectId } = await this.ensureProjectCache();
-        const allNodes = await this.fetchAllProjectItems(projectId);
         const results = [];
-        for (const item of allNodes) {
-          const parsed = this.parseItem(item);
-          if (parsed) {
+        for (const item of await this.fetchAllProjectItems(projectId)) {
+          const parsed = this.parseItem(item, repo);
+          if (parsed)
             results.push(parsed);
-          }
         }
         return results;
       }
       async moveIssue(issueNumber, targetColumn) {
+        const repo = await this.getRepo();
         const { projectId, fieldId, optionIds } = await this.ensureProjectCache();
-        const allNodes = await this.fetchAllProjectItemsForMove(projectId);
-        const itemNode = allNodes.find((n) => n.content?.number === issueNumber);
-        if (!itemNode) {
+        const itemNode = (await this.fetchAllProjectItems(projectId)).find((n) => n.content?.number === issueNumber && this.isCurrentRepoItem(n.content, repo));
+        if (!itemNode)
           throw new Error(`Issue #${issueNumber} not found on the project board.`);
-        }
         const optionId = optionIds.get(targetColumn);
-        if (!optionId) {
+        if (!optionId)
           throw new Error(`Column "${targetColumn}" not found on the project board.`);
-        }
-        await graphql(`mutation UpdateItemField(
-        $projectId: ID!,
-        $itemId: ID!,
-        $fieldId: ID!,
-        $optionId: String!
-      ) {
-        updateProjectV2ItemFieldValue(input: {
-          projectId: $projectId,
-          itemId: $itemId,
-          fieldId: $fieldId,
-          value: { singleSelectOptionId: $optionId }
-        }) {
-          projectV2Item {
-            id
-          }
-        }
-      }`, { projectId, itemId: itemNode.id, fieldId, optionId }, this.cwd);
+        await this.setItemStatus(projectId, itemNode.id, fieldId, optionId);
       }
       async closeIssue(issueNumber) {
         const repo = await this.getRepo();
-        await execFileAsync2("gh", ["issue", "close", String(issueNumber), "--repo", repo], { cwd: this.cwd, encoding: "utf-8" });
+        await execFileAsync2("gh", ["issue", "close", String(issueNumber), "--repo", repo], {
+          cwd: this.cwd,
+          encoding: "utf-8"
+        });
       }
       async commentOnIssue(issueNumber, body) {
         const repo = await this.getRepo();
@@ -2889,123 +2704,6 @@ var init_json_state_migrator = __esm({
   }
 });
 
-// ../core/dist/utils/avatar-generator.js
-function extractOutputUrl(output) {
-  if (!output)
-    return null;
-  return Array.isArray(output) ? output[0] ?? null : output;
-}
-function buildAvatarPrompt(personaName, role) {
-  const nameKey = personaName.toLowerCase();
-  const personaDescription = PERSONA_PORTRAITS[nameKey];
-  if (personaDescription) {
-    return `Professional headshot portrait photo of a ${personaDescription}, photorealistic, clean soft neutral background, natural diffused window lighting, shot at f/2.8, shallow depth of field, looking directly at camera, candid professional headshot style, no retouching artifacts, natural skin texture`;
-  }
-  const lower = role.toLowerCase();
-  let descriptor;
-  if (lower.includes("security")) {
-    descriptor = "sharp-eyed cybersecurity professional with a serious and analytical expression, wearing a dark blazer";
-  } else if (lower.includes("architect") || lower.includes("tech lead") || lower.includes("lead")) {
-    descriptor = "confident senior software architect with a composed and thoughtful expression, business casual attire";
-  } else if (lower.includes("qa") || lower.includes("quality")) {
-    descriptor = "meticulous quality engineer with a focused and detail-oriented expression, smart casual attire";
-  } else if (lower.includes("implement") || lower.includes("developer") || lower.includes("engineer")) {
-    descriptor = "software developer with a creative and approachable expression, casual tech attire";
-  } else if (lower.includes("product") || lower.includes("manager")) {
-    descriptor = "product manager with a strategic and empathetic expression, business professional attire";
-  } else if (lower.includes("design")) {
-    descriptor = "UX/UI designer with a creative and innovative expression, modern stylish attire";
-  } else {
-    descriptor = "professional software team member with a friendly and competent expression, smart casual attire";
-  }
-  return `Professional headshot portrait photo of a ${descriptor}, photorealistic, clean soft neutral background, natural diffused window lighting, shot at f/2.8, shallow depth of field, looking directly at camera, candid professional headshot style, no retouching artifacts, natural skin texture`;
-}
-function sleep(ms) {
-  return new Promise((resolve10) => setTimeout(resolve10, ms));
-}
-async function generatePersonaAvatar(personaName, personaRole, apiToken) {
-  const prompt2 = buildAvatarPrompt(personaName, personaRole);
-  console.log(`[avatar] Generating avatar for ${personaName} (${personaRole})`);
-  const createRes = await fetch(`https://api.replicate.com/v1/models/${REPLICATE_MODEL}/predictions`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${apiToken}`,
-      "Content-Type": "application/json",
-      Prefer: "wait"
-    },
-    body: JSON.stringify({
-      input: {
-        prompt: prompt2,
-        aspect_ratio: "1:1",
-        output_format: "webp",
-        output_quality: 85
-      }
-    })
-  });
-  if (!createRes.ok) {
-    const body = await createRes.text();
-    throw new Error(`Replicate create failed (${createRes.status}): ${body}`);
-  }
-  let prediction = await createRes.json();
-  if (prediction.status === "succeeded") {
-    const url = extractOutputUrl(prediction.output);
-    console.log(`[avatar] Generated for ${personaName}: ${url}`);
-    return url;
-  }
-  for (let i = 0; i < MAX_POLLS; i++) {
-    await sleep(POLL_INTERVAL_MS);
-    const pollRes = await fetch(`https://api.replicate.com/v1/predictions/${prediction.id}`, { headers: { Authorization: `Bearer ${apiToken}` } });
-    if (!pollRes.ok)
-      continue;
-    prediction = await pollRes.json();
-    if (prediction.status === "succeeded") {
-      const url = extractOutputUrl(prediction.output);
-      console.log(`[avatar] Generated for ${personaName}: ${url}`);
-      return url;
-    }
-    if (prediction.status === "failed" || prediction.status === "canceled") {
-      throw new Error(`Replicate prediction ${prediction.status}: ${prediction.error ?? "unknown error"}`);
-    }
-    console.log(`[avatar] Polling\u2026 status=${prediction.status} (${i + 1}/${MAX_POLLS})`);
-  }
-  throw new Error("Replicate avatar generation timed out after 3 minutes");
-}
-var REPLICATE_MODEL, POLL_INTERVAL_MS, MAX_POLLS, PERSONA_PORTRAITS;
-var init_avatar_generator = __esm({
-  "../core/dist/utils/avatar-generator.js"() {
-    "use strict";
-    REPLICATE_MODEL = "black-forest-labs/flux-1.1-pro";
-    POLL_INTERVAL_MS = 3e3;
-    MAX_POLLS = 60;
-    PERSONA_PORTRAITS = {
-      maya: [
-        "South Asian woman in her late 20s with sharp dark eyes and straight black hair pulled back in a low ponytail",
-        "wearing a dark charcoal blazer over a plain black turtleneck",
-        "expression is focused and perceptive \u2014 the look of someone who notices details others miss",
-        "minimal jewelry, small silver stud earrings"
-      ].join(", "),
-      carlos: [
-        "Hispanic man in his mid-30s with short dark wavy hair and a neatly trimmed beard",
-        "wearing a navy blue henley shirt with sleeves slightly pushed up",
-        "expression is calm and confident \u2014 easy authority, like someone used to making decisions",
-        "slight smile that reads more thoughtful than warm"
-      ].join(", "),
-      priya: [
-        "Indian woman in her early 30s with shoulder-length dark brown hair with subtle highlights",
-        "wearing a soft olive green cardigan over a white crew-neck t-shirt",
-        "expression is alert and curious \u2014 bright eyes, slight head tilt, like she just thought of something interesting",
-        "round tortoiseshell glasses"
-      ].join(", "),
-      dev: [
-        "East Asian man in his late 20s with short textured black hair styled casually",
-        "wearing a heather gray crewneck sweatshirt",
-        "expression is friendly and approachable \u2014 relaxed confidence, like someone in the middle of good work",
-        "clean-shaven, natural look"
-      ].join(", ")
-    };
-  }
-});
-
 // ../core/dist/utils/logger.js
 import fs4 from "fs";
 import os2 from "os";
@@ -3761,7 +3459,7 @@ function getLockFilePaths(projectDir) {
     reviewer: `${LOCK_FILE_PREFIX}pr-reviewer-${runtimeKey}.lock`
   };
 }
-function sleep2(ms) {
+function sleep(ms) {
   return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 async function cancelProcess(processType, lockPath, force = false) {
@@ -3803,7 +3501,7 @@ async function cancelProcess(processType, lockPath, force = false) {
       message: `Failed to send SIGTERM to ${processType} (PID ${pid}): ${errorMessage}`
     };
   }
-  await sleep2(3e3);
+  await sleep(3e3);
   if (!isProcessRunning(pid)) {
     try {
       fs7.unlinkSync(lockPath);
@@ -3823,7 +3521,7 @@ async function cancelProcess(processType, lockPath, force = false) {
       message: `Failed to send SIGKILL to ${processType} (PID ${pid}): ${errorMessage}`
     };
   }
-  await sleep2(500);
+  await sleep(500);
   if (!isProcessRunning(pid)) {
     try {
       fs7.unlinkSync(lockPath);
@@ -7032,7 +6730,6 @@ __export(dist_exports, {
   formatTelegramPayload: () => formatTelegramPayload,
   generateItemHash: () => generateItemHash,
   generateMarker: () => generateMarker,
-  generatePersonaAvatar: () => generatePersonaAvatar,
   getBranchTipTimestamp: () => getBranchTipTimestamp,
   getCrontabInfo: () => getCrontabInfo,
   getDb: () => getDb,
@@ -7132,7 +6829,7 @@ __export(dist_exports, {
   scanRoadmap: () => scanRoadmap,
   sendNotifications: () => sendNotifications,
   sendWebhook: () => sendWebhook,
-  sleep: () => sleep2,
+  sleep: () => sleep,
   sliceNextItem: () => sliceNextItem,
   sliceRoadmapItem: () => sliceRoadmapItem,
   slugify: () => slugify,
@@ -7166,7 +6863,6 @@ var init_dist = __esm({
     init_migrations();
     init_json_state_migrator();
     init_container();
-    init_avatar_generator();
     init_logger();
     init_cancel();
     init_checks();
@@ -14362,7 +14058,7 @@ async function promptConfirmation(prompt2) {
     });
   });
 }
-function sleep3(ms) {
+function sleep2(ms) {
   return new Promise((resolve10) => setTimeout(resolve10, ms));
 }
 function isProcessRunning3(pid) {
@@ -14419,7 +14115,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
     };
   }
   info(`Sent SIGTERM to ${processType} (PID ${pid}), waiting 3 seconds...`);
-  await sleep3(3e3);
+  await sleep2(3e3);
   if (!isProcessRunning3(pid)) {
     try {
       fs34.unlinkSync(lockPath);
@@ -14454,7 +14150,7 @@ async function cancelProcess2(processType, lockPath, force = false) {
       message: `Failed to send SIGKILL to ${processType} (PID ${pid}): ${errorMessage}`
     };
   }
-  await sleep3(500);
+  await sleep2(500);
   if (!isProcessRunning3(pid)) {
     try {
       fs34.unlinkSync(lockPath);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jonit-dev/night-watch-cli",
-  "version": "1.7.96",
+  "version": "1.7.97",
   "description": "Autonomous PRD execution using AI Provider CLIs + cron",
   "type": "module",
   "bin": {