terminal-pilot 0.0.30 → 0.0.31

package/dist/commands/uninstall.js

@@ -79,6 +79,9 @@ function isOptionalSchema(schema) {
 function getRequiredKeys(schema) {
   return Object.keys(schema.shape).filter((key) => !isOptionalSchema(schema.shape[key])).sort();
 }
+function getRequiredKeyFingerprint(schema) {
+  return getRequiredKeys(schema).join("+");
+}
 function assertUniqueRequiredKeyFingerprints(branches) {
   const fingerprints = /* @__PURE__ */ new Map();
   branches.forEach((branch, index) => {
@@ -116,6 +119,451 @@ function Union(branches) {
   };
 }
 
+// ../toolcraft-schema/src/validate.ts
+var missingValue = /* @__PURE__ */ Symbol("missingValue");
+function validate(schema, value) {
+  const state = { issues: [] };
+  const result = walkSchema(schema, value, [], state);
+  if (state.issues.length > 0) {
+    return { ok: false, issues: state.issues };
+  }
+  return { ok: true, value: result.present ? result.value : void 0 };
+}
+function walkSchema(schema, value, path10, state) {
+  if (schema.kind === "optional") {
+    return walkOptional(schema, value, path10, state);
+  }
+  if (value === missingValue) {
+    addIssue(
+      state,
+      path10,
+      expectedFor(schema),
+      "missing",
+      `Expected ${expectedFor(schema)} at ${formatPath(path10)}`
+    );
+    return { present: false };
+  }
+  if (value === null && schema.nullable === true) {
+    return { present: true, value };
+  }
+  switch (schema.kind) {
+    case "string":
+      return walkString(schema, value, path10, state);
+    case "number":
+      return walkNumber(schema, value, path10, state);
+    case "boolean":
+      return walkBoolean(value, path10, state);
+    case "enum":
+      return walkEnum(schema, value, path10, state);
+    case "array":
+      return walkArray(schema, value, path10, state);
+    case "object":
+      return walkObject(schema, value, path10, state);
+    case "oneOf":
+      return walkOneOf(schema, value, path10, state);
+    case "union":
+      return walkUnion(schema, value, path10, state);
+    case "record":
+      return walkRecord(schema, value, path10, state);
+    case "json":
+      return walkJson(value, path10, state);
+  }
+}
+function walkOptional(schema, value, path10, state) {
+  if (value === missingValue || value === void 0) {
+    const defaultValue = getDefault(schema.inner);
+    if (defaultValue.present) {
+      return walkSchema(schema.inner, cloneDefault(defaultValue.value), path10, state);
+    }
+    return { present: false };
+  }
+  return walkSchema(schema.inner, value, path10, state);
+}
+function walkString(schema, value, path10, state) {
+  if (typeof value !== "string") {
+    addExpectedIssue(state, path10, "string", value);
+    return { present: true, value };
+  }
+  if (schema.minLength !== void 0 && value.length < schema.minLength) {
+    const expected = `string with length at least ${schema.minLength}`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      `string with length ${value.length}`,
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+    const expected = `string with length at most ${schema.maxLength}`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      `string with length ${value.length}`,
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  if (schema.pattern !== void 0) {
+    const pattern = compilePattern(schema.pattern);
+    if (pattern === void 0 || !pattern.test(value)) {
+      const expected = `string matching pattern ${schema.pattern}`;
+      addIssue(state, path10, expected, value, `Expected ${expected} at ${formatPath(path10)}`);
+    }
+  }
+  return { present: true, value };
+}
+function walkNumber(schema, value, path10, state) {
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    addExpectedIssue(state, path10, schema.jsonType === "integer" ? "integer" : "number", value);
+    return { present: true, value };
+  }
+  if (schema.jsonType === "integer" && !Number.isInteger(value)) {
+    addExpectedIssue(state, path10, "integer", value);
+  }
+  if (schema.minimum !== void 0 && value < schema.minimum) {
+    const expected = `number greater than or equal to ${schema.minimum}`;
+    addIssue(state, path10, expected, String(value), `Expected ${expected} at ${formatPath(path10)}`);
+  }
+  if (schema.maximum !== void 0 && value > schema.maximum) {
+    const expected = `number less than or equal to ${schema.maximum}`;
+    addIssue(state, path10, expected, String(value), `Expected ${expected} at ${formatPath(path10)}`);
+  }
+  return { present: true, value };
+}
+function walkBoolean(value, path10, state) {
+  if (typeof value !== "boolean") {
+    addExpectedIssue(state, path10, "boolean", value);
+  }
+  return { present: true, value };
+}
+function walkEnum(schema, value, path10, state) {
+  if (!schema.values.includes(value)) {
+    const expected = `one of ${schema.values.join(", ")}`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      receivedValue(value),
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  return { present: true, value };
+}
+function walkArray(schema, value, path10, state) {
+  if (!Array.isArray(value)) {
+    addExpectedIssue(state, path10, "array", value);
+    return { present: true, value };
+  }
+  if (schema.minItems !== void 0 && value.length < schema.minItems) {
+    const expected = `array with at least ${schema.minItems} items`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      `array with ${value.length} items`,
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+    const expected = `array with at most ${schema.maxItems} items`;
+    addIssue(
+      state,
+      path10,
+      expected,
+      `array with ${value.length} items`,
+      `Expected ${expected} at ${formatPath(path10)}`
+    );
+  }
+  const nextValue = value.map((item, index) => {
+    const result = walkSchema(schema.item, item, [...path10, String(index)], state);
+    return result.present ? result.value : item;
+  });
+  return { present: true, value: nextValue };
+}
+function walkObject(schema, value, path10, state, injectedProperties = {}) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path10, "object", value);
+    return { present: true, value };
+  }
+  const nextValue = {};
+  const allowedKeys = /* @__PURE__ */ new Set([...Object.keys(schema.shape), ...Object.keys(injectedProperties)]);
+  for (const [key, propertySchema] of Object.entries(schema.shape)) {
+    const propertyValue = Object.hasOwn(value, key) ? value[key] : missingValue;
+    const result = walkSchema(propertySchema, propertyValue, [...path10, key], state);
+    if (result.present) {
+      setOwnValue(nextValue, key, result.value);
+    }
+  }
+  for (const [key, injectedValue] of Object.entries(injectedProperties)) {
+    if (Object.hasOwn(value, key)) {
+      setOwnValue(nextValue, key, value[key]);
+    } else {
+      setOwnValue(nextValue, key, injectedValue);
+    }
+  }
+  for (const [key, propertyValue] of Object.entries(value)) {
+    if (allowedKeys.has(key)) {
+      continue;
+    }
+    if (schema.additionalProperties === true) {
+      setOwnValue(nextValue, key, propertyValue);
+    } else {
+      addUnexpectedPropertyIssue(state, [...path10, key]);
+    }
+  }
+  return { present: true, value: nextValue };
+}
+function walkOneOf(schema, value, path10, state) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path10, "object", value);
+    return { present: true, value };
+  }
+  const discriminatorValue = value[schema.discriminator];
+  const discriminatorPath = [...path10, schema.discriminator];
+  const branchValues = Object.keys(schema.branches);
+  const expected = `one of ${branchValues.join(", ")}`;
+  if (!Object.hasOwn(value, schema.discriminator)) {
+    addIssueWithMessage(
+      state,
+      discriminatorPath,
+      expected,
+      "missing",
+      `Missing discriminator "${schema.discriminator}" at ${formatPath(path10)}. Expected one of: ${branchValues.join(", ")}.`
+    );
+    return { present: true, value };
+  }
+  if (typeof discriminatorValue !== "string" || !Object.hasOwn(schema.branches, discriminatorValue)) {
+    addIssueWithMessage(
+      state,
+      discriminatorPath,
+      expected,
+      receivedValue(discriminatorValue),
+      `Expected ${expected} at ${formatPath(discriminatorPath)}, got ${formatReceivedDiscriminator(discriminatorValue)}`
+    );
+    return { present: true, value };
+  }
+  return walkObject(schema.branches[discriminatorValue], value, path10, state, {
+    [schema.discriminator]: discriminatorValue
+  });
+}
+function walkUnion(schema, value, path10, state) {
+  if (isPlainRecord(value)) {
+    const candidateBranches = schema.branches.filter((branch) => hasRequiredKeys(branch, value));
+    if (candidateBranches.length === 1) {
+      return walkObject(candidateBranches[0], value, path10, state);
+    }
+  }
+  const matches = [];
+  for (const branch of schema.branches) {
+    const branchState = { issues: [] };
+    const result = walkObject(branch, value, path10, branchState);
+    if (branchState.issues.length === 0 && result.present) {
+      matches.push({ fingerprint: getRequiredKeyFingerprint(branch), value: result.value });
+    }
+  }
+  if (matches.length === 1) {
+    return { present: true, value: matches[0].value };
+  }
+  if (matches.length === 0) {
+    const branchDescriptions = schema.branches.map((branch) => getRequiredKeyFingerprint(branch));
+    addIssueWithMessage(
+      state,
+      path10,
+      "exactly one union branch",
+      "0 matching branches",
+      `No union branch matched at ${formatPath(path10)}. Tried ${schema.branches.length} branches. Expected one of: ${branchDescriptions.join(" | ")}.`
+    );
+    return { present: true, value };
+  }
+  addIssueWithMessage(
+    state,
+    path10,
+    "exactly one union branch",
+    `${matches.length} matching branches`,
+    `Expected exactly one union branch at ${formatPath(path10)}, but matched more than one branch: ${matches.map((match) => match.fingerprint).join(" | ")}`
+  );
+  return { present: true, value };
+}
+function hasRequiredKeys(schema, value) {
+  for (const [key, propertySchema] of Object.entries(schema.shape)) {
+    if (propertySchema.kind !== "optional" && !Object.hasOwn(value, key)) {
+      return false;
+    }
+  }
+  return true;
+}
+function walkRecord(schema, value, path10, state) {
+  if (!isPlainRecord(value)) {
+    addExpectedIssue(state, path10, "object", value);
+    return { present: true, value };
+  }
+  const nextValue = {};
+  for (const [key, propertyValue] of Object.entries(value)) {
+    const result = walkSchema(schema.value, propertyValue, [...path10, key], state);
+    if (result.present) {
+      setOwnValue(nextValue, key, result.value);
+    }
+  }
+  return { present: true, value: nextValue };
+}
+function walkJson(value, path10, state) {
+  if (isJsonValue(value)) {
+    return { present: true, value };
+  }
+  addExpectedIssue(state, path10, "JSON value", value);
+  return { present: true, value };
+}
+function getDefault(schema) {
+  if (schema.default !== void 0) {
+    return { present: true, value: schema.default };
+  }
+  if (schema.kind === "optional") {
+    return getDefault(schema.inner);
+  }
+  return { present: false };
+}
+function isPlainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function isJsonValue(value, ancestors = /* @__PURE__ */ new Set()) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+    return typeof value !== "number" || Number.isFinite(value);
+  }
+  if (Array.isArray(value)) {
+    if (ancestors.has(value)) {
+      return false;
+    }
+    ancestors.add(value);
+    const result = value.every((item) => isJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return result;
+  }
+  if (isPlainRecord(value)) {
+    if (ancestors.has(value)) {
+      return false;
+    }
+    ancestors.add(value);
+    const result = Object.values(value).every((item) => isJsonValue(item, ancestors));
+    ancestors.delete(value);
+    return result;
+  }
+  return false;
+}
+function cloneDefault(value) {
+  return structuredClone(value);
+}
+function setOwnValue(target, key, value) {
+  Object.defineProperty(target, key, {
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value
+  });
+}
+function expectedFor(schema) {
+  switch (schema.kind) {
+    case "string":
+      return "string";
+    case "number":
+      return schema.jsonType === "integer" ? "integer" : "number";
+    case "boolean":
+      return "boolean";
+    case "enum":
+      return `one of ${schema.values.join(", ")}`;
+    case "array":
+      return "array";
+    case "object":
+    case "oneOf":
+    case "record":
+      return "object";
+    case "union":
+      return "exactly one union branch";
+    case "json":
+      return "JSON value";
+    case "optional":
+      return expectedFor(schema.inner);
+  }
+}
+function addExpectedIssue(state, path10, expected, value) {
+  addIssue(
+    state,
+    path10,
+    expected,
+    receivedType(value),
+    `Expected ${expected} at ${formatPath(path10)}`
+  );
+}
+function addUnexpectedPropertyIssue(state, path10) {
+  addIssue(
+    state,
+    path10,
+    "no additional properties",
+    "unknown property",
+    `Unexpected property ${formatPath(path10)}`
+  );
+}
+function addIssue(state, path10, expected, received, _message) {
+  state.issues.push({
+    path: path10,
+    expected,
+    received,
+    message: formatIssueMessage(expected, path10, received)
+  });
+}
+function addIssueWithMessage(state, path10, expected, received, message2) {
+  state.issues.push({
+    path: path10,
+    expected,
+    received,
+    message: message2
+  });
+}
+function formatIssueMessage(expected, path10, received) {
+  return `Expected ${expected} at ${formatPath(path10)}, got ${received}`;
+}
+function formatPath(path10) {
+  return path10.length === 0 ? "value" : path10.join(".");
+}
+function compilePattern(pattern) {
+  try {
+    return new RegExp(pattern);
+  } catch {
+    return void 0;
+  }
+}
+function receivedType(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "array";
+  }
+  if (typeof value === "number" && Number.isInteger(value)) {
+    return "integer";
+  }
+  return typeof value;
+}
+function receivedValue(value) {
+  if (typeof value === "string") {
+    return value;
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  return String(value);
+}
+function formatReceivedDiscriminator(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  return receivedValue(value);
+}
+
 // ../toolcraft-schema/src/index.ts
 function assertValidEnumValues(values) {
   if (values.length === 0) {
@@ -139,6 +587,22 @@ function assertFiniteNumber(value, name) {
     throw new Error(`${name} must be finite`);
   }
 }
+function assertMinMaxOrder(minimum, maximum, minimumName, maximumName) {
+  if (minimum !== void 0 && maximum !== void 0 && minimum > maximum) {
+    throw new Error(`${minimumName} must be less than or equal to ${maximumName}`);
+  }
+}
+function assertValidDefault(schema) {
+  if (schema.default === void 0) {
+    return;
+  }
+  const result = validate(schema, schema.default);
+  if (!result.ok) {
+    throw new Error(
+      `default must satisfy schema: ${result.issues[0]?.message ?? "invalid default"}`
+    );
+  }
+}
 function assertPattern(pattern) {
   if (pattern === void 0) {
     return;
@@ -153,56 +617,71 @@ var S = {
   String(options = {}) {
     assertNonNegativeInteger(options.minLength, "minLength");
     assertNonNegativeInteger(options.maxLength, "maxLength");
+    assertMinMaxOrder(options.minLength, options.maxLength, "minLength", "maxLength");
     assertPattern(options.pattern);
-    return {
+    const schema = {
       kind: "string",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Number(options = {}) {
     assertFiniteNumber(options.minimum, "minimum");
     assertFiniteNumber(options.maximum, "maximum");
+    assertMinMaxOrder(options.minimum, options.maximum, "minimum", "maximum");
     assertFiniteNumber(options.default, "default");
     if (options.jsonType === "integer" && options.default !== void 0 && !Number.isInteger(options.default)) {
       throw new Error("default must be an integer");
     }
-    return {
+    const schema = {
       kind: "number",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Boolean(options = {}) {
-    return {
+    const schema = {
       kind: "boolean",
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Enum(values, options = {}) {
     assertValidEnumValues(values);
     if (options.jsonType === "integer" && values.some((value) => typeof value !== "number" || !Number.isInteger(value))) {
       throw new Error("Integer enum values must be integers");
     }
-    return {
+    const schema = {
       kind: "enum",
       values,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Array(item, options = {}) {
     assertNonNegativeInteger(options.minItems, "minItems");
     assertNonNegativeInteger(options.maxItems, "maxItems");
-    return {
+    assertMinMaxOrder(options.minItems, options.maxItems, "minItems", "maxItems");
+    const schema = {
       kind: "array",
       item,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Object(shape, options = {}) {
-    return {
+    const schema = {
       kind: "object",
       shape,
       ...options
     };
+    assertValidDefault(schema);
+    return schema;
   },
   Optional(inner) {
     return {
@@ -1081,7 +1560,54 @@ var symbols = {
 
 // ../toolcraft-design/src/internal/strip-ansi.ts
 function stripAnsi(value) {
-  return value.replace(/\u001b\[[0-9;]*m/g, "");
+  let output = "";
+  let index = 0;
+  while (index < value.length) {
+    const char = value[index];
+    if (char === "\x1B") {
+      index = skipEscapeSequence(value, index);
+      continue;
+    }
+    if (char === "\x9B") {
+      index = skipCsiSequence(value, index + 1);
+      continue;
+    }
+    output += char;
+    index += char.length;
+  }
+  return output;
+}
+function skipEscapeSequence(value, index) {
+  const next = value[index + 1];
+  if (next === "[") {
+    return skipCsiSequence(value, index + 2);
+  }
+  if (next === "]") {
+    return skipOscSequence(value, index + 2);
+  }
+  return Math.min(value.length, index + 2);
+}
+function skipCsiSequence(value, index) {
+  while (index < value.length) {
+    const codePoint = value.charCodeAt(index);
+    index += 1;
+    if (codePoint >= 64 && codePoint <= 126) {
+      break;
+    }
+  }
+  return index;
+}
+function skipOscSequence(value, index) {
+  while (index < value.length) {
+    if (value[index] === "\x07") {
+      return index + 1;
+    }
+    if (value[index] === "\x1B" && value[index + 1] === "\\") {
+      return index + 2;
+    }
+    index += 1;
+  }
+  return index;
 }
 
 // ../toolcraft-design/src/prompts/primitives/log.ts
@@ -1278,6 +1804,10 @@ var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 // ../toolcraft-design/src/components/table.ts
 var graphemeSegmenter2 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 
+// ../toolcraft-design/src/components/detail-card.ts
+import stringWidth from "fast-string-width";
+import { wrapAnsi } from "fast-wrap-ansi";
+
 // ../toolcraft-design/src/components/browser.ts
 import { spawn } from "node:child_process";
 import process2 from "node:process";
@@ -1288,13 +1818,13 @@ import { LineCounter, parse, parseDocument } from "yaml";
 // ../frontmatter/src/stringify.ts
 import { stringify } from "yaml";
 
+// ../toolcraft-design/src/dashboard/terminal-width.ts
+var graphemeSegmenter3 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+
 // ../toolcraft-design/src/acp/writer.ts
 import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
 var storage = new AsyncLocalStorage2();
 
-// ../toolcraft-design/src/dashboard/terminal-width.ts
-var graphemeSegmenter3 = new Intl.Segmenter(void 0, { granularity: "grapheme" });
-
 // ../toolcraft-design/src/dashboard/terminal.ts
 import readline from "node:readline";
 import { PassThrough } from "node:stream";
@@ -1343,11 +1873,11 @@ import { EventEmitter } from "node:events";
 import * as readline2 from "node:readline";
 
 // ../toolcraft-design/src/prompts/interactive/wrap.ts
-import { wrapAnsi } from "fast-wrap-ansi";
-import stringWidth from "fast-string-width";
+import { wrapAnsi as wrapAnsi2 } from "fast-wrap-ansi";
+import stringWidth2 from "fast-string-width";
 
 // ../toolcraft-design/src/prompts/interactive/pagination.ts
-import { wrapAnsi as wrapAnsi2 } from "fast-wrap-ansi";
+import { wrapAnsi as wrapAnsi3 } from "fast-wrap-ansi";
 
 // ../toolcraft-design/src/static/spinner.ts
 var SPINNER_FRAMES = Object.freeze(["\u25D2", "\u25D0", "\u25D3", "\u25D1"]);
@@ -1370,17 +1900,17 @@ import path5 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
 // ../agent-skill-config/src/resolve-skill-reference.ts
-import { statSync as statSync2 } from "node:fs";
+import * as fs from "node:fs";
 import path6 from "node:path";
 
 // ../agent-skill-config/src/git-exclude.ts
 import { execFileSync } from "node:child_process";
 import { randomUUID as randomUUID2 } from "node:crypto";
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import path7 from "node:path";
 
 // ../agent-skill-config/src/bridge-active-skills.ts
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 import { createHash, randomUUID as randomUUID3 } from "node:crypto";
 import path8 from "node:path";
 
@@ -1434,12 +1964,12 @@ function getSkillFolderWithHome(agent, scope, cwd, homeDir) {
     )
   };
 }
-async function assertNoSymbolicLinkPath(fs3, targetPath) {
+async function assertNoSymbolicLinkPath(fs4, targetPath) {
   const rootPath = path9.parse(targetPath).root;
   let currentPath = targetPath;
   while (currentPath !== rootPath) {
     try {
-      if ((await fs3.lstat(currentPath)).isSymbolicLink()) {
+      if ((await fs4.lstat(currentPath)).isSymbolicLink()) {
         throw new UserError(`Refusing terminal-pilot skill operation through symbolic link: ${currentPath}`);
       }
     } catch (error2) {
@@ -1508,9 +2038,9 @@ var uninstall = defineCommand({
     };
   }
 });
-async function folderExists(fs3, folderPath) {
+async function folderExists(fs4, folderPath) {
   try {
-    await fs3.stat(folderPath);
+    await fs4.stat(folderPath);
     return true;
   } catch (error2) {
     if (hasOwnErrorCode(error2, "ENOENT")) {