@impulselab/directory 1.1.0 → 2.7.5

package/dist/index.js

@@ -0,0 +1,1615 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { readFileSync } from "fs";
+import path7 from "path";
+import { fileURLToPath } from "url";
+import { Command } from "commander";
+
+// src/commands/add.ts
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
+import path3 from "path";
+import {
+  cancel,
+  intro,
+  isCancel,
+  multiselect,
+  outro,
+  spinner
+} from "@clack/prompts";
+
+// ../shared/src/artifact.ts
+var ARTIFACT_KINDS = ["skill", "command", "agent", "rule"];
+var legacyTargetToKindMap = {
+  "claude-slash": "command",
+  "claude-sub-agent": "agent",
+  "claude-skill": "skill",
+  "cursor-command": "command",
+  "cursor-rule": "rule"
+};
+var LEGACY_TARGETS = Object.keys(legacyTargetToKindMap);
+function legacyTargetToKind(target) {
+  if (target in legacyTargetToKindMap) {
+    return legacyTargetToKindMap[target];
+  }
+  return;
+}
+
+// ../shared/src/hash.ts
+import { createHash } from "crypto";
+function sha256Hex(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex");
+}
+
+// ../shared/src/manifest.ts
+import { z } from "zod";
+
+// ../shared/src/safe-segment.ts
+var SAFE_PATH_SEGMENT_REGEX = /^[a-z0-9](?:[a-z0-9._-]*[a-z0-9])?$/i;
+function isSafePathSegment(value) {
+  return value.length <= 128 && SAFE_PATH_SEGMENT_REGEX.test(value);
+}
+
+// ../shared/src/manifest.ts
+var sha256HexSchema = z.string().regex(/^[a-f0-9]{64}$/);
+var safePathSegmentSchema = z.string().max(256).regex(SAFE_PATH_SEGMENT_REGEX);
+var manifestArtifactSchema = z.object({
+  id: z.string(),
+  slug: safePathSegmentSchema,
+  ownerSlug: safePathSegmentSchema,
+  path: z.string(),
+  title: z.string(),
+  kind: z.enum(ARTIFACT_KINDS),
+  version: z.number().int().min(1),
+  contentHash: sha256HexSchema
+});
+var manifestStackSchema = z.object({
+  id: z.string(),
+  slug: safePathSegmentSchema,
+  title: z.string(),
+  artifacts: z.array(manifestArtifactSchema)
+});
+var syncManifestSchema = z.object({
+  generatedAt: z.iso.datetime(),
+  stacks: z.array(manifestStackSchema)
+});
+var artifactResponseSchema = manifestArtifactSchema.extend({
+  content: z.string(),
+  changelog: z.string().nullable()
+});
+var pushVersionRequestSchema = z.object({
+  content: z.string().min(1),
+  baseVersion: z.number().int().min(1),
+  changelog: z.string().max(500).optional()
+});
+var pushVersionResponseSchema = z.object({
+  id: z.string(),
+  version: z.number().int().min(1),
+  contentHash: sha256HexSchema
+});
+var meResponseSchema = z.object({
+  user: z.object({
+    id: z.string(),
+    slug: safePathSegmentSchema,
+    name: z.string(),
+    email: z.string()
+  })
+});
+
+// ../shared/src/targets.ts
+var AGENT_NAMES = ["claude", "codex", "cursor"];
+var TARGET_RULES = {
+  skill: [
+    {
+      agent: "claude",
+      scopes: ["global", "project"],
+      relativePath: (slug) => `.claude/skills/${slug}/SKILL.md`
+    }
+  ],
+  command: [
+    {
+      agent: "claude",
+      scopes: ["global", "project"],
+      relativePath: (slug) => `.claude/commands/${slug}.md`
+    },
+    {
+      agent: "codex",
+      scopes: ["global"],
+      relativePath: (slug) => `.codex/prompts/${slug}.md`
+    },
+    {
+      agent: "cursor",
+      scopes: ["project"],
+      relativePath: (slug) => `.cursor/commands/${slug}.md`
+    }
+  ],
+  agent: [
+    {
+      agent: "claude",
+      scopes: ["global", "project"],
+      relativePath: (slug) => `.claude/agents/${slug}.md`
+    }
+  ],
+  rule: [
+    {
+      agent: "cursor",
+      scopes: ["project"],
+      relativePath: (slug) => `.cursor/rules/${slug}.mdc`
+    }
+  ]
+};
+function resolveInstallPaths(kind, slug, agents2, scope) {
+  if (!isSafePathSegment(slug)) {
+    throw new Error(`Invalid artifact slug '${slug}'`);
+  }
+  return TARGET_RULES[kind].filter(
+    (rule) => rule.scopes.includes(scope) && agents2.includes(rule.agent)
+  ).map((rule) => rule.relativePath(slug));
+}
+
+// src/commands/add.ts
+import pc from "picocolors";
+
+// src/lib/cli-invocation.ts
+var cliInvocation = "npx @impulselab/directory";
+function cliCommand(args) {
+  return `${cliInvocation} ${args}`;
+}
+
+// src/lib/config.ts
+import { chmod, mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
+import { z as z2 } from "zod";
+var configPath = path.join(homedir(), ".impulse", "config.json");
+var schemeRegex = /^[a-z][a-z\d+\-.]*:\/\//i;
+var trailingSlashesRegex = /\/+$/;
+var trailingSlashRegex = /\/$/;
+var httpSchemeRegex = /^https?:\/\//i;
+var agentConfigSchema = z2.object({
+  claude: z2.boolean().default(true),
+  codex: z2.boolean().default(true),
+  cursor: z2.boolean().default(true)
+});
+var configSchema = z2.object({
+  baseUrl: z2.string().default(normalizeBaseUrl(process.env.IMPULSE_BASE_URL)),
+  apiKey: z2.string().optional(),
+  agents: agentConfigSchema.default({
+    claude: true,
+    codex: true,
+    cursor: true
+  })
+});
+function normalizeBaseUrl(input) {
+  const raw = (input || "https://impulse.directory").trim();
+  const host = raw === "::1" ? "[::1]" : raw;
+  const withScheme = schemeRegex.test(raw) ? raw : `${isLocalHost(raw) ? "http" : "https"}://${host}`;
+  try {
+    const url = new URL(withScheme);
+    url.pathname = url.pathname.replace(trailingSlashesRegex, "");
+    url.search = "";
+    url.hash = "";
+    return url.toString().replace(trailingSlashRegex, "");
+  } catch {
+    throw new Error(`Invalid base URL: ${input}`);
+  }
+}
+function defaultConfig() {
+  return configSchema.parse({});
+}
+async function loadConfig() {
+  try {
+    const raw = await readFile(configPath, "utf8");
+    const parsed = configSchema.parse(JSON.parse(raw));
+    return {
+      ...parsed,
+      baseUrl: normalizeBaseUrl(process.env.IMPULSE_BASE_URL || parsed.baseUrl)
+    };
+  } catch (error) {
+    if (isNotFound(error)) {
+      return defaultConfig();
+    }
+    throw error;
+  }
+}
+async function saveConfig(config) {
+  await mkdir(path.dirname(configPath), { recursive: true });
+  const temporaryPath = `${configPath}.tmp`;
+  await writeFile(temporaryPath, `${JSON.stringify(config, null, 2)}
+`, {
+    mode: 384
+  });
+  await chmod(temporaryPath, 384);
+  await rename(temporaryPath, configPath);
+  await chmod(configPath, 384);
+}
+function isLocalHost(input) {
+  const withoutScheme = input.trim().replace(httpSchemeRegex, "");
+  const hostname2 = extractHostname(withoutScheme);
+  return hostname2 === "localhost" || hostname2 === "127.0.0.1" || hostname2 === "::1";
+}
+function extractHostname(input) {
+  if (input === "::1") {
+    return "::1";
+  }
+  if (input.startsWith("[")) {
+    const bracketIndex = input.indexOf("]");
+    return bracketIndex === -1 ? input : input.slice(1, bracketIndex);
+  }
+  return input.split(":")[0];
+}
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/lib/api.ts
+var ApiError = class extends Error {
+  status;
+  payload;
+  constructor(status, message, payload) {
+    super(message);
+    this.name = "ApiError";
+    this.status = status;
+    this.payload = payload;
+  }
+};
+function createApiClient(baseUrl, apiKey) {
+  assertAllowedBaseUrl(baseUrl);
+  async function request(apiPath, schema, init = {}) {
+    let response;
+    try {
+      response = await fetch(`${baseUrl}${apiPath}`, {
+        ...init,
+        headers: {
+          ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+          ...init.body ? { "content-type": "application/json" } : {},
+          ...init.headers
+        }
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Could not reach ${baseUrl}: ${message}`);
+    }
+    const payload = await readPayload(response);
+    if (!response.ok) {
+      throw new ApiError(
+        response.status,
+        errorMessage(response.status, payload),
+        payload
+      );
+    }
+    return schema.parse(payload);
+  }
+  return {
+    artifact(id, version) {
+      if (version !== void 0 && (!Number.isInteger(version) || version < 1)) {
+        throw new Error("Artifact version must be a positive integer");
+      }
+      const query = version !== void 0 ? `?version=${version}` : "";
+      return request(
+        `/api/v1/artifacts/${encodeURIComponent(id)}${query}`,
+        artifactResponseSchema
+      );
+    },
+    manifest() {
+      return request("/api/v1/sync/manifest", syncManifestSchema);
+    },
+    me() {
+      return request("/api/v1/me", meResponseSchema);
+    },
+    pushVersion(id, body) {
+      const parsed = pushVersionRequestSchema.parse(body);
+      return request(
+        `/api/v1/artifacts/${encodeURIComponent(id)}/versions`,
+        pushVersionResponseSchema,
+        {
+          body: JSON.stringify(parsed),
+          method: "POST"
+        }
+      );
+    }
+  };
+}
+function assertAllowedBaseUrl(baseUrl) {
+  const url = new URL(baseUrl);
+  if (url.protocol === "http:" && process.env.IMPULSE_ALLOW_HTTP !== "1" && !isLocalHost(url.host)) {
+    throw new Error(
+      "Refusing to send credentials over HTTP to a non-local host. Use HTTPS or set IMPULSE_ALLOW_HTTP=1 to override."
+    );
+  }
+}
+async function readPayload(response) {
+  const text = await response.text();
+  if (!text) {
+    return null;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function errorMessage(status, payload) {
+  if (status === 401) {
+    return `Invalid or missing API key - run \`${cliCommand("login")}\``;
+  }
+  if (status === 403) {
+    return "You do not have permission to perform this action";
+  }
+  if (status === 409 && isObject(payload) && payload.error === "version_conflict") {
+    return `Remote is at v${payload.currentVersion}, run \`${cliCommand("sync")}\` first (your file is kept)`;
+  }
+  if (status === 422) {
+    return "The server rejected the request as invalid";
+  }
+  if (isObject(payload) && typeof payload.error === "string") {
+    return payload.error;
+  }
+  return `Request failed with HTTP ${status}`;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+
+// src/lib/paths.ts
+import { existsSync, realpathSync } from "fs";
+import { homedir as homedir2 } from "os";
+import path2 from "path";
+function canonicalize(target) {
+  const resolved = path2.resolve(target);
+  try {
+    return existsSync(resolved) ? realpathSync.native(resolved) : resolved;
+  } catch {
+    return resolved;
+  }
+}
+function findUp(names, start = process.cwd(), options = {}) {
+  let current = path2.resolve(start);
+  const stopBefore = options.stopBefore ? canonicalize(options.stopBefore) : null;
+  while (true) {
+    if (stopBefore && path2.relative(stopBefore, canonicalize(current)) === "") {
+      return null;
+    }
+    if (names.some((name) => existsSync(path2.join(current, name)))) {
+      return current;
+    }
+    const parent = path2.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+function resolveProjectRoot(start = process.cwd()) {
+  return findUp([".git", ".claude", ".cursor"], start, {
+    stopBefore: homedir2()
+  }) || path2.resolve(start);
+}
+function resolveAddScopeRoot() {
+  const projectRoot = findUp([".claude", ".cursor"]);
+  if (projectRoot) {
+    return { scope: "project", scopeRoot: projectRoot };
+  }
+  return { scope: "global", scopeRoot: homedir2() };
+}
+function resolveCursorProjectScopeRoot(start = process.cwd()) {
+  return {
+    scope: "project",
+    scopeRoot: findUp([".claude", ".cursor"], start, { stopBefore: homedir2() }) || path2.resolve(start)
+  };
+}
+function relativeDisplay(filePath) {
+  const relative = path2.relative(process.cwd(), filePath);
+  return relative && !relative.startsWith("..") ? relative : filePath;
+}
+
+// src/commands/add.ts
+var defaultTarget = "claude-slash";
+var scopeOrder = ["global", "project"];
+var agentLabels = {
+  claude: "Claude Code",
+  codex: "Codex",
+  cursor: "Cursor"
+};
+var accentsRegex = /[\u0300-\u036f]/g;
+var dotDotRegex = /\.\./g;
+var unsafeFilenameRegex = /[<>:"/\\|?*]/g;
+var pathSeparatorRegex = /[/\\]+/g;
+var unsupportedSlugCharsRegex = /[^a-zA-Z0-9._-]+/g;
+var edgeDashesRegex = /^-+|-+$/g;
+var targetAgents = {
+  "claude-skill": ["claude"],
+  "claude-slash": ["claude"],
+  "claude-sub-agent": ["claude"],
+  "cursor-command": ["cursor"],
+  "cursor-rule": ["cursor"]
+};
+async function addCommand(identifier, options) {
+  if (identifier === "stack") {
+    throw new Error("Missing stack id");
+  }
+  if (identifier.includes("/")) {
+    if (shouldRunInteractive(options)) {
+      await addInteractive(identifier);
+    } else {
+      await addRaw(identifier, options.target || defaultTarget);
+    }
+    return;
+  }
+  throw new Error(
+    `Use \`${cliCommand("add <owner/slug>")}\` or \`${cliCommand(
+      "add stack <id>"
+    )}\``
+  );
+}
+function shouldRunInteractive(options) {
+  return Boolean(
+    process.stdout.isTTY && process.stdin.isTTY && !options.target && !process.env.CI
+  );
+}
+function isArtifactKind(value) {
+  return value !== null && ARTIFACT_KINDS.includes(value);
+}
+function buildInstallOptions(kind, slug) {
+  const options = [];
+  for (const agent of AGENT_NAMES) {
+    for (const scope of scopeOrder) {
+      const paths = resolveInstallPaths(kind, slug, [agent], scope);
+      const relativePath = paths[0];
+      if (!relativePath) {
+        continue;
+      }
+      const scopeLabel = scope === "global" ? "global" : "this project";
+      const pathLabel = scope === "global" ? `~/${relativePath}` : relativePath;
+      options.push({
+        agent,
+        label: `${agentLabels[agent]} \u2014 ${scopeLabel} (${pathLabel})`,
+        relativePath,
+        scope,
+        value: `${agent}:${scope}`
+      });
+    }
+  }
+  return options;
+}
+function scopeRootFor(scope) {
+  if (scope === "global") {
+    return homedir3();
+  }
+  return resolveCursorProjectScopeRoot().scopeRoot;
+}
+function tildeDisplay(absPath) {
+  const home = homedir3();
+  return absPath.startsWith(home) ? `~${absPath.slice(home.length)}` : absPath;
+}
+async function addInteractive(identifier) {
+  const config = await loadConfig();
+  assertAllowedBaseUrl(config.baseUrl);
+  const slug = sanitizeSlug(identifier.split("/").at(-1) || "artifact");
+  intro(pc.cyan(`impulse \xB7 install ${identifier}`));
+  const loading = spinner();
+  loading.start("Fetching artifact");
+  let content;
+  let kind;
+  try {
+    const response = await fetch(
+      `${config.baseUrl}/raw/${identifier.split("/").map((segment) => encodeURIComponent(segment)).join("/")}`
+    );
+    if (!response.ok) {
+      throw new Error(
+        response.status === 404 ? `Command '${identifier}' not found` : `Request failed with HTTP ${response.status}`
+      );
+    }
+    content = await response.text();
+    const kindHeader = response.headers.get("X-Prompt-Kind");
+    kind = isArtifactKind(kindHeader) ? kindHeader : legacyTargetToKind(defaultTarget) ?? "command";
+  } catch (error) {
+    loading.stop("Fetch failed");
+    throw error;
+  }
+  loading.stop("Fetched artifact");
+  const options = buildInstallOptions(kind, slug);
+  if (options.length === 0) {
+    cancel(`No install destinations available for kind '${kind}'`);
+    return;
+  }
+  const defaultValue = options.find((option) => option.value === "claude:global")?.value ?? options[0].value;
+  const selection = await multiselect({
+    initialValues: [defaultValue],
+    message: "Where do you want to install it?",
+    options: options.map((option) => ({
+      label: option.label,
+      value: option.value
+    })),
+    required: true
+  });
+  if (isCancel(selection)) {
+    cancel("Cancelled");
+    return;
+  }
+  const chosen = options.filter((option) => selection.includes(option.value));
+  const written = [];
+  await Promise.all(
+    chosen.map(async (option) => {
+      const absPath = path3.join(
+        scopeRootFor(option.scope),
+        option.relativePath
+      );
+      await mkdir2(path3.dirname(absPath), { recursive: true });
+      await writeFile2(absPath, content, "utf8");
+      written.push(absPath);
+    })
+  );
+  outro(
+    written.map((absPath) => `${pc.green("\u2713")} ${tildeDisplay(absPath)}`).join("\n")
+  );
+}
+async function addStackCommand(stackId, options) {
+  const config = await loadConfig();
+  assertAllowedBaseUrl(config.baseUrl);
+  const payload = await fetchJson(
+    `${config.baseUrl}/api/stacks/${encodeURIComponent(stackId)}/npx`
+  );
+  const prompts = payload.prompts || [];
+  console.info(
+    `${pc.green("\u2713")} Installing stack '${payload.stack?.title || stackId}' (${prompts.length})`
+  );
+  let skipped = 0;
+  const installs = await Promise.all(
+    prompts.map(async (prompt, index) => {
+      const target = options.target || prompt.target || defaultTarget;
+      const markdown = prompt.markdown;
+      if (!markdown) {
+        skipped += 1;
+        console.info(
+          `${pc.yellow("\u26A0")} skipped ${prompt.slug || prompt.id || index + 1}`
+        );
+        return false;
+      }
+      await installLegacy({
+        content: markdown,
+        identifier: prompt.path || prompt.slug || prompt.id || `prompt-${index + 1}`,
+        slug: sanitizeSlug(
+          prompt.slug || prompt.path || prompt.id || `prompt-${index + 1}`
+        ),
+        target
+      });
+      return true;
+    })
+  );
+  const installed = installs.filter(Boolean).length;
+  console.info(
+    `${pc.green("\u2713")} Installed ${installed} prompt${installed === 1 ? "" : "s"}${skipped ? ` (skipped ${skipped})` : ""}`
+  );
+}
+async function addRaw(identifier, target) {
+  const config = await loadConfig();
+  assertAllowedBaseUrl(config.baseUrl);
+  const response = await fetch(
+    `${config.baseUrl}/raw/${identifier.split("/").map((segment) => encodeURIComponent(segment)).join("/")}`
+  );
+  if (!response.ok) {
+    throw new Error(
+      response.status === 404 ? `Command '${identifier}' not found` : `Request failed with HTTP ${response.status}`
+    );
+  }
+  await installLegacy({
+    content: await response.text(),
+    identifier,
+    slug: sanitizeSlug(identifier.split("/").at(-1) || "artifact"),
+    target
+  });
+}
+async function installLegacy(input) {
+  const kind = legacyTargetToKind(input.target);
+  if (!kind) {
+    throw new Error(
+      `Unknown target '${input.target}'. Available targets: ${LEGACY_TARGETS.join(
+        ", "
+      )}`
+    );
+  }
+  const agents2 = targetAgents[input.target] || agentsForKind(kind);
+  const { scope, scopeRoot } = agents2.includes("cursor") ? resolveCursorProjectScopeRoot() : await resolveAddScopeRoot();
+  const paths = resolveInstallPaths(kind, input.slug, agents2, scope);
+  if (paths.length === 0) {
+    throw new Error(
+      `Target '${input.target}' is not available in ${scope} scope`
+    );
+  }
+  await Promise.all(
+    paths.map(async (relativePath) => {
+      const absPath = path3.join(scopeRoot, relativePath);
+      await mkdir2(path3.dirname(absPath), { recursive: true });
+      await writeFile2(absPath, input.content, "utf8");
+      console.info(
+        `${pc.green("\u2713")} Installed '${input.identifier}' to ${absPath}`
+      );
+    })
+  );
+}
+async function fetchJson(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Request failed with HTTP ${response.status}`);
+  }
+  return await response.json();
+}
+function agentsForKind(kind) {
+  if (kind === "rule") {
+    return ["cursor"];
+  }
+  return ["claude"];
+}
+function sanitizeSlug(input) {
+  return input.normalize("NFKD").replace(accentsRegex, "").split("").filter((char) => {
+    const code = char.charCodeAt(0);
+    return code > 31 && (code < 127 || code > 159);
+  }).join("").replace(dotDotRegex, "").replace(unsafeFilenameRegex, "").replace(pathSeparatorRegex, "-").replace(unsupportedSlugCharsRegex, "-").replace(edgeDashesRegex, "").toLowerCase() || "artifact";
+}
+
+// src/commands/agents.ts
+import pc2 from "picocolors";
+var agentNames = ["claude", "codex", "cursor"];
+async function listAgentsCommand() {
+  const config = await loadConfig();
+  for (const agent of agentNames) {
+    const state = config.agents[agent] ? pc2.green("enabled") : pc2.dim("disabled");
+    console.info(`${agent.padEnd(8)} ${state}`);
+  }
+}
+async function updateAgentCommand(action, agent) {
+  if (!agentNames.includes(agent)) {
+    throw new Error(`Unknown agent '${agent}'`);
+  }
+  const config = await loadConfig();
+  const agents2 = {
+    ...config.agents,
+    [agent]: action === "enable"
+  };
+  await saveConfig({ ...config, agents: agents2 });
+  console.info(
+    pc2.green(`\u2713 ${agent} ${action === "enable" ? "enabled" : "disabled"}`)
+  );
+}
+
+// src/commands/login.ts
+import pc3 from "picocolors";
+
+// src/lib/device-auth.ts
+import { spawn } from "child_process";
+import { hostname, platform } from "os";
+import { z as z3 } from "zod";
+var CLIENT_ID = "impulse-cli";
+var deviceCodeSchema = z3.object({
+  device_code: z3.string(),
+  user_code: z3.string(),
+  verification_uri: z3.string(),
+  verification_uri_complete: z3.string().optional(),
+  expires_in: z3.number(),
+  interval: z3.number()
+});
+var tokenSuccessSchema = z3.object({
+  access_token: z3.string()
+});
+var tokenErrorSchema = z3.object({
+  error: z3.string(),
+  error_description: z3.string().optional()
+});
+var apiKeySchema = z3.object({
+  key: z3.string()
+});
+async function authRequest(baseUrl, path8, init) {
+  let response;
+  try {
+    response = await fetch(`${baseUrl}/api/auth${path8}`, init);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Could not reach ${baseUrl}: ${message}`);
+  }
+  const text = await response.text();
+  let payload = null;
+  if (text) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = text;
+    }
+  }
+  return { status: response.status, payload };
+}
+async function requestDeviceCode(baseUrl) {
+  const { status, payload } = await authRequest(baseUrl, "/device/code", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ client_id: CLIENT_ID })
+  });
+  if (status !== 200) {
+    throw new Error(
+      errorDescription(payload) ?? "Could not start device login"
+    );
+  }
+  return deviceCodeSchema.parse(payload);
+}
+function sleep(ms) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, ms);
+  });
+}
+async function pollForToken(baseUrl, device) {
+  const deadline = Date.now() + device.expires_in * 1e3;
+  let intervalMs = Math.max(device.interval, 1) * 1e3;
+  while (Date.now() < deadline) {
+    await sleep(intervalMs);
+    const { status, payload } = await authRequest(baseUrl, "/device/token", {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({
+        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        device_code: device.device_code,
+        client_id: CLIENT_ID
+      })
+    });
+    if (status === 200) {
+      return tokenSuccessSchema.parse(payload).access_token;
+    }
+    const parsed = tokenErrorSchema.safeParse(payload);
+    const errorCode = parsed.success ? parsed.data.error : "invalid_request";
+    if (errorCode === "authorization_pending") {
+      continue;
+    }
+    if (errorCode === "slow_down") {
+      intervalMs += 5e3;
+      continue;
+    }
+    if (errorCode === "access_denied") {
+      throw new Error(
+        `Authorization was denied. Run \`${cliCommand("login")}\` to retry.`
+      );
+    }
+    if (errorCode === "expired_token") {
+      throw new Error(
+        `The code expired. Run \`${cliCommand("login")}\` to get a new one.`
+      );
+    }
+    throw new Error(
+      errorDescription(payload) ?? `Device login failed (${errorCode})`
+    );
+  }
+  throw new Error(
+    `The code expired. Run \`${cliCommand("login")}\` to get a new one.`
+  );
+}
+async function createApiKey(baseUrl, accessToken) {
+  const { status, payload } = await authRequest(baseUrl, "/api-key/create", {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      authorization: `Bearer ${accessToken}`
+    },
+    body: JSON.stringify({ name: `cli-${hostname()}` })
+  });
+  if (status !== 200) {
+    throw new Error(
+      errorDescription(payload) ?? "Could not create an API key for the CLI"
+    );
+  }
+  return apiKeySchema.parse(payload).key;
+}
+function openBrowser(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new Error(`Refusing to open invalid URL: ${url}`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw new Error(
+      `Refusing to open URL with unsupported protocol: ${parsed.protocol}`
+    );
+  }
+  const commands = {
+    darwin: ["open", [url]],
+    win32: ["cmd", ["/c", "start", "", `"${url}"`]]
+  };
+  const [command, args] = commands[platform()] ?? ["xdg-open", [url]];
+  try {
+    const child = spawn(command, args, { stdio: "ignore", detached: true });
+    child.on("error", () => {
+    });
+    child.unref();
+  } catch {
+  }
+}
+function errorDescription(payload) {
+  if (payload && typeof payload === "object") {
+    const record = payload;
+    const description = record.error_description ?? record.message ?? record.error;
+    if (typeof description === "string") {
+      return description;
+    }
+  }
+  return null;
+}
+
+// src/commands/login.ts
+async function loginCommand(options) {
+  const existing = await loadConfig();
+  const baseUrl = normalizeBaseUrl(options.url || existing.baseUrl);
+  assertAllowedBaseUrl(baseUrl);
+  const apiKey = options.key ?? await deviceLogin(baseUrl);
+  const config = {
+    ...existing,
+    apiKey,
+    baseUrl
+  };
+  const me = await createApiClient(baseUrl, apiKey).me();
+  await saveConfig(config);
+  console.info(pc3.green(`\u2713 Logged in as ${me.user.slug}`));
+}
+async function deviceLogin(baseUrl) {
+  const device = await requestDeviceCode(baseUrl);
+  const openUrl = device.verification_uri_complete ?? device.verification_uri;
+  console.info("");
+  console.info("Authorize the Impulse CLI in your browser:");
+  console.info(`  ${pc3.cyan(pc3.bold(device.verification_uri))}`);
+  console.info("");
+  console.info(`  Your code: ${pc3.bold(device.user_code)}`);
+  console.info("");
+  openBrowser(openUrl);
+  console.info(pc3.dim("Waiting for approval\u2026"));
+  const accessToken = await pollForToken(baseUrl, device);
+  return createApiKey(baseUrl, accessToken);
+}
+
+// src/commands/logout.ts
+import pc4 from "picocolors";
+async function logoutCommand() {
+  const config = await loadConfig();
+  const nextConfig = { ...config };
+  nextConfig.apiKey = void 0;
+  await saveConfig(nextConfig);
+  console.info(pc4.green("\u2713 Logged out"));
+}
+
+// src/commands/push.ts
+import { readFile as readFile3, writeFile as writeFile4 } from "fs/promises";
+import { homedir as homedir5 } from "os";
+import path5 from "path";
+import pc5 from "picocolors";
+
+// src/lib/lock.ts
+import { randomUUID } from "crypto";
+import { mkdir as mkdir3, readFile as readFile2, rename as rename2, rm, writeFile as writeFile3 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import path4 from "path";
+import { z as z4 } from "zod";
+var lockEntrySchema = z4.object({
+  slug: z4.string(),
+  kind: z4.enum(ARTIFACT_KINDS),
+  version: z4.number().int().min(1),
+  contentHash: z4.string(),
+  files: z4.array(z4.string())
+});
+var lockfileSchema = z4.object({
+  artifacts: z4.record(z4.string(), lockEntrySchema).default({})
+});
+function lockPath(scope, scopeRoot) {
+  return scope === "global" ? path4.join(homedir4(), ".impulse", "lock.json") : path4.join(scopeRoot, ".impulse", "lock.json");
+}
+async function readLockfile(scope, scopeRoot) {
+  try {
+    const raw = await readFile2(lockPath(scope, scopeRoot), "utf8");
+    return lockfileSchema.parse(JSON.parse(raw));
+  } catch (error) {
+    if (isNotFound2(error)) {
+      return { artifacts: {} };
+    }
+    throw error;
+  }
+}
+async function writeLockfile(scope, scopeRoot, lock) {
+  const target = lockPath(scope, scopeRoot);
+  const temporaryPath = path4.join(
+    path4.dirname(target),
+    `.${path4.basename(target)}.${process.pid}.${randomUUID()}.tmp`
+  );
+  await mkdir3(path4.dirname(target), { recursive: true });
+  try {
+    await writeFile3(temporaryPath, `${JSON.stringify(lock, null, 2)}
+`, {
+      mode: 384
+    });
+    await rename2(temporaryPath, target);
+  } catch (error) {
+    try {
+      await rm(temporaryPath, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function isNotFound2(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/commands/push.ts
+async function pushCommand(filePath, options) {
+  const config = await loadConfig();
+  if (!config.apiKey) {
+    throw new Error(
+      `Invalid or missing API key - run \`${cliCommand("login")}\``
+    );
+  }
+  const absPath = path5.resolve(filePath);
+  const match = await findLockedFile(absPath);
+  if (!match) {
+    throw new Error(`No lock entry found for ${absPath}`);
+  }
+  const content = await readFile3(absPath, "utf8");
+  const api = createApiClient(config.baseUrl, config.apiKey);
+  try {
+    const response = await api.pushVersion(match.artifactId, {
+      baseVersion: match.entry.version,
+      changelog: options.message,
+      content
+    });
+    const lock = await readLockfile(match.scope, match.scopeRoot);
+    const currentEntry = lock.artifacts[match.artifactId] ?? match.entry;
+    const contentHash = response.contentHash || sha256Hex(content);
+    await updateUntouchedSiblings({
+      absPath,
+      content,
+      contentHash,
+      entry: currentEntry,
+      match
+    });
+    lock.artifacts[match.artifactId] = {
+      ...currentEntry,
+      contentHash,
+      version: response.version
+    };
+    await writeLockfile(match.scope, match.scopeRoot, lock);
+    console.info(
+      pc5.green(`\u2713 Published ${match.entry.slug} v${response.version}`)
+    );
+  } catch (error) {
+    if (error instanceof ApiError && error.status === 409) {
+      console.error(error.message);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+}
+async function findLockedFile(absPath) {
+  const candidates = [
+    { scope: "global", scopeRoot: homedir5() },
+    {
+      scope: "project",
+      scopeRoot: await resolveProjectRoot(path5.dirname(absPath))
+    }
+  ];
+  const locks = await Promise.all(
+    candidates.map(async (candidate) => ({
+      candidate,
+      lock: await readLockfile(candidate.scope, candidate.scopeRoot)
+    }))
+  );
+  for (const { candidate, lock } of locks) {
+    for (const [artifactId, entry] of Object.entries(lock.artifacts)) {
+      if (entry.files.map((file) => path5.resolve(file)).includes(absPath)) {
+        return { artifactId, entry, ...candidate };
+      }
+    }
+  }
+  return null;
+}
+function resolveLockPath(scopeRoot, lockedFile) {
+  const resolved = path5.isAbsolute(lockedFile) ? lockedFile : path5.resolve(scopeRoot, lockedFile);
+  const relative = path5.relative(scopeRoot, resolved);
+  const outside = relative !== "" && (relative.startsWith("..") || path5.isAbsolute(relative));
+  if (outside) {
+    console.info(
+      `${pc5.yellow("\u26A0")} skipped lock entry outside scope root: ${relativeDisplay(
+        resolved
+      )}`
+    );
+    return null;
+  }
+  return resolved;
+}
+async function updateUntouchedSiblings(input) {
+  const { scopeRoot } = input.match;
+  await Promise.all(
+    input.entry.files.map((lockedFile) => resolveLockPath(scopeRoot, lockedFile)).filter((siblingPath) => siblingPath !== null).filter((siblingPath) => siblingPath !== input.absPath).map((siblingPath) => updateUntouchedSibling(input, siblingPath))
+  );
+}
+async function updateUntouchedSibling(input, siblingPath) {
+  try {
+    const siblingContent = await readFile3(siblingPath, "utf8");
+    const siblingHash = sha256Hex(siblingContent);
+    if (siblingHash === input.match.entry.contentHash) {
+      await writeFile4(siblingPath, input.content, "utf8");
+      return;
+    }
+    if (siblingHash !== input.contentHash) {
+      console.info(
+        `${pc5.yellow("\u26A0")} left modified sibling unchanged: ${relativeDisplay(
+          siblingPath
+        )}`
+      );
+    }
+  } catch (error) {
+    if (!isNotFound3(error)) {
+      throw error;
+    }
+    console.info(
+      `${pc5.yellow("\u26A0")} left missing sibling unchanged: ${relativeDisplay(
+        siblingPath
+      )}`
+    );
+  }
+}
+function isNotFound3(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/commands/status.ts
+import { homedir as homedir6 } from "os";
+
+// src/lib/installer.ts
+import { mkdir as mkdir4, readFile as readFile4, rm as rm2, writeFile as writeFile5 } from "fs/promises";
+import path6 from "path";
+function flattenManifest(manifest) {
+  const artifactsById = /* @__PURE__ */ new Map();
+  for (const stack of manifest.stacks) {
+    for (const artifact of stack.artifacts) {
+      if (!artifactsById.has(artifact.id)) {
+        artifactsById.set(artifact.id, artifact);
+      }
+    }
+  }
+  return [...artifactsById.values()];
+}
+function planSync(input) {
+  const artifacts = flattenManifest(input.manifest);
+  const rawActions = artifacts.flatMap(
+    (artifact) => planArtifact(input, artifact)
+  );
+  if (input.prune) {
+    const currentTargetPaths = new Set(
+      targetPathsForManifest(
+        input.manifest,
+        input.agents,
+        input.scope,
+        input.scopeRoot
+      )
+    );
+    rawActions.push(
+      ...planPrune(
+        input,
+        new Set(artifacts.map((artifact) => artifact.id)),
+        currentTargetPaths
+      )
+    );
+  }
+  const claimedTargets = firstTargetClaims(rawActions);
+  const actions = [];
+  for (const action of rawActions) {
+    const claimedBy = claimedTargets.get(action.absPath);
+    if (claimedBy && claimedBy.id !== action.artifact.id) {
+      actions.push({
+        ...action,
+        conflictWith: claimedBy,
+        type: "skip-conflict"
+      });
+      continue;
+    }
+    actions.push(action);
+  }
+  return demoteModifiedSiblings(actions);
+}
+function demoteModifiedSiblings(actions) {
+  const modifiedIds = new Set(
+    actions.filter((action) => action.type === "skip-modified").map((action) => action.artifact.id)
+  );
+  if (modifiedIds.size === 0) {
+    return actions;
+  }
+  return actions.map((action) => {
+    if (modifiedIds.has(action.artifact.id) && (action.type === "install" || action.type === "update")) {
+      return { ...action, type: "skip-modified" };
+    }
+    return action;
+  });
+}
+function firstTargetClaims(actions) {
+  const claims = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    if (action.type === "prune" || claims.has(action.absPath)) {
+      continue;
+    }
+    claims.set(action.absPath, action.artifact);
+  }
+  return claims;
+}
+async function readFilesForPlan(paths) {
+  const entries = await Promise.all(
+    paths.map(async (filePath) => {
+      try {
+        return [filePath, await readFile4(filePath, "utf8")];
+      } catch (error) {
+        if (isNotFound4(error)) {
+          return [filePath, null];
+        }
+        throw error;
+      }
+    })
+  );
+  return Object.fromEntries(entries);
+}
+function targetPathsForManifest(manifest, agents2, scope, scopeRoot) {
+  return flattenManifest(manifest).flatMap(
+    (artifact) => resolveInstallPaths(artifact.kind, artifact.slug, agents2, scope).map(
+      (relativePath) => path6.join(scopeRoot, relativePath)
+    )
+  );
+}
+async function applyActions(actions, options) {
+  const summary = emptySummary();
+  const contentCache = /* @__PURE__ */ new Map();
+  await Promise.all(
+    actions.map(async (action) => {
+      if (action.type === "install" || action.type === "update") {
+        assertContained(options.scopeRoot, action.absPath);
+        const contentPromise = contentCache.get(action.artifact.id) ?? options.fetchContent(action.artifact);
+        contentCache.set(action.artifact.id, contentPromise);
+        await mkdir4(path6.dirname(action.absPath), { recursive: true });
+        await writeFile5(action.absPath, await contentPromise, "utf8");
+      }
+      if (action.type === "prune") {
+        assertContained(options.scopeRoot, action.absPath);
+        await pruneIfUnmodified(action);
+      }
+    })
+  );
+  for (const action of actions) {
+    summary[action.type] += 1;
+  }
+  return summary;
+}
+function emptySummary() {
+  return {
+    install: 0,
+    prune: 0,
+    "skip-conflict": 0,
+    "skip-modified": 0,
+    "up-to-date": 0,
+    update: 0
+  };
+}
+function mergeSummary(actions) {
+  const summary = emptySummary();
+  for (const action of actions) {
+    summary[action.type] += 1;
+  }
+  return summary;
+}
+function classifyAction(input) {
+  if (input.fileHash === null) {
+    return "install";
+  }
+  if (!input.previousHash) {
+    return input.fileHash === input.manifestHash ? "up-to-date" : "skip-modified";
+  }
+  if (input.fileHash !== input.previousHash) {
+    return input.force ? "update" : "skip-modified";
+  }
+  return input.manifestHash === input.previousHash ? "up-to-date" : "update";
+}
+function planArtifact(input, artifact) {
+  const previous = input.lock.artifacts[artifact.id];
+  const targetActions = resolveInstallPaths(
+    artifact.kind,
+    artifact.slug,
+    input.agents,
+    input.scope
+  ).map((relativePath) => {
+    const absPath = path6.join(input.scopeRoot, relativePath);
+    const content = input.filesOnDisk[absPath] ?? null;
+    const fileHash = content === null ? null : sha256Hex(content);
+    return {
+      absPath,
+      artifact,
+      previous,
+      type: classifyAction({
+        fileHash,
+        force: input.force ?? false,
+        manifestHash: artifact.contentHash,
+        previousHash: previous?.contentHash
+      })
+    };
+  });
+  if (!(input.prune && previous)) {
+    return targetActions;
+  }
+  const currentPaths = new Set(targetActions.map((action) => action.absPath));
+  const stalePruneActions = previous.files.filter((absPath) => !currentPaths.has(absPath)).map((absPath) => ({
+    absPath,
+    artifact,
+    previous,
+    type: pruneActionType(input.filesOnDisk[absPath], previous)
+  }));
+  return [...targetActions, ...stalePruneActions];
+}
+function planPrune(input, manifestIds, currentTargetPaths) {
+  return Object.entries(input.lock.artifacts).flatMap(([id, entry]) => {
+    if (manifestIds.has(id)) {
+      return [];
+    }
+    return entry.files.filter((absPath) => !currentTargetPaths.has(absPath)).map((absPath) => ({
+      absPath,
+      artifact: {
+        contentHash: entry.contentHash,
+        id,
+        kind: entry.kind,
+        path: entry.slug,
+        slug: entry.slug,
+        title: entry.slug,
+        version: entry.version
+      },
+      previous: entry,
+      type: pruneActionType(input.filesOnDisk[absPath], entry)
+    }));
+  });
+}
+function pruneActionType(content, entry) {
+  if (content === null || content === void 0) {
+    return "prune";
+  }
+  return sha256Hex(content) === entry.contentHash ? "prune" : "skip-modified";
+}
+async function pruneIfUnmodified(action) {
+  if (!action.previous) {
+    return;
+  }
+  try {
+    const content = await readFile4(action.absPath, "utf8");
+    if (sha256Hex(content) !== action.previous.contentHash) {
+      return;
+    }
+    await rm2(action.absPath);
+  } catch (error) {
+    if (!isNotFound4(error)) {
+      throw error;
+    }
+  }
+}
+function assertContained(scopeRoot, absPath) {
+  const relative = path6.relative(scopeRoot, absPath);
+  if (relative === "" || !(relative.startsWith("..") || path6.isAbsolute(relative))) {
+    return;
+  }
+  throw new Error(
+    `Refusing to write outside sync scope: ${absPath} is not under ${scopeRoot}`
+  );
+}
+function isNotFound4(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/lib/output.ts
+import pc6 from "picocolors";
+function printError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(pc6.red(`\u2716 ${message}`));
+}
+function enabledAgents(agents2) {
+  return Object.keys(agents2).filter(
+    (agent) => agents2[agent]
+  );
+}
+function printPlan(actions) {
+  for (const action of actions) {
+    const prefix = prefixForAction(action.type);
+    const conflict = action.conflictWith ? ` (conflicts with ${action.conflictWith.slug})` : "";
+    console.info(
+      `${prefix} ${action.type.padEnd(13)} ${action.artifact.slug} -> ${action.absPath}${conflict}`
+    );
+  }
+}
+function prefixForAction(type) {
+  switch (type) {
+    case "install":
+      return pc6.green("\u2713");
+    case "update":
+      return pc6.cyan("\u2191");
+    case "up-to-date":
+      return pc6.dim("\u2261");
+    case "skip-modified":
+      return pc6.yellow("\u26A0");
+    case "skip-conflict":
+      return pc6.yellow("\u26A0");
+    case "prune":
+      return pc6.red("\u2212");
+    default:
+      return "";
+  }
+}
+
+// src/commands/status.ts
+async function statusCommand(options) {
+  const config = await loadConfig();
+  if (!config.apiKey) {
+    throw new Error(
+      `Invalid or missing API key - run \`${cliCommand("login")}\``
+    );
+  }
+  const scope = options.project ? "project" : "global";
+  const scopeRoot = options.project ? await resolveProjectRoot() : homedir6();
+  const agents2 = enabledAgents(config.agents);
+  const manifest = await createApiClient(
+    config.baseUrl,
+    config.apiKey
+  ).manifest();
+  const lock = await readLockfile(scope, scopeRoot);
+  const targetPaths = targetPathsForManifest(
+    manifest,
+    agents2,
+    scope,
+    scopeRoot
+  );
+  const filesOnDisk = await readFilesForPlan(targetPaths);
+  const actions = planSync({
+    agents: agents2,
+    filesOnDisk,
+    lock,
+    manifest,
+    scope,
+    scopeRoot
+  });
+  const rows = actions.map((action) => ({
+    kind: action.artifact.kind,
+    path: action.absPath,
+    slug: action.artifact.slug,
+    state: statusForAction(action),
+    version: action.artifact.version
+  }));
+  if (options.json) {
+    console.info(JSON.stringify(rows, null, 2));
+    return;
+  }
+  for (const row of rows) {
+    console.info(
+      `${row.slug.padEnd(24)} ${row.kind.padEnd(8)} v${String(row.version).padEnd(4)} ${row.state}`
+    );
+  }
+}
+function statusForAction(action) {
+  switch (action.type) {
+    case "install":
+      return "missing";
+    case "skip-modified":
+      return "modified";
+    case "skip-conflict":
+      return "modified";
+    case "update":
+      return "outdated";
+    case "up-to-date":
+      return "synced";
+    case "prune":
+      return "outdated";
+    default:
+      return "modified";
+  }
+}
+
+// src/commands/sync.ts
+import { homedir as homedir7 } from "os";
+import pc7 from "picocolors";
+async function syncCommand(options) {
+  const config = await loadConfig();
+  if (!config.apiKey) {
+    throw new Error(
+      `Invalid or missing API key - run \`${cliCommand("login")}\``
+    );
+  }
+  const scope = options.project ? "project" : "global";
+  const scopeRoot = options.project ? await resolveProjectRoot() : homedir7();
+  const agents2 = enabledAgents(config.agents);
+  const api = createApiClient(config.baseUrl, config.apiKey);
+  const manifest = await api.manifest();
+  const lock = await readLockfile(scope, scopeRoot);
+  const targetPaths = targetPathsForManifest(
+    manifest,
+    agents2,
+    scope,
+    scopeRoot
+  );
+  const prunePaths = options.prune ? Object.values(lock.artifacts).flatMap((entry) => entry.files) : [];
+  const filesOnDisk = await readFilesForPlan([...targetPaths, ...prunePaths]);
+  const actions = planSync({
+    agents: agents2,
+    filesOnDisk,
+    force: options.force,
+    lock,
+    manifest,
+    prune: options.prune,
+    scope,
+    scopeRoot
+  });
+  if (options.dryRun) {
+    const summary2 = mergeSummary(actions);
+    if (options.json) {
+      console.info(JSON.stringify({ actions, summary: summary2 }, null, 2));
+    } else {
+      printPlan(actions);
+      printSummary(summary2);
+    }
+    return;
+  }
+  const summary = await applyActions(actions, {
+    fetchContent: async (artifact) => (await api.artifact(artifact.id, artifact.version)).content,
+    scopeRoot
+  });
+  await writeLockfile(scope, scopeRoot, nextLock(lock, actions));
+  if (options.json) {
+    console.info(JSON.stringify({ actions, summary }, null, 2));
+    return;
+  }
+  printSummary(summary);
+  const skipped = actions.filter((action) => action.type === "skip-modified");
+  for (const action of skipped) {
+    console.info(
+      `${pc7.yellow("\u26A0")} skipped locally modified ${relativeDisplay(action.absPath)}`
+    );
+  }
+  if (skipped.length > 0) {
+    console.info(
+      `Run \`${cliCommand("push <path>")}\` to publish, or \`${cliCommand(
+        "sync --force"
+      )}\`.`
+    );
+  }
+  const conflicts = actions.filter((action) => action.type === "skip-conflict");
+  for (const action of conflicts) {
+    console.info(
+      `${pc7.yellow("\u26A0")} skipped path conflict for ${action.artifact.slug} at ${relativeDisplay(action.absPath)}`
+    );
+  }
+}
+function nextLock(lock, actions) {
+  const next = {
+    artifacts: { ...lock.artifacts }
+  };
+  const actionsByArtifact = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    actionsByArtifact.set(action.artifact.id, [
+      ...actionsByArtifact.get(action.artifact.id) || [],
+      action
+    ]);
+  }
+  for (const [artifactId, artifactActions] of actionsByArtifact) {
+    if (artifactActions.some(
+      (action) => action.type === "skip-modified" || action.type === "skip-conflict"
+    )) {
+      continue;
+    }
+    const targetActions = artifactActions.filter(
+      (action) => action.type === "install" || action.type === "update" || action.type === "up-to-date"
+    );
+    if (targetActions.length === 0) {
+      delete next.artifacts[artifactId];
+      continue;
+    }
+    const artifact = targetActions[0].artifact;
+    next.artifacts[artifactId] = {
+      contentHash: artifact.contentHash,
+      files: targetActions.map((action) => action.absPath),
+      kind: artifact.kind,
+      slug: artifact.slug,
+      version: artifact.version
+    };
+  }
+  return next;
+}
+function printSummary(summary) {
+  console.info(
+    [
+      `${pc7.green("\u2713")} installed ${summary.install}`,
+      `${pc7.cyan("\u2191")} updated ${summary.update}`,
+      `${pc7.dim("\u2261")} up-to-date ${summary["up-to-date"]}`,
+      `${pc7.yellow("\u26A0")} skipped ${summary["skip-modified"]}`,
+      `${pc7.yellow("\u26A0")} conflicts ${summary["skip-conflict"]}`,
+      `${pc7.red("\u2212")} pruned ${summary.prune}`
+    ].join("\n")
+  );
+}
+
+// src/commands/whoami.ts
+import pc8 from "picocolors";
+async function whoamiCommand() {
+  const config = await loadConfig();
+  if (!config.apiKey) {
+    throw new Error(`Not logged in - run \`${cliCommand("login")}\``);
+  }
+  const me = await createApiClient(config.baseUrl, config.apiKey).me();
+  console.info(`${pc8.green("\u2713")} ${me.user.slug} <${me.user.email}>`);
+}
+
+// src/index.ts
+var knownCommands = /* @__PURE__ */ new Set([
+  "add",
+  "agents",
+  "help",
+  "login",
+  "logout",
+  "push",
+  "status",
+  "sync",
+  "whoami"
+]);
+var packageJson = JSON.parse(
+  readFileSync(
+    path7.join(path7.dirname(fileURLToPath(import.meta.url)), "../package.json"),
+    "utf8"
+  )
+);
+var program = new Command();
+program.name("impulse").description("Sync versioned skills, commands and agent configs").version(packageJson.version).exitOverride();
+program.command("login").option("--key <key>", "API key").option("--url <baseUrl>", "Impulse Directory base URL").action(wrap(loginCommand));
+program.command("logout").action(wrap(logoutCommand));
+program.command("whoami").action(wrap(whoamiCommand));
+program.command("sync").option("--project", "sync project-scoped targets").option("--prune", "remove locked files no longer in the manifest").option("--force", "overwrite locally modified files").option("--dry-run", "print planned changes without writing files").option("--json", "print machine-readable output").action(wrap(syncCommand));
+program.command("status").option("--project", "check project-scoped targets").option("--json", "print machine-readable output").action(wrap(statusCommand));
+program.command("push").argument("<path>", "file to publish").option("-m, --message <changelog>", "version changelog").action(wrap((filePath, options) => pushCommand(filePath, options)));
+var add = program.command("add").argument("<owner/slug>", "artifact path or 'stack'").argument("[id]", "stack id").option("-t, --target <legacy-target>", "legacy installation target").action(
+  wrap(
+    (identifier, id, options) => identifier === "stack" ? addStackCommand(required(id, "Missing stack id"), options) : addCommand(identifier, options)
+  )
+);
+add.command("stack").argument("<id>", "stack id").option("-t, --target <legacy-target>", "legacy installation target").action(wrap(addStackCommand));
+var agents = program.command("agents").action(wrap(listAgentsCommand));
+agents.command("enable").argument("<agent>", "claude, codex or cursor").action(wrap((agent) => updateAgentCommand("enable", agent)));
+agents.command("disable").argument("<agent>", "claude, codex or cursor").action(wrap((agent) => updateAgentCommand("disable", agent)));
+rewriteLegacyArgv(process.argv);
+try {
+  await program.parseAsync(process.argv);
+} catch (error) {
+  if (isCommanderHelp(error)) {
+    process.exitCode = 0;
+  } else {
+    printError(error);
+    process.exitCode = 1;
+  }
+}
+function rewriteLegacyArgv(argv) {
+  const first = argv[2];
+  if (!first || first.startsWith("-") || knownCommands.has(first)) {
+    return;
+  }
+  if (first.includes("/") || first === "stack") {
+    argv.splice(2, 0, "add");
+  }
+}
+function wrap(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      printError(error);
+      process.exitCode = 1;
+    }
+  };
+}
+function required(value, message) {
+  if (!value) {
+    throw new Error(message);
+  }
+  return value;
+}
+function isCommanderHelp(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "commander.helpDisplayed" || error.code === "commander.version");
+}