@craftsamo/github-tools 0.6.1 → 0.7.0

package/dist/mcp.js

@@ -29830,7 +29830,7 @@ function issueFieldValues(connection) {
 }
 var SCHEMA_ERROR_PATTERNS = [
   /issueFieldValues.*(?:doesn['’]t exist on type|is not defined on type).*['"`]?Issue['"`]?/i,
-  /issueFields.*(?:doesn['’]t exist on type|is not defined on type).*['"`]?Repository['"`]?/i,
+  /issueFields.*(?:doesn['’]t exist on type|is not defined on type).*['"`]?(?:Repository|Organization)['"`]?/i,
   /(?:isIssueField|issueField).*(?:doesn['’]t exist on type|is not defined on type).*['"`]?ProjectV2/i,
   /(?:No such type\s+['"`]?(?:ProjectV2ItemIssueFieldValue|ProjectV2IssueFieldValues)['"`]?|(?:ProjectV2ItemIssueFieldValue|ProjectV2IssueFieldValues).*(?:doesn['’]t exist|is not defined))/i
 ];
@@ -29849,7 +29849,9 @@ function isIssueFieldsMissingError(error62) {
 var issueFieldInputSchema = issueFieldValuesSchema;
 var ISSUE_FIELDS_ARGUMENT = `The organization's issue fields to set, by field name (without regard to case): {"Priority": "High", "Target date": "2026-12-01"}. Each takes a text, a number, a date as YYYY-MM-DD, an option name, or a list of option names for a multi-select field.`;
 var MAX_ISSUE_FIELDS = 25;
-var DEFINITIONS_QUERY = `query($owner:String!,$name:String!){repository(owner:$owner,name:$name){issueFields(first:${MAX_ISSUE_FIELDS}){nodes{__typename ... on IssueFieldCommon{name dataType} ... on IssueFieldText{id} ... on IssueFieldNumber{id} ... on IssueFieldDate{id} ... on IssueFieldSingleSelect{id options{id name}} ... on IssueFieldMultiSelect{id options{id name}}}}}}`;
+var DEFINITION_SELECTION = "__typename ... on IssueFieldCommon{name dataType} ... on IssueFieldText{id} ... on IssueFieldNumber{id} ... on IssueFieldDate{id} ... on IssueFieldSingleSelect{id options{id name}} ... on IssueFieldMultiSelect{id options{id name}}";
+var DEFINITIONS_QUERY = `query($owner:String!,$name:String!){repository(owner:$owner,name:$name){issueFields(first:${MAX_ISSUE_FIELDS}){nodes{${DEFINITION_SELECTION}}}}}`;
+var ORGANIZATION_DEFINITIONS_QUERY = `query($login:String!){repositoryOwner(login:$login){__typename ... on Organization{issueFields(first:${MAX_ISSUE_FIELDS}){nodes{${DEFINITION_SELECTION}}}}}}`;
 var VALUES_QUERY = `query($id:ID!){node(id:$id){... on Issue{${ISSUE_FIELD_VALUES_FRAGMENT}}}}`;
 var issueFieldTypes = {
   TEXT: "text",
@@ -29885,6 +29887,20 @@ async function readIssueFieldDefinitions(repo, ctx) {
   }
   return (data?.repository?.issueFields?.nodes ?? []).flatMap((raw) => definitionOf(raw) ?? []);
 }
+async function readOrganizationIssueFields(login, ctx) {
+  let data;
+  try {
+    data = await graphql(ORGANIZATION_DEFINITIONS_QUERY, { login }, ctx);
+  } catch (error62) {
+    if (isIssueFieldsMissingError(error62)) return null;
+    throw error62;
+  }
+  if (data?.repositoryOwner?.__typename !== "Organization") return null;
+  return (data.repositoryOwner.issueFields?.nodes ?? []).flatMap((raw) => definitionOf(raw) ?? []);
+}
+function findIssueField(definitions, name) {
+  return definitions.find((candidate) => sameTitle(candidate.name, name));
+}
 function invalid4(message) {
   return new ToolError("invalid_argument", message);
 }
@@ -29892,7 +29908,7 @@ function fieldNames(definitions) {
   return listOf(definitions.map((field) => field.name));
 }
 function fieldOf(repo, definitions, name) {
-  const field = definitions.find((candidate) => sameTitle(candidate.name, name));
+  const field = findIssueField(definitions, name);
   if (!field) throw invalid4(`${repo.full} has no issue field "${name}". Fields: ${fieldNames(definitions)}.`);
   return field;
 }
@@ -30938,6 +30954,7 @@ var STATUS_FIELD = "Status";
 var FIELD_REPLY = `projectV2Field{${FIELD_SELECTION}}`;
 var createFieldMutation = (type, options) => `mutation($project:ID!,$name:String!){createProjectV2Field(input:{projectId:$project,dataType:${type.toUpperCase()},name:$name${options}}){${FIELD_REPLY}}}`;
 var updateOptionsMutation = (options) => `mutation($field:ID!){updateProjectV2Field(input:{fieldId:$field,singleSelectOptions:${options}}){${FIELD_REPLY}}}`;
+var createIssueFieldColumnMutation = `mutation($project:ID!,$field:ID!){createProjectV2IssueField(input:{projectId:$project,issueFieldId:$field}){projectV2Field{${READ_FIELD_SELECTION}}}}`;
 function invalid7(message) {
   return new ToolError("invalid_argument", message);
 }
@@ -30950,6 +30967,29 @@ function fieldRequest(name, type, options) {
   }
   return { name: trimmed, type, options: parsed };
 }
+function issueFieldColumnRequest(name, type) {
+  const trimmed = name.trim();
+  if (!trimmed) throw invalid7("name cannot be blank.");
+  return { name: trimmed, type };
+}
+async function readOwnerIssueFields(owner, ctx) {
+  return owner.owner_type === "organization" ? readOrganizationIssueFields(owner.owner, ctx) : null;
+}
+function requireIssueField(owner, definitions, request2) {
+  if (owner.owner_type !== "organization") {
+    throw invalid7(`Issue fields belong to an organization; ${owner.owner} is a user.`);
+  }
+  if (!definitions) throw invalid7("This GitHub has no issue fields.");
+  const definition = findIssueField(definitions, request2.name);
+  if (!definition) {
+    const names = listOf(definitions.map((field) => field.name));
+    throw invalid7(`${owner.owner} has no issue field "${request2.name}". Issue fields: ${names}.`);
+  }
+  if (request2.type && request2.type !== definition.type) {
+    throw invalid7(`"${definition.name}" is ${definition.type}, not ${request2.type}.`);
+  }
+  return definition;
+}
 function optionsLiteral(options) {
   const items = options.map((option) => {
     if (!OPTION_COLORS.some((color) => color === option.color)) {
@@ -31007,6 +31047,23 @@ async function ensureField(board, fields, request2, policy, ctx) {
   const field = fieldOf2(data?.updateProjectV2Field ?? null, existing.name);
   return { field, created: false, added_options: merge2.added, updated_options: merge2.updated };
 }
+async function ensureIssueFieldColumn(board, fields, definitions, request2, ctx) {
+  const definition = requireIssueField(board, definitions, request2);
+  const existing = fields.find((field2) => sameTitle(field2.name, definition.name));
+  if (existing?.issue_field) return { field: existing, created: false, added_options: [], updated_options: [] };
+  if (existing) {
+    throw invalid7(
+      `The board has its own field "${existing.name}"; an issue field column cannot take the same name. Rename or delete the board's field in the web UI, or use the board's field.`
+    );
+  }
+  const data = await graphql(
+    createIssueFieldColumnMutation,
+    { project: board.id, field: definition.id },
+    ctx
+  );
+  const field = fieldOf2(data?.createProjectV2IssueField ?? null, definition.name);
+  return { field, created: true, added_options: [], updated_options: [] };
+}
 
 // src/core/projects/support.ts
 var BOARD_SELECTION = {
@@ -31030,60 +31087,65 @@ function boardSummary(board) {
 // src/core/projects/template.ts
 var STATUS_TODO = "Todo";
 var STATUS_WAITING = "Waiting";
-var START_FIELD = "Start";
-var TARGET_FIELD = "Target";
-var NOT_DONE = "-status:Done -status:Cancelled";
+var DATE_MODES = ["board", "issue_fields"];
+var BOARD_DATE_FIELDS = { start: "Start", target: "Target" };
+var ISSUE_DATE_FIELDS = { start: "Start date", target: "Target date" };
 var DEFAULT_VIEW_NAME = "View 1";
-var ROADMAP_NOTE = "Set the Roadmap view's date fields to Start and Target in the web UI; the API cannot set them.";
-var STANDARD_FIELDS = [
-  {
-    name: STATUS_FIELD,
-    type: "single_select",
-    options: [
-      { name: STATUS_TODO, color: "BLUE", description: "Ready to start; nothing is in the way." },
-      { name: "In Progress", color: "YELLOW", description: "Being worked on now." },
+function roadmapNote(dates) {
+  return `Set the Roadmap view's date fields to ${dates.start} and ${dates.target} in the web UI; the API cannot set them.`;
+}
+var ROADMAP_NOTE = roadmapNote(BOARD_DATE_FIELDS);
+var STATUS_REQUEST = {
+  name: STATUS_FIELD,
+  type: "single_select",
+  options: [
+    { name: STATUS_TODO, color: "BLUE", description: "Ready to start; nothing is in the way." },
+    { name: "In Progress", color: "YELLOW", description: "Being worked on now." },
+    {
+      name: STATUS_WAITING,
+      color: "GRAY",
+      description: "Cannot move until something else clears: an open blocking issue, a review or a reply."
+    },
+    { name: "Done", color: "PURPLE", description: "Finished." },
+    { name: "Cancelled", color: "RED", description: "Will not be done; kept for the record." }
+  ]
+};
+function standardTemplate(dates) {
+  const notDone = "-status:Done -status:Cancelled";
+  return {
+    roadmapNote: roadmapNote(dates),
+    views: [
+      { name: "Roadmap", layout: "roadmap", filter: "-status:Cancelled", sort_by: dates.start },
       {
-        name: STATUS_WAITING,
-        color: "GRAY",
-        description: "Cannot move until something else clears: an open blocking issue, a review or a reply."
+        name: "Kanban",
+        layout: "board",
+        filter: notDone,
+        column_by: STATUS_FIELD,
+        fields: ["Title", "Assignees", "Repository", "Parent issue", dates.target],
+        sort_by: dates.target
       },
-      { name: "Done", color: "PURPLE", description: "Finished." },
-      { name: "Cancelled", color: "RED", description: "Will not be done; kept for the record." }
+      {
+        name: "Backlog",
+        layout: "table",
+        filter: notDone,
+        fields: [
+          "Title",
+          STATUS_FIELD,
+          "Assignees",
+          "Repository",
+          "Milestone",
+          "Parent issue",
+          "Sub-issues progress",
+          dates.start,
+          dates.target,
+          "Linked pull requests"
+        ],
+        group_by: STATUS_FIELD,
+        sort_by: dates.target
+      }
     ]
-  },
-  { name: START_FIELD, type: "date", options: [] },
-  { name: TARGET_FIELD, type: "date", options: [] }
-];
-var STANDARD_VIEWS = [
-  { name: "Roadmap", layout: "roadmap", filter: "-status:Cancelled", sort_by: START_FIELD },
-  {
-    name: "Kanban",
-    layout: "board",
-    filter: NOT_DONE,
-    column_by: STATUS_FIELD,
-    fields: ["Title", "Assignees", "Repository", "Parent issue", TARGET_FIELD],
-    sort_by: TARGET_FIELD
-  },
-  {
-    name: "Backlog",
-    layout: "table",
-    filter: NOT_DONE,
-    fields: [
-      "Title",
-      STATUS_FIELD,
-      "Assignees",
-      "Repository",
-      "Milestone",
-      "Parent issue",
-      "Sub-issues progress",
-      START_FIELD,
-      TARGET_FIELD,
-      "Linked pull requests"
-    ],
-    group_by: STATUS_FIELD,
-    sort_by: TARGET_FIELD
-  }
-];
+  };
+}
 
 // src/core/projects/item-support.ts
 var ITEM_BOARD_SELECTION = {
@@ -32318,6 +32380,9 @@ var input10 = external_exports.object({
     "A board to copy, without its draft items, when the board has to be made: its number, owner/number or URL (a bare number or a title is looked up among owner's boards)."
   ),
   standard: external_exports.boolean().optional().describe("Bring the board to the standard template: its fields and views (default true)."),
+  dates: external_exports.enum(DATE_MODES).optional().describe(
+    `"board" (default) makes the board's own date fields Start and Target; "issue_fields" uses the organization's issue fields Start date and Target date instead, so an issue carries the same dates on every board and they are set with the issue tools (a pull request or draft has none). Organization boards only.`
+  ),
   link_repo: external_exports.string().optional().describe("owner/name of a repository to link the board to; needs write permission.")
 });
 var output10 = external_exports.object({
@@ -32349,23 +32414,41 @@ function openBoardTitled(boards, title) {
   }
   return matches[0];
 }
-async function applyFields(board, fresh, report, ctx) {
+async function applyFields(board, fresh, mode, dates, definitions, report, ctx) {
   const fields = await readBoardFields(board.id, ctx);
-  for (const request2 of STANDARD_FIELDS) {
-    const { field, created, added_options, updated_options } = await ensureField(
-      board,
-      fields,
-      request2,
-      fresh && request2.name === STATUS_FIELD ? "replace" : "append",
-      ctx
-    );
-    report.push({ field: field.name, created, added_options, updated_options });
+  const status = await ensureField(board, fields, STATUS_REQUEST, fresh ? "replace" : "append", ctx);
+  report.push({
+    field: status.field.name,
+    created: status.created,
+    added_options: status.added_options,
+    updated_options: status.updated_options
+  });
+  if (mode === "issue_fields") {
+    for (const name of [dates.start, dates.target]) {
+      const outcome = await ensureIssueFieldColumn(board, fields, definitions, { name, type: "date" }, ctx);
+      report.push({
+        field: outcome.field.name,
+        created: outcome.created,
+        added_options: outcome.added_options,
+        updated_options: outcome.updated_options
+      });
+    }
+  } else {
+    for (const name of [dates.start, dates.target]) {
+      const outcome = await ensureField(board, fields, { name, type: "date", options: [] }, "append", ctx);
+      report.push({
+        field: outcome.field.name,
+        created: outcome.created,
+        added_options: outcome.added_options,
+        updated_options: outcome.updated_options
+      });
+    }
   }
 }
-async function applyViews(board, report, notes, ctx) {
+async function applyViews(board, templateViews, roadmapNote2, report, notes, ctx) {
   const before = await readBoardViewNodes(board.id, ctx);
   const readers = viewFieldReaders(board, ctx);
-  for (const request2 of STANDARD_VIEWS) {
+  for (const request2 of templateViews) {
     if (before.some((view5) => sameTitle(view5.name, request2.name))) {
       report.push({ view: request2.name, created: false });
       continue;
@@ -32377,7 +32460,7 @@ async function applyViews(board, report, notes, ctx) {
       throw error62;
     }
     report.push({ view: request2.name, created: true });
-    if (request2.layout === "roadmap") notes.push(ROADMAP_NOTE);
+    if (request2.layout === "roadmap") notes.push(roadmapNote2);
   }
   return before;
 }
@@ -32387,6 +32470,7 @@ var projectCreate = defineTool({
   description: [
     `Create a project board for a user or organization, or reuse the open board of that owner and exact title (case-insensitive; several are invalid_argument), and bring it to the standard template. The title defaults to ${DEFAULT_BOARD_TITLE}. A board that has to be made is empty, or a copy of template without its draft items.`,
     "With standard (the default): the fields Status (Todo, In Progress, Waiting, Done, Cancelled, each with a color and a description), Start and Target (dates), and the views Roadmap, Kanban and Backlog. On a board this call made, Status gets exactly those options, keeping the ids of GitHub's own Todo, In Progress and Done, and GitHub's default view View 1 is deleted once the three views exist. On a reused or copied board only the missing fields, options and views are added, and nothing is deleted. A reused board must be one the viewer may update.",
+    `dates: "issue_fields" uses the organization's issue fields Start date and Target date as the board's dates, refused before the board is made when the owner is a user or lacks them.`,
     "link_repo links the board to a repository (needs write permission there) unless it is already linked. GitHub links only boards of the repository's own owner, so a repository of another owner is invalid_argument, before the board is made.",
     "Once the board exists, a failed step does not fail the call: it is listed in errors and the board is still returned.",
     `notes lists what the API cannot do, such as setting the Roadmap view's date fields. ${PROJECT_SCOPE_NOTE}`
@@ -32412,6 +32496,23 @@ var projectCreate = defineTool({
       linkRepo = await writableContext(repo, ctx);
     }
     const owner = await readBoardOwner(login, ctx);
+    const dateMode = args.dates ?? "board";
+    let dateNames = BOARD_DATE_FIELDS;
+    let definitions = null;
+    if (dateMode === "issue_fields") {
+      if (!standard) throw invalid5("dates applies only with standard.");
+      definitions = await readOwnerIssueFields({ owner: owner.login, owner_type: owner.type }, ctx);
+      const startDef = requireIssueField({ owner: owner.login, owner_type: owner.type }, definitions, {
+        name: ISSUE_DATE_FIELDS.start,
+        type: "date"
+      });
+      const targetDef = requireIssueField({ owner: owner.login, owner_type: owner.type }, definitions, {
+        name: ISSUE_DATE_FIELDS.target,
+        type: "date"
+      });
+      dateNames = { start: startDef.name, target: targetDef.name };
+    }
+    const template = standardTemplate(dateNames);
     const reused = openBoardTitled((await ownerBoards(owner.login, ctx, owner.type)).boards, title);
     if (reused) assertBoardWritable(reused);
     const source = reused || !templateRef ? void 0 : (await resolveBoard({ project: templateRef, owner: ownerArg }, ctx)).project;
@@ -32424,8 +32525,11 @@ var projectCreate = defineTool({
     const notes = [];
     let deletedDefaultView = false;
     if (standard) {
-      await steps.record("fields", () => applyFields(board, fresh, fields, ctx));
-      const before = await steps.record("views", () => applyViews(board, views, notes, ctx));
+      await steps.record("fields", () => applyFields(board, fresh, dateMode, dateNames, definitions, fields, ctx));
+      const before = await steps.record(
+        "views",
+        () => applyViews(board, template.views, template.roadmapNote, views, notes, ctx)
+      );
       const defaultView = fresh ? before?.find((view5) => view5.name === DEFAULT_VIEW_NAME) : void 0;
       if (defaultView) {
         deletedDefaultView = await steps.record("default_view", async () => {
@@ -32456,9 +32560,14 @@ var projectCreate = defineTool({
 var input11 = external_exports.object({
   ...BOARD_SELECTION,
   name: external_exports.string().describe("The field's name, matched without regard to case."),
-  type: external_exports.enum(FIELD_TYPES).describe("The field's type; a field of that name with another type is invalid_argument."),
+  type: external_exports.enum(FIELD_TYPES).optional().describe(
+    "The field's type; a field of that name with another type is invalid_argument. Required unless issue_field is true, where it only checks the issue field's type."
+  ),
   options: external_exports.array(external_exports.string()).optional().describe(
-    `single_select only: Name, Name:COLOR or Name:COLOR:Description (the description is everything after the second colon). COLOR is one of ${OPTION_COLORS.join(", ")}, in any case; the default is GRAY.`
+    `single_select only, not with issue_field: Name, Name:COLOR or Name:COLOR:Description (the description is everything after the second colon). COLOR is one of ${OPTION_COLORS.join(", ")}, in any case; the default is GRAY.`
+  ),
+  issue_field: external_exports.boolean().optional().describe(
+    "Add a column that mirrors the organization's issue field of that name instead of a field of the board's own; its options and values are the organization's and the issue's."
   )
 });
 var output11 = external_exports.object({
@@ -32467,12 +32576,25 @@ var output11 = external_exports.object({
   created: external_exports.boolean().describe("Whether this call made the field."),
   added_options: external_exports.array(external_exports.string()).describe("The names of the options this call added; [] when none.")
 });
+function planEnsure(args) {
+  if (args.issue_field) {
+    if (args.options && args.options.length > 0) {
+      throw new ToolError("invalid_argument", "options are the organization's with issue_field; leave them out.");
+    }
+    const request3 = issueFieldColumnRequest(args.name, args.type);
+    return async (board, fields, ctx) => ensureIssueFieldColumn(board, fields, await readOwnerIssueFields(board, ctx), request3, ctx);
+  }
+  if (!args.type) throw new ToolError("invalid_argument", "type is required unless issue_field is true.");
+  const request2 = fieldRequest(args.name, args.type, args.options);
+  return (board, fields, ctx) => ensureField(board, fields, request2, "append", ctx);
+}
 var projectFieldEnsure = defineTool({
   id: "github_project_field_ensure",
   title: "Ensure a GitHub project field",
   description: [
     "Make sure a field exists on a project board the viewer may update, without ever making a second one: a missing field is created, and the missing options of an existing single select are appended after its own, which keep their id, name, color, description and order, so nothing already set moves.",
     "A new single_select field needs options. Status can be extended but not created. A field of that name with another type, options on a field that is not single_select, a repeated option name and a color GitHub does not list are invalid_argument, before anything is written.",
+    "With issue_field: true (organization boards only) the column mirrors the organization's issue field of that name, such as Priority, Start date or Target date; it is added when the board lacks it, and a field of the board's own with that name is invalid_argument.",
     BOARD_LOOKUP_NOTE,
     PROJECT_SCOPE_NOTE
   ].join(" "),
@@ -32482,11 +32604,11 @@ var projectFieldEnsure = defineTool({
   input: input11,
   output: output11,
   async execute(args, ctx) {
-    const request2 = fieldRequest(args.name, args.type, args.options);
+    const ensure = planEnsure(args);
     const { project } = await resolveBoard(args, ctx);
     assertBoardWritable(project);
     const fields = await readBoardFields(project.id, ctx);
-    const { field, created, added_options } = await ensureField(project, fields, request2, "append", ctx);
+    const { field, created, added_options } = await ensure(project, fields, ctx);
     return { project: boardSummary(project), field, created, added_options };
   }
 });
@@ -37967,7 +38089,7 @@ async function main() {
     const settings = parseSettings(process.argv.slice(2), process.env);
     server = createServer(ALL_TOOLS, settings, {
       ownDir: packageRoot(import.meta.url),
-      version: true ? "0.6.1" : void 0
+      version: true ? "0.7.0" : void 0
     });
   } catch (error62) {
     if (!isToolError(error62)) throw error62;