terminal-pilot 0.0.6 → 0.0.7

package/dist/commands/close-session.js

@@ -1,8 +1,253 @@
-// src/commands/close-session.ts
-import { defineCommand, S } from "@poe-code/cmdkit";
+// ../cmdkit/src/index.ts
+import { fileURLToPath } from "node:url";
 
-// src/commands/runtime.ts
-import { UserError } from "@poe-code/cmdkit";
+// ../cmdkit-schema/src/index.ts
+function assertValidEnumValues(values) {
+  if (values.length === 0) {
+    throw new Error("Enum schema requires at least one value");
+  }
+  const uniqueValues = new Set(values);
+  if (uniqueValues.size !== values.length) {
+    throw new Error("Enum schema values must be unique");
+  }
+}
+var S = {
+  String(options = {}) {
+    return {
+      kind: "string",
+      ...options
+    };
+  },
+  Number(options = {}) {
+    return {
+      kind: "number",
+      ...options
+    };
+  },
+  Boolean(options = {}) {
+    return {
+      kind: "boolean",
+      ...options
+    };
+  },
+  Enum(values, options = {}) {
+    assertValidEnumValues(values);
+    return {
+      kind: "enum",
+      values,
+      ...options
+    };
+  },
+  Array(item, options = {}) {
+    return {
+      kind: "array",
+      item,
+      ...options
+    };
+  },
+  Object(shape) {
+    return {
+      kind: "object",
+      shape
+    };
+  },
+  Optional(inner) {
+    return {
+      kind: "optional",
+      inner
+    };
+  }
+};
+
+// ../cmdkit/src/index.ts
+var commandConfigSymbol = /* @__PURE__ */ Symbol("cmdkit.command.config");
+var commandSourcePathSymbol = /* @__PURE__ */ Symbol("cmdkit.command.sourcePath");
+var UserError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UserError";
+  }
+};
+function cloneScope(scope) {
+  return scope === void 0 ? void 0 : [...scope];
+}
+function cloneSecretDefinition(secret) {
+  return {
+    env: secret.env,
+    description: secret.description,
+    optional: secret.optional
+  };
+}
+function cloneSecrets(secrets) {
+  if (secrets === void 0) {
+    return {};
+  }
+  return Object.fromEntries(
+    Object.entries(secrets).map(([key, secret]) => [key, cloneSecretDefinition(secret)])
+  );
+}
+function cloneRequires(requires) {
+  if (requires === void 0) {
+    return void 0;
+  }
+  return {
+    auth: requires.auth,
+    apiVersion: requires.apiVersion,
+    check: requires.check
+  };
+}
+function parseStackPath(candidate) {
+  if (candidate.startsWith("file://")) {
+    try {
+      return fileURLToPath(candidate);
+    } catch {
+      return void 0;
+    }
+  }
+  if (candidate.startsWith("/")) {
+    return candidate;
+  }
+  return void 0;
+}
+function extractStackPath(line) {
+  const trimmed = line.trim();
+  const fileIndex = trimmed.indexOf("file://");
+  if (fileIndex >= 0) {
+    const location2 = trimmed.slice(fileIndex);
+    const separatorIndex2 = location2.lastIndexOf(":");
+    const previousSeparatorIndex2 = separatorIndex2 >= 0 ? location2.lastIndexOf(":", separatorIndex2 - 1) : -1;
+    const candidate2 = separatorIndex2 >= 0 && previousSeparatorIndex2 >= 0 ? location2.slice(0, previousSeparatorIndex2) : location2;
+    return parseStackPath(candidate2);
+  }
+  const slashIndex = trimmed.indexOf("/");
+  if (slashIndex < 0) {
+    return void 0;
+  }
+  const location = trimmed.slice(slashIndex);
+  const separatorIndex = location.lastIndexOf(":");
+  const previousSeparatorIndex = separatorIndex >= 0 ? location.lastIndexOf(":", separatorIndex - 1) : -1;
+  const candidate = separatorIndex >= 0 && previousSeparatorIndex >= 0 ? location.slice(0, previousSeparatorIndex) : location;
+  return parseStackPath(candidate);
+}
+function inferCommandSourcePath() {
+  const stack = new Error().stack;
+  if (typeof stack !== "string") {
+    return void 0;
+  }
+  for (const line of stack.split("\n").slice(1)) {
+    const candidate = extractStackPath(line);
+    if (candidate === void 0) {
+      continue;
+    }
+    if (candidate.includes("/packages/cmdkit/src/index.ts") || candidate.includes("/packages/cmdkit/dist/index.js")) {
+      continue;
+    }
+    return candidate;
+  }
+  return void 0;
+}
+function composeChecks(parentCheck, childCheck) {
+  if (parentCheck === void 0) {
+    return childCheck;
+  }
+  if (childCheck === void 0) {
+    return parentCheck;
+  }
+  return async (ctx) => {
+    const parentResult = await parentCheck(ctx);
+    if (!parentResult.ok) {
+      return parentResult;
+    }
+    return childCheck(ctx);
+  };
+}
+function mergeRequires(parent, child) {
+  if (parent === void 0 && child === void 0) {
+    return void 0;
+  }
+  const merged = {
+    auth: child?.auth ?? parent?.auth,
+    apiVersion: child?.apiVersion ?? parent?.apiVersion,
+    check: composeChecks(parent?.check, child?.check)
+  };
+  if (merged.auth === void 0 && merged.apiVersion === void 0 && merged.check === void 0) {
+    return void 0;
+  }
+  return merged;
+}
+function mergeSecrets(parent, child) {
+  return cloneSecrets({
+    ...parent,
+    ...child
+  });
+}
+function resolveCommandScope(ownScope, inheritedScope) {
+  return cloneScope(ownScope ?? inheritedScope) ?? ["cli", "sdk"];
+}
+function createBaseCommand(config) {
+  const command = {
+    kind: "command",
+    name: config.name,
+    description: config.description,
+    aliases: [...config.aliases ?? []],
+    positional: [...config.positional ?? []],
+    params: config.params,
+    secrets: cloneSecrets(config.secrets),
+    scope: resolveCommandScope(config.scope, void 0),
+    confirm: config.confirm ?? false,
+    requires: cloneRequires(config.requires),
+    handler: config.handler,
+    render: config.render
+  };
+  Object.defineProperty(command, commandConfigSymbol, {
+    value: {
+      scope: cloneScope(config.scope),
+      secrets: cloneSecrets(config.secrets),
+      requires: cloneRequires(config.requires),
+      sourcePath: inferCommandSourcePath()
+    }
+  });
+  return command;
+}
+function getInternalCommandConfig(command) {
+  return command[commandConfigSymbol];
+}
+function materializeCommand(command, inherited) {
+  const internal = getInternalCommandConfig(command);
+  const materialized = {
+    kind: "command",
+    name: command.name,
+    description: command.description,
+    aliases: [...command.aliases],
+    positional: [...command.positional],
+    params: command.params,
+    secrets: mergeSecrets(inherited.secrets, internal.secrets),
+    scope: resolveCommandScope(internal.scope, inherited.scope),
+    confirm: command.confirm,
+    requires: mergeRequires(inherited.requires, internal.requires),
+    handler: command.handler,
+    render: command.render
+  };
+  Object.defineProperty(materialized, commandConfigSymbol, {
+    value: {
+      scope: cloneScope(internal.scope),
+      secrets: cloneSecrets(internal.secrets),
+      requires: cloneRequires(internal.requires),
+      sourcePath: internal.sourcePath
+    }
+  });
+  Object.defineProperty(materialized, commandSourcePathSymbol, {
+    value: internal.sourcePath
+  });
+  return materialized;
+}
+function defineCommand(config) {
+  return materializeCommand(createBaseCommand(config), {
+    scope: void 0,
+    secrets: {},
+    requires: void 0
+  });
+}
 
 // src/terminal-pilot.ts
 import { randomUUID } from "node:crypto";