@staff0rd/assist 0.461.3 → 0.462.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@staff0rd/assist",
-  version: "0.461.3",
+  version: "0.462.0",
   type: "module",
   main: "dist/index.js",
   bin: {
@@ -3365,7 +3365,7 @@ function collectHashComments(content, options2) {
 function collectComments(sourceFile) {
   const seen = /* @__PURE__ */ new Set();
   const comments3 = [];
-  const collect6 = (node) => {
+  const collect5 = (node) => {
     for (const range of [
       ...node.getLeadingCommentRanges(),
       ...node.getTrailingCommentRanges()
@@ -3376,8 +3376,8 @@ function collectComments(sourceFile) {
       comments3.push({ pos, text: range.getText() });
     }
   };
-  collect6(sourceFile);
-  sourceFile.forEachDescendant(collect6);
+  collect5(sourceFile);
+  sourceFile.forEachDescendant(collect5);
   return comments3;
 }
 
@@ -3596,16 +3596,19 @@ var WRAPPER_TYPES = /* @__PURE__ */ new Set([
   "readonly",
   "catch"
 ]);
+var OPTIONAL_TYPES = /* @__PURE__ */ new Set(["optional", "nullish"]);
 function unwrapSchemaNode(node) {
   let current = node;
   let defaultValue;
+  let optional = false;
   while (current.def && WRAPPER_TYPES.has(current.def.type ?? "") && current.def.innerType) {
     if (current.def.type === "default" && defaultValue === void 0) {
       defaultValue = current.def.defaultValue;
     }
+    if (OPTIONAL_TYPES.has(current.def.type ?? "")) optional = true;
     current = current.def.innerType;
   }
-  return { inner: current, defaultValue };
+  return { inner: current, defaultValue, optional };
 }
 
 // src/shared/scalarUnionMembers.ts
@@ -3649,7 +3652,67 @@ function scalarArrayItemType(node) {
   return isScalarLeafType(type) ? type : void 0;
 }
 
-// src/shared/describeConfigLeaves.ts
+// src/shared/listConfigNode.ts
+function scalarListNode(inner, base, item) {
+  const itemType = scalarArrayItemType(inner);
+  if (!itemType || item.kind !== "scalar") return void 0;
+  return { ...base, kind: "scalarList", itemType, item };
+}
+function objectListNode(base, item) {
+  if (item.kind !== "object" && item.kind !== "unionOfObjects")
+    return void 0;
+  return { ...base, kind: "objectList", item };
+}
+function listConfigNode(inner, base, build2) {
+  const element = inner.def?.element;
+  if (inner.def?.type !== "array" || !element) return void 0;
+  const item = build2(element, [...base.path, { kind: "item" }]);
+  return scalarListNode(inner, base, item) ?? objectListNode(base, item);
+}
+
+// src/shared/objectConfigNode.ts
+function objectConfigNode(inner, base, build2) {
+  const shape = inner.def?.shape;
+  if (inner.def?.type !== "object" || !shape) return void 0;
+  const fields = Object.entries(shape).map(
+    ([name, child]) => build2(child, [...base.path, { kind: "key", name }])
+  );
+  return { ...base, kind: "object", fields };
+}
+function unionOfObjectsConfigNode(inner, base, build2) {
+  const options2 = inner.def?.options;
+  if (inner.def?.type !== "union" || !options2?.length) return void 0;
+  const variants = [];
+  for (const option of options2) {
+    const variant = build2(option, base.path);
+    if (variant.kind !== "object") return void 0;
+    variants.push(variant);
+  }
+  return { ...base, kind: "unionOfObjects", variants };
+}
+
+// src/shared/recordConfigNode.ts
+function recordConfigNode(inner, base, build2) {
+  const valueType = inner.def?.valueType;
+  if (inner.def?.type !== "record" || !valueType) return void 0;
+  const value = build2(valueType, [...base.path, { kind: "entry" }]);
+  return { ...base, kind: "record", value };
+}
+
+// src/shared/scalarConfigNode.ts
+function scalarConfigNode(inner, base) {
+  const unionTypes = scalarUnionMembers(inner);
+  if (unionTypes) return { ...base, kind: "scalar", type: "union", unionTypes };
+  const type = leafTypeOf(inner);
+  if (!isScalarLeafType(type)) return void 0;
+  const values = type === "enum" ? enumValues(inner) : void 0;
+  return {
+    ...base,
+    kind: "scalar",
+    type,
+    ...values ? { enumValues: values } : {}
+  };
+}
 function enumValues(node) {
   const entries = node.def?.entries;
   if (!entries) return void 0;
@@ -3657,31 +3720,81 @@ function enumValues(node) {
     (value) => typeof value === "string"
   );
 }
-function toLeaf(key, node, defaultValue) {
-  const unionTypes = scalarUnionMembers(node);
-  const type = unionTypes ? "union" : leafTypeOf(node);
-  const leaf = { key, type };
-  if (type === "enum") leaf.enumValues = enumValues(node);
-  if (unionTypes) leaf.unionTypes = unionTypes;
-  const itemType = scalarArrayItemType(node);
-  if (itemType) leaf.itemType = itemType;
-  if (defaultValue !== void 0) leaf.defaultValue = defaultValue;
+
+// src/shared/describeConfigNode.ts
+function opaqueConfigNode(inner, base) {
+  return { ...base, kind: "other", type: leafTypeOf(inner) };
+}
+function build(node, path71) {
+  const { inner, defaultValue, optional } = unwrapSchemaNode(node);
+  const base = {
+    path: path71,
+    ...optional ? { optional: true } : {},
+    ...defaultValue === void 0 ? {} : { defaultValue }
+  };
+  return scalarConfigNode(inner, base) ?? objectConfigNode(inner, base, build) ?? listConfigNode(inner, base, build) ?? recordConfigNode(inner, base, build) ?? unionOfObjectsConfigNode(inner, base, build) ?? opaqueConfigNode(inner, base);
+}
+function describeConfigNode(schema2) {
+  return build(schema2, []);
+}
+
+// src/shared/formatConfigPath.ts
+var RECORD_ENTRY_TOKEN = "*";
+function segmentText(segment) {
+  if (segment.kind === "key") return segment.name;
+  if (segment.kind === "entry") return RECORD_ENTRY_TOKEN;
+  if (segment.kind === "index") return `[${segment.index}]`;
+  return "[]";
+}
+function formatConfigPath(path71) {
+  let text17 = "";
+  for (const segment of path71) {
+    const dotted = segment.kind === "key" || segment.kind === "entry";
+    const rendered = segmentText(segment);
+    text17 += dotted && text17 ? `.${rendered}` : rendered;
+  }
+  return text17;
+}
+
+// src/shared/describeConfigLeaves.ts
+function leafType(node) {
+  switch (node.kind) {
+    case "scalar":
+      return node.type;
+    case "scalarList":
+    case "objectList":
+      return "array";
+    case "record":
+      return "record";
+    case "other":
+      return node.type;
+    default:
+      return "other";
+  }
+}
+function toLeaf(node) {
+  const leaf = {
+    key: formatConfigPath(node.path),
+    type: leafType(node)
+  };
+  if (node.kind === "scalar") {
+    if (node.enumValues) leaf.enumValues = node.enumValues;
+    if (node.unionTypes) leaf.unionTypes = node.unionTypes;
+  }
+  if (node.kind === "scalarList") leaf.itemType = node.itemType;
+  if (node.defaultValue !== void 0) leaf.defaultValue = node.defaultValue;
   return leaf;
 }
-function collect(node, prefix2, out) {
-  const { inner, defaultValue } = unwrapSchemaNode(node);
-  const shape = inner.def?.shape;
-  if (inner.def?.type === "object" && shape) {
-    for (const [key, child] of Object.entries(shape)) {
-      collect(child, prefix2 ? `${prefix2}.${key}` : key, out);
-    }
+function flatten(node, out) {
+  if (node.kind === "object") {
+    for (const field of node.fields) flatten(field, out);
     return;
   }
-  out.push(toLeaf(prefix2, inner, defaultValue));
+  out.push(toLeaf(node));
 }
 function describeConfigLeaves(schema2) {
   const out = [];
-  collect(schema2, "", out);
+  flatten(describeConfigNode(schema2), out);
   return out.sort((a, b) => a.key < b.key ? -1 : a.key > b.key ? 1 : 0);
 }
 
@@ -9224,16 +9337,104 @@ function resolveConfigSource(key, layers) {
   return "default";
 }
 
+// src/shared/configNodeFieldName.ts
+function configNodeFieldName(node) {
+  const last = node.path.at(-1);
+  return last?.kind === "key" ? last.name : void 0;
+}
+
+// src/shared/findConfigNode.ts
+function objectField(node, segment) {
+  if (segment.kind !== "key") return void 0;
+  return node.fields.find(
+    (field) => configNodeFieldName(field) === segment.name
+  );
+}
+function variantField(node, segment) {
+  for (const variant of node.variants) {
+    const found = objectField(variant, segment);
+    if (found) return found;
+  }
+  return void 0;
+}
+function step(node, segment) {
+  const intoItem = segment.kind === "item" || segment.kind === "index";
+  const intoEntry = segment.kind === "entry" || segment.kind === "key";
+  switch (node.kind) {
+    case "object":
+      return objectField(node, segment);
+    case "unionOfObjects":
+      return variantField(node, segment);
+    case "objectList":
+    case "scalarList":
+      return intoItem ? node.item : void 0;
+    case "record":
+      return intoEntry ? node.value : void 0;
+    default:
+      return void 0;
+  }
+}
+function findConfigNode(root, path71) {
+  let current = root;
+  for (const segment of path71) {
+    if (!current) return void 0;
+    current = step(current, segment);
+  }
+  return current;
+}
+
+// src/shared/parseConfigPath.ts
+var INDEX = /^\d+$/;
+function bracketSegment(inner) {
+  if (inner === "") return { kind: "item" };
+  return INDEX.test(inner) ? { kind: "index", index: Number(inner) } : void 0;
+}
+function nameSegment(name) {
+  return name === RECORD_ENTRY_TOKEN ? { kind: "entry" } : { kind: "key", name };
+}
+function parseConfigPath(text17) {
+  const path71 = [];
+  let at2 = 0;
+  while (at2 < text17.length) {
+    if (text17[at2] === "[") {
+      const close = text17.indexOf("]", at2);
+      const segment = close === -1 ? void 0 : bracketSegment(text17.slice(at2 + 1, close));
+      if (!segment) return void 0;
+      path71.push(segment);
+      at2 = close + 1;
+      continue;
+    }
+    if (text17[at2] === ".") {
+      if (path71.length === 0) return void 0;
+      at2 += 1;
+    }
+    const start3 = at2;
+    while (at2 < text17.length && text17[at2] !== "." && text17[at2] !== "[") at2 += 1;
+    const name = text17.slice(start3, at2);
+    if (!name) return void 0;
+    path71.push(nameSegment(name));
+  }
+  return path71;
+}
+
+// src/commands/config/configEntryNode.ts
+function configEntryNode(root, key) {
+  const path71 = parseConfigPath(key);
+  return path71 ? findConfigNode(root, path71) : void 0;
+}
+
 // src/commands/config/readConfigEntries.ts
 var KEYS_STRIPPED_FROM_MERGED_CONFIG = /* @__PURE__ */ new Set(["repos"]);
 function readConfigEntries(cwd) {
   const config = loadConfigFrom(cwd);
   const layers = readRawConfigLayers(cwd);
+  const schema2 = describeConfigNode(assistConfigSchema);
   return describeConfigLeaves(assistConfigSchema).filter((leaf) => !KEYS_STRIPPED_FROM_MERGED_CONFIG.has(leaf.key)).map((leaf) => ({
     ...leaf,
     value: getNestedValue(config, leaf.key),
     source: resolveConfigSource(leaf.key, layers),
-    globalOnly: isGlobalOnlyConfigKey(leaf.key)
+    globalOnly: isGlobalOnlyConfigKey(leaf.key),
+    node: configEntryNode(schema2, leaf.key)
   }));
 }
 
@@ -10155,6 +10356,41 @@ function coerceString(key, raw) {
   return { ok: false, error: `${key}: expected a string` };
 }
 
+// src/shared/configLeafSchema.ts
+function configLeafSchema(schema2, key) {
+  let current = schema2;
+  for (const name of key.split(".")) {
+    const { inner } = unwrapSchemaNode(current);
+    const child = inner.def?.type === "object" ? inner.def.shape?.[name] : void 0;
+    if (!child) return void 0;
+    current = child;
+  }
+  return current;
+}
+
+// src/commands/config/coerceStructuredConfigValue.ts
+function coerceStructuredConfigValue(key, raw) {
+  const schema2 = configLeafSchema(assistConfigSchema, key);
+  if (!schema2) return { ok: false, error: `Unknown config key "${key}"` };
+  const parsed = schema2.safeParse(raw);
+  if (parsed.success)
+    return { ok: true, value: parsed.data };
+  return {
+    ok: false,
+    error: parsed.error.issues.map((issue) => formatIssue2(key, issue)).join("\n")
+  };
+}
+function formatIssue2(key, issue) {
+  const path71 = formatConfigPath([
+    { kind: "key", name: key },
+    ...issue.path.map(toSegment)
+  ]);
+  return `${path71}: ${issue.message}`;
+}
+function toSegment(part) {
+  return typeof part === "number" ? { kind: "index", index: part } : { kind: "key", name: String(part) };
+}
+
 // src/commands/config/coerceConfigValue.ts
 var EDITABLE_TYPES = /* @__PURE__ */ new Set([
   "string",
@@ -10169,12 +10405,8 @@ function coerceConfigValue(key, raw) {
   );
   if (!leaf) return { ok: false, error: `Unknown config key "${key}"` };
   if (leaf.itemType) return coerceScalarList(key, raw, leaf.itemType);
-  if (!EDITABLE_TYPES.has(leaf.type)) {
-    return {
-      ok: false,
-      error: `"${key}" is a ${leaf.type} value and is read-only here`
-    };
-  }
+  if (!EDITABLE_TYPES.has(leaf.type))
+    return coerceStructuredConfigValue(key, raw);
   if (leaf.type === "union")
     return coerceUnion(key, raw, leaf.unionTypes ?? []);
   return coerceConfigScalar(key, raw, leaf.type);
@@ -13137,14 +13369,14 @@ async function updatePhase(id, phase, options2) {
 }
 
 // src/commands/backlog/registerUpdatePhaseCommand.ts
-function collect2(value, previous) {
+function collect(value, previous) {
   return [...previous, value];
 }
 function registerUpdatePhaseCommand(cmd) {
-  cmd.command("update-phase <id> <phase>").alias("edit-phase").description("Modify a plan phase on a backlog item").option("--name <name>", "New phase name").option("--task <task...>", "Replace tasks (repeatable)").option("--manual-check <check...>", "Replace manual checks (repeatable)").option("--add-task <text>", "Append one task (repeatable)", collect2, []).option("--edit-task <n> <text...>", "Replace task n (1-based) in place").option("--remove-task <n>", "Remove task n (1-based)").option(
+  cmd.command("update-phase <id> <phase>").alias("edit-phase").description("Modify a plan phase on a backlog item").option("--name <name>", "New phase name").option("--task <task...>", "Replace tasks (repeatable)").option("--manual-check <check...>", "Replace manual checks (repeatable)").option("--add-task <text>", "Append one task (repeatable)", collect, []).option("--edit-task <n> <text...>", "Replace task n (1-based) in place").option("--remove-task <n>", "Remove task n (1-based)").option(
     "--add-check <text>",
     "Append one manual check (repeatable)",
-    collect2,
+    collect,
     []
   ).option(
     "--edit-check <n> <text...>",
@@ -13294,7 +13526,7 @@ async function update(id, options2) {
 }
 
 // src/commands/backlog/registerUpdateCommands.ts
-function collect3(value, previous) {
+function collect2(value, previous) {
   return [...previous, value];
 }
 function registerUpdateCommands(cmd) {
@@ -13304,7 +13536,7 @@ function registerUpdateCommands(cmd) {
   ).option("--type <type>", "New type (story or bug)").option("--ac <criterion...>", "Replace acceptance criteria (repeatable)").option(
     "--add-ac <text>",
     "Append one acceptance criterion (repeatable)",
-    collect3,
+    collect2,
     []
   ).option(
     "--edit-ac <n> <text...>",
@@ -13489,9 +13721,9 @@ var UNPARSEABLE = { ok: false, error: "unable to parse" };
 function groupByOperator(tokens) {
   const groups = [[]];
   for (let i = 0; i < tokens.length; i++) {
-    const step = handleToken(tokens, i, groups);
-    if (!step.ok) return step;
-    i = step.nextIndex;
+    const step2 = handleToken(tokens, i, groups);
+    if (!step2.ok) return step2;
+    i = step2.nextIndex;
   }
   return { ok: true, groups };
 }
@@ -17924,16 +18156,16 @@ function* durabilityProbes() {
 async function checkDurability(cwd) {
   if (!existsSync44(cwd)) return { durable: true };
   const probes = durabilityProbes();
-  let step = probes.next();
-  while (!step.done) step = probes.next(await gitResult(cwd, step.value));
-  return step.value;
+  let step2 = probes.next();
+  while (!step2.done) step2 = probes.next(await gitResult(cwd, step2.value));
+  return step2.value;
 }
 function checkDurabilitySync(cwd) {
   if (!existsSync44(cwd)) return { durable: true };
   const probes = durabilityProbes();
-  let step = probes.next();
-  while (!step.done) step = probes.next(gitSyncResult(cwd, step.value));
-  return step.value;
+  let step2 = probes.next();
+  while (!step2.done) step2 = probes.next(gitSyncResult(cwd, step2.value));
+  return step2.value;
 }
 
 // src/commands/sessions/daemon/worktree/worktreeConfigFor.ts
@@ -20178,7 +20410,7 @@ var prsConfigHelp = [
 ];
 
 // src/commands/registerPrsEdit.ts
-function collect4(value, previous) {
+function collect3(value, previous) {
   return previous.concat([value]);
 }
 function registerPrsEdit(prsCommand) {
@@ -20187,7 +20419,7 @@ function registerPrsEdit(prsCommand) {
   ).option("-t, --title <title>", "New title for the pull request").option("--what <what>", "Replace the ## What section").option("--why <why>", "Replace the ## Why section").option("--how <how>", "Replace the ## How section").option(
     "--resolves <key>",
     "Jira issue key resolved by this PR, appended to ## Why (repeatable)",
-    collect4,
+    collect3,
     []
   ).action(edit);
 }
@@ -20288,7 +20520,7 @@ ${confirm}
 }
 
 // src/commands/registerPrsRaise.ts
-function collect5(value, previous) {
+function collect4(value, previous) {
   return previous.concat([value]);
 }
 function registerPrsRaise(prsCommand) {
@@ -20297,20 +20529,20 @@ function registerPrsRaise(prsCommand) {
   ).option("-t, --title <title>", "Title for the pull request").option("--what <what>", "What the change does (## What section)").option("--why <why>", "Why the change is needed (## Why section)").option("--how <how>", "How the change works (optional ## How section)").option(
     "--resolves <key>",
     "Jira issue key resolved by this PR, appended to ## Why (repeatable)",
-    collect5,
+    collect4,
     []
   ).option(
     "--force",
     "Overwrite the title and body of an existing pull request"
-  ).option("-B, --base <branch>", "Branch into which the pull request merges").option("-H, --head <branch>", "Branch that contains the commits").option("-d, --draft", "Mark the pull request as a draft").option("-w, --web", "Open the browser to create the pull request").option("-l, --label <label>", "Add a label (repeatable)", collect5, []).option(
+  ).option("-B, --base <branch>", "Branch into which the pull request merges").option("-H, --head <branch>", "Branch that contains the commits").option("-d, --draft", "Mark the pull request as a draft").option("-w, --web", "Open the browser to create the pull request").option("-l, --label <label>", "Add a label (repeatable)", collect4, []).option(
     "-a, --assignee <login>",
     "Assign a person by login (repeatable)",
-    collect5,
+    collect4,
     []
   ).option(
     "-r, --reviewer <handle>",
     "Request a review (repeatable)",
-    collect5,
+    collect4,
     []
   ).option("-m, --milestone <name>", "Add the pull request to a milestone").addHelpText("after", () => raiseHelpText()).action(raise);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@staff0rd/assist",
-	"version": "0.461.3",
+	"version": "0.462.0",
 	"type": "module",
 	"main": "dist/index.js",
 	"bin": {