nolo-cli 0.1.32 → 0.1.34

package/dialogStatusCommands.ts

@@ -1,123 +0,0 @@
-import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
-import { resolveAuthToken, resolveServerCandidates } from "./cliEnvHelpers";
-import {
-  isLocalBaseUrl,
-  readDialogFromLocalDb,
-  tryHttpDialogCandidates,
-} from "./dialogDataAccess";
-import {
-  parseDialogInputForCli,
-  type DialogHttpAttempt,
-} from "./dialogReadHelpers";
-import { renderDialogStatus } from "./agent-runtime/dialogStatus";
-
-function usage() {
-  return [
-    "Usage:",
-    "  nolo dialog status <dialogId|dialogUrl>",
-    "",
-  ].join("\n");
-}
-
-export async function runDialogStatusCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const rawInput = args[0]?.trim();
-  if (!rawInput || rawInput === "-h" || rawInput === "--help") {
-    output.write(`${usage()}\n`);
-    return rawInput ? 0 : 1;
-  }
-
-  const authToken = resolveAuthToken(args, env);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-
-  try {
-    const { base, dialogId, userId } = parseDialogInputForCli(rawInput, env);
-    const dialogKey = `dialog-${userId}-${dialogId}`;
-    const candidateBases = resolveServerCandidates(
-      args,
-      {
-        ...env,
-        BASE_URL: env.READ_DIALOG_BASE?.trim() || base || env.BASE_URL,
-      },
-      base
-    );
-
-    let meta: any;
-    let resolvedBase = base;
-
-    try {
-      ({ meta, resolvedBase } = await tryHttpDialogCandidates({
-        authToken,
-        bases: candidateBases,
-        dialogId,
-        dialogKey,
-        fetchImpl,
-        fallbackFetchImpl,
-        limit: 1,
-      }));
-    } catch (error) {
-      const localhostCandidate = candidateBases.find(isLocalBaseUrl);
-      if (!localhostCandidate) {
-        const attempts =
-          typeof error === "object" && error !== null && "attempts" in error
-            ? ((error as any).attempts as DialogHttpAttempt[])
-            : [];
-        throw new Error(
-          `read dialog status failed: ${attempts
-            .map((attempt) => `${attempt.base} -> ${attempt.status ?? attempt.message}`)
-            .join("; ")}`
-        );
-      }
-      try {
-        const db = deps.db ?? await getReadableCliDb(output);
-        ({ meta } = await readDialogFromLocalDb({
-          db,
-          dialogId,
-          dialogKey,
-          limit: 1,
-        }));
-        resolvedBase = localhostCandidate;
-      } catch (fallbackError) {
-        throw new Error(
-          `read dialog status failed: ${
-            fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
-          }`
-        );
-      }
-    }
-
-    output.write(
-      renderDialogStatus({
-        dialogId,
-        dialogKey,
-        base: resolvedBase,
-        title: meta?.title ?? null,
-        status: meta?.status ?? null,
-        parentDialogId: meta?.parentDialogId ?? null,
-        rootDialogId: meta?.rootDialogId ?? null,
-        subjectRefs: Array.isArray(meta?.subjectRefs) ? meta.subjectRefs : [],
-        runtimeCheckpoint: meta?.runtimeCheckpoint ?? null,
-        artifacts: meta?.artifacts ?? null,
-        writtenFiles: Array.isArray(meta?.writtenFiles) ? meta.writtenFiles : [],
-        toolsUsed: Array.isArray(meta?.toolsUsed) ? meta.toolsUsed : [],
-        toolErrors: Array.isArray(meta?.toolErrors) ? meta.toolErrors : [],
-        durationMs: typeof meta?.durationMs === "number" ? meta.durationMs : null,
-        updatedAt: meta?.updatedAt ?? null,
-        finishedAt: meta?.finishedAt ?? null,
-      })
-    );
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] dialog status failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}

package/docInternalCommandEntries.ts

@@ -1,20 +0,0 @@
-import { createEnvCommand } from "./cliCommandFactories";
-import type { CommandEntry } from "./cliCommandTypes";
-import { runDocCreateCommand, runSkillDocCreateCommand } from "./pageCreateCommands";
-import { runDocDeleteCommand, runSkillDocDeleteCommand } from "./pageDeleteCommands";
-import { runDocReadCommand, runSkillDocReadCommand } from "./pageReadCommands";
-import { runDocUpdateCommand, runSkillDocUpdateCommand } from "./pageUpdateCommands";
-
-export function getDocInternalCommandEntries(): CommandEntry[] {
-  return [
-    createEnvCommand(["doc", "create"], "Create a normal doc", runDocCreateCommand),
-    createEnvCommand(["doc", "read"], "Read a normal doc", runDocReadCommand),
-    createEnvCommand(["doc", "update"], "Update a normal doc", runDocUpdateCommand),
-    createEnvCommand(["doc", "delete"], "Delete a normal doc", runDocDeleteCommand),
-    createEnvCommand(["skill-doc", "create"], "Create a skill doc", runSkillDocCreateCommand),
-    createEnvCommand(["skill-doc", "read"], "Read a skill doc", runSkillDocReadCommand),
-    createEnvCommand(["skill-doc", "update"], "Update a skill doc", runSkillDocUpdateCommand),
-    createEnvCommand(["skill-doc", "delete"], "Delete a skill doc", runSkillDocDeleteCommand),
-    createEnvCommand(["skill", "create-doc"], "Create a skill-backed doc", runSkillDocCreateCommand),
-  ];
-}

package/hybridReadHelpers.ts

@@ -1,109 +0,0 @@
-type LocalReadableDb = {
-  get: (key: string) => Promise<unknown>;
-};
-
-export type HybridReadSource = "local-cache" | "remote-cache";
-
-export type CandidateReadResult<T> = {
-  value: T;
-  serverUrl: string;
-};
-
-export type ReadThroughResult<T> = {
-  value: T;
-  source: HybridReadSource;
-  serverUrl: string | null;
-};
-
-export async function readFromServerCandidates<T>(args: {
-  serverCandidates: string[];
-  readRemote: (serverUrl: string) => Promise<T>;
-}): Promise<CandidateReadResult<T>> {
-  let lastError: Error | null = null;
-  for (const serverUrl of args.serverCandidates) {
-    try {
-      return {
-        value: await args.readRemote(serverUrl),
-        serverUrl,
-      };
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-    }
-  }
-
-  throw lastError ?? new Error("record not found from candidate servers");
-}
-
-export async function readThroughRecord<T>(args: {
-  db: LocalReadableDb;
-  dbKey: string;
-  serverCandidates: string[];
-  readRemote: (serverUrl: string, dbKey: string) => Promise<T>;
-  cacheRemote?: (value: T, serverUrl: string) => unknown | Promise<unknown>;
-  isReadableLocal?: (value: unknown) => value is T;
-}): Promise<ReadThroughResult<T>> {
-  try {
-    const local = await args.db.get(args.dbKey);
-    const isReadableLocal =
-      args.isReadableLocal ?? ((value: unknown): value is T => !!value && typeof value === "object");
-    if (isReadableLocal(local)) {
-      return {
-        value: local,
-        source: "local-cache",
-        serverUrl: null,
-      };
-    }
-  } catch {
-    // local miss; fall through to remote candidates
-  }
-
-  const remote = await readFromServerCandidates({
-    serverCandidates: args.serverCandidates,
-    readRemote: (serverUrl) => args.readRemote(serverUrl, args.dbKey),
-  });
-  if (args.cacheRemote) {
-    await args.cacheRemote(remote.value, remote.serverUrl);
-  }
-
-  return {
-    value: remote.value,
-    source: "remote-cache",
-    serverUrl: remote.serverUrl,
-  };
-}
-
-export async function readRecordWithCandidates<T>(args: {
-  db: LocalReadableDb;
-  dbKey: string;
-  serverCandidates: string[];
-  readRemote: (serverUrl: string, dbKey: string) => Promise<T>;
-  cacheRemote?: (value: T, serverUrl: string) => unknown | Promise<unknown>;
-  isReadableLocal?: (value: unknown) => value is T;
-}) {
-  const result = await readThroughRecord(args);
-  return result.value;
-}
-
-export async function readThroughList<T>(args: {
-  readLocal: () => Promise<T[]>;
-  readRemote: () => Promise<T[]>;
-  isEmpty?: (items: T[]) => boolean;
-}): Promise<{ items: T[]; source: HybridReadSource }> {
-  try {
-    const items = await args.readLocal();
-    const isEmpty = args.isEmpty ?? ((values: T[]) => values.length === 0);
-    if (!isEmpty(items)) {
-      return {
-        items,
-        source: "local-cache",
-      };
-    }
-  } catch {
-    // local cache unavailable; fall through to remote
-  }
-
-  return {
-    items: await args.readRemote(),
-    source: "remote-cache",
-  };
-}

package/machineCommandPrompts.ts

@@ -1,79 +0,0 @@
-import {
-  buildMachinePermissionPromptBlock,
-  resolveMachineRunPermissionPolicy,
-  type MachineRunPermissionPolicy,
-} from "./ai/agent/machineRunPermissions";
-import { buildNoloReadOnlyBridgePrompt } from "./noloReadBridgePrompt";
-
-export function inferTaskRunRole(agentKey: string, agentConfig: any) {
-  const haystack = [agentKey, agentConfig?.name, agentConfig?.prompt]
-    .filter(Boolean)
-    .join("\n")
-    .toLowerCase();
-  if (haystack.includes("frontend") || haystack.includes("前端")) return "frontend";
-  if (haystack.includes("fullstack") || haystack.includes("全栈")) return "fullstack";
-  if (haystack.includes("review") || haystack.includes("审查")) return "reviewer";
-  if (haystack.includes("project-manager") || haystack.includes("项目经理")) return "pm";
-  return "codex";
-}
-
-export function buildTaskRunBridgePrompt(args: {
-  agentKey: string;
-  agentConfig: any;
-  runtimeContext: any;
-}) {
-  const taskRun = args.runtimeContext?.taskRun;
-  const rowDbKey = typeof taskRun?.rowDbKey === "string" ? taskRun.rowDbKey.trim() : "";
-  if (!rowDbKey) return "";
-  const workItemId = typeof taskRun?.workItemId === "string" ? taskRun.workItemId.trim() : "";
-  const role = inferTaskRunRole(args.agentKey, args.agentConfig);
-  return [
-    "--- Nolo task-run tool bridge ---",
-    "This CLI runtime does not receive server-side function tools directly.",
-    "Use the local task-run bridge command for durable task state writes. Do not edit meta.taskRun with table or database commands.",
-    "Run commands from the repository root. The runner already provides server URL and auth in the environment.",
-    "Release boundary: after review passes, AI/reviewer/Codex may advance alpha for verification. Do not merge, push, or release main/release unless the human owner explicitly authorizes it in the current task context.",
-    "Cost boundary: read taskRun.control from context. Prefer low-cost/free-window models for routine work, and reserve Codex for supervision, quality gates, complex unblocking, and main/release decisions.",
-    "Handoff context: start from read-context, then inspect existing refs such as workItems.dialogIds, workItems.outcome, review.dialogId, activityRefs, agentRuns.dialogId/resultSummary, and artifactRefs. Use dialog read/search for exact evidence; do not infer completion from handoff text alone.",
-    `Read context: bun packages/cli/index.ts task-run read-context --row-dbkey ${JSON.stringify(rowDbKey)}`,
-    ...(workItemId
-      ? [
-          `Claim work item: bun packages/cli/index.ts task-run claim-work-item --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --agent-key ${JSON.stringify(args.agentKey)} --role ${role}`,
-          `Set blocker: bun packages/cli/index.ts task-run set-blocker --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --layer tool --code <CODE> --message <MESSAGE>`,
-          `Clear resolved blocker: bun packages/cli/index.ts task-run clear-blocker --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --blocker-id <BLOCKER_ID>`,
-          `Submit outcome: bun packages/cli/index.ts task-run submit-outcome --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --summary <SUMMARY>`,
-          `Request review: bun packages/cli/index.ts task-run request-review --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --reviewer-agent-key <AGENT_KEY> --message <MESSAGE>`,
-          `Record review: bun packages/cli/index.ts task-run record-review --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --review-status <passed|needs_changes|blocked> --reviewer-agent-key ${JSON.stringify(args.agentKey)} --findings <FINDINGS>`,
-          `Close work item: bun packages/cli/index.ts task-run close-work-item --row-dbkey ${JSON.stringify(rowDbKey)} --work-item-id ${JSON.stringify(workItemId)} --summary <SUMMARY>`,
-        ]
-      : []),
-    "If a bridge command fails, report the exact command and error.",
-  ].join("\n");
-}
-
-export function buildConnectorCliPrompt(
-  agentConfig: any,
-  userInput: string,
-  bridgeArgs?: {
-    agentKey: string;
-    runtimeContext: any;
-  },
-  permissionPolicy?: MachineRunPermissionPolicy,
-) {
-  const policy = permissionPolicy ?? resolveMachineRunPermissionPolicy(agentConfig);
-  return [
-    typeof agentConfig?.prompt === "string" ? agentConfig.prompt.trim() : "",
-    buildNoloReadOnlyBridgePrompt(),
-    bridgeArgs
-      ? buildTaskRunBridgePrompt({
-          agentKey: bridgeArgs.agentKey,
-          agentConfig,
-          runtimeContext: bridgeArgs.runtimeContext,
-        })
-      : "",
-    buildMachinePermissionPromptBlock(policy),
-    `--- User task ---\n${userInput}`,
-  ]
-    .filter(Boolean)
-    .join("\n\n");
-}

package/machineCommandResolution.ts

@@ -1,43 +0,0 @@
-import {
-  hasFlag,
-  readCliOptionValue,
-  resolveAuthToken as resolveCliAuthToken,
-  resolveAuthTokenFromArgs,
-  resolveServerUrlFromArgs,
-  resolveServerUrlFromEnv,
-  type EnvLike,
-} from "./cliEnvHelpers";
-import type { OutputLike } from "./cliIoTypes";
-export type { OutputLike } from "./cliIoTypes";
-export { hasFlag };
-
-export function resolveServerUrl(env: EnvLike) {
-  return resolveServerUrlFromEnv(env);
-}
-
-export function resolveAuthToken(env: EnvLike) {
-  return resolveCliAuthToken(env);
-}
-
-export function writeAuthMissing(output: OutputLike) {
-  output.write(
-    "[nolo] Machine commands require an auth token. Run `nolo login` or set AUTH_TOKEN.\n"
-  );
-}
-
-export function readOption(args: string[], flag: string) {
-  return readCliOptionValue(args, flag);
-}
-
-export function resolveConnectServerUrl(args: string[], env: EnvLike) {
-  return resolveServerUrlFromArgs(args, env);
-}
-
-export function resolveConnectAuthToken(args: string[], env: EnvLike) {
-  return resolveAuthTokenFromArgs(args, env);
-}
-
-export function resolveConnectorReconnectDelayMs(env: EnvLike) {
-  const raw = Number(env.NOLO_CONNECT_RECONNECT_MS ?? "");
-  return Number.isFinite(raw) && raw >= 0 ? raw : 5_000;
-}

package/noloReadBridgePrompt.ts

@@ -1,16 +0,0 @@
-const REPO_CLI_PREFIX = "bun packages/cli/index.ts";
-
-export function buildNoloReadOnlyBridgePrompt() {
-  return [
-    "--- Nolo read-only CLI bridge ---",
-    "This CLI runtime does not receive server-side function tools directly.",
-    "Use these repo-local read commands to fetch authoritative Nolo docs and records on demand instead of trusting prompt snapshots or summaries alone.",
-    "Run commands from the repository root. The runner already provides server URL and auth in the environment.",
-    `Read doc/page truth: ${REPO_CLI_PREFIX} doc read "<pageKey>"`,
-    `Read skill doc truth: ${REPO_CLI_PREFIX} skill-doc read "<pageKey>"`,
-    `Read dialog truth: ${REPO_CLI_PREFIX} dialog read "<dialogId|dialogUrl>"`,
-    `Read shared space truth: ${REPO_CLI_PREFIX} space read "<spaceId|spaceKey|spaceUrl>"`,
-    `Read agent truth: ${REPO_CLI_PREFIX} agent read "<agentKey|agentAlias|agentUrl>"`,
-    "If a read command fails, report the exact command and error.",
-  ].join("\n");
-}

package/pageCreateCommands.ts

@@ -1,219 +0,0 @@
-import type { SkillDocConfig } from "./ai/skills/skillDocProtocol";
-import { getReadableCliDb, type AgentCommandDeps } from "./agentCommandSupport";
-import { readDbRecord } from "./agentRecordHelpers";
-import { parseUserIdFromAuthToken, resolveAuthToken, resolveServerUrl } from "./cliEnvHelpers";
-import {
-  buildDocSpaceRecord,
-  buildPageKey,
-  buildPageRecord,
-  buildSkillDocId,
-  buildSkillPageRecord,
-  buildSkillSummaryFromRecord,
-  createPageId,
-  parseJsonOption,
-  readBodyOption,
-  readOption,
-  writeRemoteRecordsThenCache,
-} from "./pageWriteHelpers";
-import { findPotentialSecrets, formatSecretFindings } from "./secretScanHelpers";
-
-function usage(command: "doc" | "skill-doc") {
-  return [
-    "Usage:",
-    `  nolo ${command} create --title <title> [options]`,
-    "",
-  ].join("\n");
-}
-
-async function readSpaceRecord(args: {
-  authToken: string;
-  db: Awaited<ReturnType<typeof getReadableCliDb>>;
-  fetchImpl: typeof fetch;
-  fallbackFetchImpl?: typeof fetch;
-  serverUrl: string;
-  spaceKey: string;
-}) {
-  try {
-    return await args.db.get(args.spaceKey);
-  } catch {
-    return readDbRecord({
-      authToken: args.authToken,
-      dbKey: args.spaceKey,
-      fallbackFetchImpl: args.fallbackFetchImpl,
-      fetchImpl: args.fetchImpl,
-      serverUrl: args.serverUrl,
-    });
-  }
-}
-
-async function runBasePageCreateCommand(
-  args: string[],
-  deps: AgentCommandDeps,
-  mode: "doc" | "skill-doc"
-) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  if (args.includes("--help") || args.includes("-h")) {
-    output.write(`${usage(mode)}\n`);
-    return 0;
-  }
-
-  const title = readOption(args, "--title")?.trim();
-  const description = readOption(args, "--description")?.trim();
-  const spaceId = readOption(args, "--space")?.trim() ?? null;
-  if (!title || !spaceId || (mode === "skill-doc" && !description)) {
-    output.write(`${usage(mode)}\n`);
-    return 1;
-  }
-
-  const authToken = resolveAuthToken(args, env);
-  const userId = parseUserIdFromAuthToken(authToken);
-  if (!authToken || !userId) {
-    output.write(`[nolo] ${mode} create requires an auth token with userId. Run \`nolo login\`.\n`);
-    return 1;
-  }
-
-  const body = readBodyOption(args, "");
-  const secretFindings = findPotentialSecrets(body);
-  if (secretFindings.length > 0 && !args.includes("--allow-secrets")) {
-    output.write(
-      `[nolo] refusing to create ${mode} because the body looks like it contains secrets.\n${formatSecretFindings(secretFindings)}\n`
-    );
-    return 1;
-  }
-
-  const serverUrl = resolveServerUrl(args, env);
-  const db = deps.db ?? await getReadableCliDb(output);
-  const fetchImpl = deps.fetchImpl ?? fetch;
-  const fallbackFetchImpl = deps.fallbackFetchImpl;
-  const explicitId = readOption(args, "--id")?.trim();
-  const pageId = explicitId || (mode === "skill-doc" ? buildSkillDocId(title) : createPageId());
-  const dbKey = buildPageKey(userId, pageId);
-  const spaceKey = `space-${spaceId}`;
-  const shouldDryRun = args.includes("--dry-run");
-  const shouldOutputJson = args.includes("--json");
-
-  const pageRecord =
-    mode === "skill-doc"
-      ? buildSkillPageRecord({
-          body,
-          dbKey,
-          existing: null,
-          skillConfig: {
-            version: "0.1",
-            kind: "skill",
-            id: pageId,
-            name: title,
-            description: description!,
-            ...(readOption(args, "--tools") !== undefined
-              ? { toolNames: parseJsonOption<string[]>(readOption(args, "--tools"), []) }
-              : {}),
-            ...(readOption(args, "--required-skills") !== undefined
-              ? { requiredSkills: parseJsonOption<string[]>(readOption(args, "--required-skills"), []) }
-              : {}),
-            ...(readOption(args, "--recommended-skills") !== undefined
-              ? { recommendedSkills: parseJsonOption<string[]>(readOption(args, "--recommended-skills"), []) }
-              : {}),
-            ...(readOption(args, "--preferred-agents") !== undefined
-              ? { preferredAgents: parseJsonOption<string[]>(readOption(args, "--preferred-agents"), []) }
-              : {}),
-            ...(readOption(args, "--trigger-mode") !== undefined
-              ? { triggerMode: readOption(args, "--trigger-mode") as SkillDocConfig["triggerMode"] }
-              : {}),
-            ...(readOption(args, "--budget-tier") !== undefined
-              ? { budgetTier: readOption(args, "--budget-tier") as SkillDocConfig["budgetTier"] }
-              : {}),
-            ...(readOption(args, "--prompt-patch") !== undefined
-              ? { promptPatch: readOption(args, "--prompt-patch") || undefined }
-              : {}),
-          },
-          skillId: pageId,
-          spaceId,
-          title,
-        })
-      : buildPageRecord({
-          content: body,
-          dbKey,
-          meta: description ? { description } : undefined,
-          pageId,
-          spaceId,
-          title,
-        });
-
-  const summary = {
-    dryRun: shouldDryRun,
-    kind: mode === "skill-doc" ? "skill" : "page",
-    title,
-    dbKey,
-    id: pageId,
-    spaceId,
-    baseUrl: serverUrl,
-    secretFindingCount: secretFindings.length,
-    secretFindings,
-  };
-
-  if (shouldDryRun) {
-    output.write(`${JSON.stringify(summary, null, 2)}\n`);
-    return 0;
-  }
-
-  try {
-    const existingSpaceRecord = await readSpaceRecord({
-      authToken,
-      db,
-      fallbackFetchImpl,
-      fetchImpl,
-      serverUrl,
-      spaceKey,
-    });
-    const spaceRecord = buildDocSpaceRecord({
-      contentKey: dbKey,
-      existingSpaceRecord,
-      skillSummary: mode === "skill-doc" ? buildSkillSummaryFromRecord(pageRecord) : undefined,
-      spaceId,
-      title,
-    });
-
-    await writeRemoteRecordsThenCache({
-      authToken,
-      db,
-      fallbackFetchImpl,
-      fetchImpl,
-      records: [
-        { dbKey, record: pageRecord, serverUrl },
-        { dbKey: spaceKey, record: spaceRecord, serverUrl },
-      ],
-      userId,
-    });
-
-    output.write(
-      `${JSON.stringify(
-        shouldOutputJson ? summary : { ...summary, ok: true },
-        null,
-        2
-      )}\n`
-    );
-    return 0;
-  } catch (error) {
-    output.write(
-      `[nolo] ${mode} create failed: ${
-        error instanceof Error ? error.message : String(error)
-      }\n`
-    );
-    return 1;
-  }
-}
-
-export async function runDocCreateCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  return runBasePageCreateCommand(args, deps, "doc");
-}
-
-export async function runSkillDocCreateCommand(
-  args: string[],
-  deps: AgentCommandDeps = {}
-) {
-  return runBasePageCreateCommand(args, deps, "skill-doc");
-}