deepline 0.3.409 → 0.3.411

package/dist/cli/chunk-7DSMMCXP.js

@@ -0,0 +1,501 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkTPFD4F5Sjs = require('./chunk-TPFD4F5S.js');
+
+
+var _chunkZHWBU36Hjs = require('./chunk-ZHWBU36H.js');
+
+
+
+
+
+
+
+var _chunkOZSC6CEWjs = require('./chunk-OZSC6CEW.js');
+
+// src/cli/commands/skills.ts
+var _child_process = require('child_process');
+var _fs = require('fs');
+var _os = require('os');
+var _path = require('path');
+var SKILLS_INSTALL_LEASE_WAIT_MS = 9e4;
+var SKILLS_PROCESS_TIMEOUT_MS = 45e3;
+var RUNTIME_TO_SKILLS_AGENT = {
+  antigravity: "antigravity",
+  claude_code: "claude-code",
+  claude_cowork: "claude-code",
+  cline: "cline",
+  codex: "codex",
+  cursor: "cursor",
+  gemini: "gemini-cli",
+  windsurf: "windsurf"
+};
+var AGENT_MARKERS = [
+  { agent: "codex", paths: [".codex"] },
+  { agent: "claude-code", paths: [".claude"] },
+  { agent: "cursor", paths: [".cursor"] },
+  { agent: "gemini-cli", paths: [".gemini", ".gemini-cli"] },
+  { agent: "antigravity", paths: [".antigravity"] }
+];
+var WORKSPACE_SKILL_ROOTS_BY_AGENT = {
+  antigravity: [".agents"],
+  "claude-code": [".claude"],
+  cline: [".agents"],
+  codex: [".agents"],
+  cursor: [".agents"],
+  "gemini-cli": [".agents"],
+  windsurf: [".windsurf"],
+  "*": [".agents", ".claude", ".windsurf"]
+};
+function workspaceSkillRootsForAgents(agents) {
+  return [
+    ...new Set(
+      agents.flatMap((agent) => _nullishCoalesce(WORKSPACE_SKILL_ROOTS_BY_AGENT[agent], () => ( [])))
+    )
+  ].sort((a, b) => a.localeCompare(b));
+}
+function normalizeScope(value) {
+  if (value === "global") return "global";
+  if (value === "local") return "local";
+  if (!value) return inferActiveSkillsScope();
+  throw new Error("--scope must be one of: global, local");
+}
+function inferActiveSkillsScope(entrypoint = _nullishCoalesce(process.argv[1], () => ( ""))) {
+  return /[\\/]\.deepline[\\/]runtime[\\/]/.test(entrypoint) ? "local" : "global";
+}
+function resolveLocalRoot() {
+  const target = _chunkOZSC6CEWjs.resolveProjectPinTarget.call(void 0, );
+  if (!target.ok) {
+    throw new Error(
+      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
+        ", "
+      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder.`
+    );
+  }
+  return target.dir;
+}
+function detectSkillsAgents(input) {
+  const runtime = _nullishCoalesce(input.runtime, () => ( _chunkOZSC6CEWjs.detectAgentRuntime.call(void 0, )));
+  const knownAgent = RUNTIME_TO_SKILLS_AGENT[runtime];
+  if (knownAgent) return [knownAgent];
+  const roots = [
+    ...input.scope === "local" && input.root ? [input.root] : [],
+    _nullishCoalesce(input.homeDir, () => ( _os.homedir.call(void 0, )))
+  ];
+  const detected = AGENT_MARKERS.filter(
+    (marker) => roots.some(
+      (root) => marker.paths.some((path) => _fs.existsSync.call(void 0, _path.join.call(void 0, root, path)))
+    )
+  ).map((marker) => marker.agent);
+  return detected.length > 0 ? detected : ["*"];
+}
+function skillsStatePathForScope(baseUrl, scope, root) {
+  return scope === "local" && root ? _path.join.call(void 0, root, ".deepline", "setup", "skills.json") : _path.join.call(void 0, _chunkOZSC6CEWjs.sdkCliStateDirPath.call(void 0, baseUrl), "skills-install.json");
+}
+function buildSkillsPlan(input) {
+  const scopeArgs = input.scope === "global" ? ["--global"] : [];
+  const legacyNames = [..._chunkTPFD4F5Sjs.LEGACY_SKILL_NAMES_TO_REMOVE].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  return {
+    scope: input.scope,
+    root: input.root,
+    agents: input.agents,
+    skillNames: input.skillNames,
+    version: input.version,
+    remove: {
+      command: "npm",
+      args: [
+        "exec",
+        "--yes",
+        `--package=${_chunkTPFD4F5Sjs.SKILLS_NPX_PACKAGE}`,
+        "--",
+        "skills",
+        "remove",
+        ...scopeArgs,
+        "--agent",
+        ...input.agents,
+        "-y",
+        ...legacyNames
+      ]
+    },
+    install: {
+      command: "npm",
+      args: [
+        "exec",
+        "--yes",
+        `--package=${_chunkTPFD4F5Sjs.SKILLS_NPX_PACKAGE}`,
+        "--",
+        "skills",
+        "add",
+        _chunkTPFD4F5Sjs.skillsSourceUrl.call(void 0, input.baseUrl),
+        "--agent",
+        ...input.agents,
+        ...scopeArgs,
+        "--yes",
+        ...input.skillNames.flatMap((name) => ["--skill", name]),
+        "--full-depth"
+      ]
+    },
+    statePath: skillsStatePathForScope(input.baseUrl, input.scope, input.root)
+  };
+}
+function sortedStrings(value) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    return null;
+  }
+  return [...value].sort((a, b) => a.localeCompare(b));
+}
+function isSkillsPlanCurrent(plan, state) {
+  if (!state || state.scope !== plan.scope || state.skillsVersion !== plan.version) {
+    return false;
+  }
+  const installedAgents = sortedStrings(state.agents);
+  const installedSkillNames = sortedStrings(state.skillNames);
+  if (!installedAgents || !installedSkillNames) return false;
+  return installedAgents.join("\0") === [...plan.agents].sort((a, b) => a.localeCompare(b)).join("\0") && installedSkillNames.join("\0") === [...plan.skillNames].sort((a, b) => a.localeCompare(b)).join("\0");
+}
+function readSkillsInstallState(path) {
+  try {
+    const parsed = JSON.parse(_fs.readFileSync.call(void 0, path, "utf8"));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch (e) {
+    return null;
+  }
+}
+function runProcess(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const plan = _chunkTPFD4F5Sjs.resolveShellSpawn.call(void 0, 
+      command,
+      args,
+      process.platform,
+      process.env,
+      cwd
+    );
+    const child = _child_process.spawn.call(void 0, plan.command, plan.args, {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "ignore", "pipe"],
+      shell: plan.shell
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      process.stderr.write(chunk);
+    });
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(
+        new Error(
+          `${_chunkTPFD4F5Sjs.SKILLS_NPX_PACKAGE} timed out after ${SKILLS_PROCESS_TIMEOUT_MS}ms.`
+        )
+      );
+    }, SKILLS_PROCESS_TIMEOUT_MS);
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timeout);
+      if (code && stderr.trim()) {
+        process.stderr.write(`${_chunkTPFD4F5Sjs.SKILLS_NPX_PACKAGE} exited ${code}.
+`);
+      }
+      resolve(_nullishCoalesce(code, () => ( 1)));
+    });
+  });
+}
+async function runSkillsCommand(options, dependencies = {}) {
+  let scope;
+  let root;
+  try {
+    scope = normalizeScope(options.scope);
+    root = scope === "local" ? resolveLocalRoot() : null;
+  } catch (error) {
+    _chunkZHWBU36Hjs.printCommandEnvelope.call(void 0, 
+      {
+        ok: false,
+        status: "failed",
+        code: "INVALID_SKILLS_SCOPE",
+        exitCode: 2,
+        message: error instanceof Error ? error.message : String(error)
+      },
+      { json: options.json }
+    );
+    return 2;
+  }
+  const baseUrl = _chunkOZSC6CEWjs.autoDetectBaseUrl.call(void 0, ).replace(/\/$/, "");
+  const catalog = {
+    skillNames: [..._chunkTPFD4F5Sjs.DEFAULT_SDK_SKILL_NAMES],
+    version: _chunkOZSC6CEWjs.SDK_VERSION
+  };
+  const agents = options.agent ? [options.agent] : detectSkillsAgents({ scope, root });
+  const plan = buildSkillsPlan({ baseUrl, scope, root, agents, ...catalog });
+  if (options.dryRun) {
+    _chunkZHWBU36Hjs.printCommandEnvelope.call(void 0, 
+      { ok: true, status: "planned", dryRun: true, ...plan },
+      { json: options.json }
+    );
+    return 0;
+  }
+  if (isSkillsPlanCurrent(plan, readSkillsInstallState(plan.statePath)) && !_chunkTPFD4F5Sjs.hasFailedAutomaticSkillsSync.call(void 0, baseUrl, agents)) {
+    _chunkZHWBU36Hjs.printCommandEnvelope.call(void 0, 
+      {
+        ok: true,
+        status: "current",
+        complete: true,
+        changed: false,
+        skipped: true,
+        skipReason: "skills_version_current",
+        scope,
+        agents,
+        skillsVersion: plan.version,
+        skillCount: plan.skillNames.length,
+        statePath: plan.statePath,
+        render: {
+          sections: [
+            {
+              title: "skills",
+              lines: [
+                `Scope: ${scope}`,
+                `Agents: ${agents.join(", ")}`,
+                `Current: ${plan.skillNames.length}`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+    return 0;
+  }
+  if (scope === "local" && root) {
+    const managedNames = [
+      .../* @__PURE__ */ new Set([...plan.skillNames, ..._chunkTPFD4F5Sjs.LEGACY_SKILL_NAMES_TO_REMOVE])
+    ];
+    const agentRoots = workspaceSkillRootsForAgents(plan.agents);
+    _chunkOZSC6CEWjs.ensureProjectPrivatePathsIgnored.call(void 0, root, [
+      ".deepline/",
+      ...agentRoots.flatMap(
+        (agentRoot) => managedNames.map((name) => `${agentRoot}/skills/${name}/`)
+      )
+    ]);
+  }
+  let lease;
+  try {
+    lease = scope === "global" ? await _chunkTPFD4F5Sjs.acquireSkillsInstallLease.call(void 0, baseUrl, agents, plan.version, {
+      waitMs: _nullishCoalesce(dependencies.installLeaseWaitMs, () => ( SKILLS_INSTALL_LEASE_WAIT_MS)),
+      onWait: () => process.stderr.write(
+        "Waiting for a background Deepline skills refresh to finish...\n"
+      )
+    }) : { release: () => {
+    } };
+  } catch (error) {
+    if (!(error instanceof _chunkTPFD4F5Sjs.SkillsStateUnavailableError)) throw error;
+    _chunkZHWBU36Hjs.printCommandEnvelope.call(void 0, 
+      {
+        ok: false,
+        status: "failed",
+        code: "SKILLS_STATE_UNAVAILABLE",
+        exitCode: 5,
+        scope,
+        agents,
+        message: error.message,
+        next: `Resolve this filesystem error, then run: deepline skills --scope ${scope}`
+      },
+      { json: options.json }
+    );
+    return 5;
+  }
+  if (!lease) {
+    _chunkZHWBU36Hjs.printCommandEnvelope.call(void 0, 
+      {
+        ok: false,
+        status: "failed",
+        code: "SKILLS_SYNC_IN_PROGRESS",
+        exitCode: 7,
+        scope,
+        agents,
+        message: "A background Deepline skills refresh is still running for these agents.",
+        next: `Retry in a moment: deepline skills --scope ${scope}. If no refresh is running, remove ${_chunkTPFD4F5Sjs.skillsInstallLeasePath.call(void 0, baseUrl, agents)}`
+      },
+      { json: options.json }
+    );
+    return 7;
+  }
+  try {
+    return await runSkillsInstallWithLease({
+      options,
+      dependencies,
+      baseUrl,
+      scope,
+      root,
+      agents,
+      plan
+    });
+  } finally {
+    lease.release();
+  }
+}
+async function runSkillsInstallWithLease(input) {
+  const { options, dependencies, baseUrl, scope, root, agents, plan } = input;
+  process.stderr.write(
+    `Replacing Deepline skills for ${agents.join(", ")} (${scope})...
+`
+  );
+  const execute = _nullishCoalesce(dependencies.runProcess, () => ( runProcess));
+  try {
+    const installCode = await execute(
+      plan.install.command,
+      plan.install.args,
+      _nullishCoalesce(root, () => ( void 0))
+    );
+    if (installCode !== 0) {
+      throw new Error("Could not install the current Deepline skills.");
+    }
+  } catch (error) {
+    _chunkZHWBU36Hjs.printCommandEnvelope.call(void 0, 
+      {
+        ok: false,
+        status: "failed",
+        code: "SKILLS_INSTALL_FAILED",
+        exitCode: 5,
+        scope,
+        agents,
+        message: error instanceof Error ? error.message : String(error),
+        next: `deepline skills --scope ${scope}`
+      },
+      { json: options.json }
+    );
+    return 5;
+  }
+  try {
+    const removeCode = await execute(
+      plan.remove.command,
+      plan.remove.args,
+      _nullishCoalesce(root, () => ( void 0))
+    );
+    if (removeCode !== 0) {
+      process.stderr.write(
+        "Current Deepline skills installed, but legacy skill cleanup failed. The installed skills remain usable.\n"
+      );
+    }
+  } catch (error) {
+    process.stderr.write(
+      `Current Deepline skills installed, but legacy skill cleanup failed: ${error instanceof Error ? error.message : String(error)}. The installed skills remain usable.
+`
+    );
+  }
+  _fs.mkdirSync.call(void 0, _path.dirname.call(void 0, plan.statePath), { recursive: true });
+  _fs.writeFileSync.call(void 0, 
+    plan.statePath,
+    `${JSON.stringify(
+      {
+        schemaVersion: 1,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cliVersion: _chunkOZSC6CEWjs.SDK_VERSION,
+        scope,
+        agents,
+        skillsVersion: plan.version,
+        skillNames: plan.skillNames
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+  if (scope === "global") {
+    _chunkTPFD4F5Sjs.clearFailedAutomaticSkillsSync.call(void 0, baseUrl, agents);
+  }
+  _chunkZHWBU36Hjs.printCommandEnvelope.call(void 0, 
+    {
+      ok: true,
+      status: "complete",
+      scope,
+      agents,
+      skillsVersion: plan.version,
+      skillCount: plan.skillNames.length,
+      statePath: plan.statePath,
+      render: {
+        sections: [
+          {
+            title: "skills",
+            lines: [
+              `Scope: ${scope}`,
+              `Agents: ${agents.join(", ")}`,
+              `Installed: ${plan.skillNames.length}`
+            ]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+  return 0;
+}
+function registerSkillsCommand(program) {
+  program.command("skills").description("Replace Deepline agent skills with the current release.").option("--scope <scope>", "Install scope: global or local").option("--agent <agent>", "Override the detected agent target").option("--dry-run", "Print the install plan without changing files").option("--json", "Emit one JSON result envelope").addHelpText(
+    "after",
+    `
+Notes:
+  This command reinstalls current Deepline-managed skills using ${_chunkTPFD4F5Sjs.SKILLS_NPX_PACKAGE},
+  then removes legacy Deepline skill names. Local scope writes into the resolved
+  persistent project.
+
+Examples:
+  deepline skills
+  deepline skills --scope local
+  deepline skills --agent codex --dry-run
+`
+  ).action(async (options) => {
+    process.exitCode = await runSkillsCommand(options);
+  });
+  program.command(_chunkTPFD4F5Sjs.SKILLS_AUTO_SYNC_COMMAND, { hidden: true }).description("Refresh Deepline agent skills in the background.").option(
+    "--claim <token>",
+    "Owner token of the leases this child was started for."
+  ).action(async (options) => {
+    const claim = _optionalChain([options, 'access', _ => _.claim, 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]);
+    if (!claim) {
+      _chunkZHWBU36Hjs.printCommandEnvelope.call(void 0, 
+        {
+          ok: false,
+          status: "failed",
+          code: "SKILLS_AUTO_SYNC_CLAIM_REQUIRED",
+          exitCode: 2,
+          message: "skills-auto-sync is started by ordinary deepline commands and requires the lease token they pass; run `deepline skills` to install skills yourself."
+        },
+        { json: true }
+      );
+      process.exitCode = 2;
+      return;
+    }
+    await _chunkTPFD4F5Sjs.syncSdkSkillsIfNeeded.call(void 0, _chunkOZSC6CEWjs.autoDetectBaseUrl.call(void 0, ).replace(/\/$/, ""), {
+      mode: "inline",
+      notices: "defer",
+      claim
+    });
+  });
+}
+
+
+
+
+
+
+
+
+
+
+exports.workspaceSkillRootsForAgents = workspaceSkillRootsForAgents; exports.inferActiveSkillsScope = inferActiveSkillsScope; exports.detectSkillsAgents = detectSkillsAgents; exports.skillsStatePathForScope = skillsStatePathForScope; exports.buildSkillsPlan = buildSkillsPlan; exports.isSkillsPlanCurrent = isSkillsPlanCurrent; exports.runSkillsCommand = runSkillsCommand; exports.registerSkillsCommand = registerSkillsCommand;