spacecode 2.3.0 → 2.4.0

package/dist/repl.mjs

@@ -5031,6 +5031,11 @@ function createProfileClient({ baseUrl, apiKey, fetch: doFetch, timeoutMs = 8e3
         throw err;
       }
     },
+    /** Asks the server-side classifier to decide keep/on_demand/drop per section (see adapt-plan.ts). */
+    async adapt(sections) {
+      const res = await call("POST", "/adapt", { body: { sections } });
+      return await res.json();
+    },
     async put(kind, name, input) {
       const res = await call("PUT", `/assets/${enc(kind)}/${enc(name)}`, {
         body: { content: input.content, description: input.description ?? "", base_version: input.baseVersion }
@@ -5174,6 +5179,222 @@ var init_profile_loader = __esm({
   }
 });
 
+// ../agent/src/import/instruction-sections.ts
+function slugify(title, taken) {
+  const base = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "section";
+  let slug = base;
+  for (let n = 2; taken.has(slug); n++) slug = `${base}-${n}`;
+  taken.add(slug);
+  return slug;
+}
+function splitSections(text) {
+  const lines2 = text.split("\n");
+  const starts = [];
+  let fence = null;
+  lines2.forEach((line, i) => {
+    const m2 = /^\s*(```+|~~~+)/.exec(line);
+    if (m2) {
+      if (fence === null) fence = m2[1][0];
+      else if (m2[1][0] === fence) fence = null;
+      return;
+    }
+    if (fence === null && /^## \S/.test(line)) starts.push(i);
+  });
+  if (starts.length === 0) return { preamble: text, sections: [] };
+  const taken = /* @__PURE__ */ new Set();
+  const sections = starts.map((start, k2) => {
+    const end = k2 + 1 < starts.length ? starts[k2 + 1] : lines2.length;
+    const chunk = lines2.slice(start, end).join("\n") + (end < lines2.length ? "\n" : "");
+    const title = lines2[start].slice(3).trim();
+    return { title, slug: slugify(title, taken), text: chunk };
+  });
+  const preamble = starts[0] === 0 ? "" : lines2.slice(0, starts[0]).join("\n") + "\n";
+  return { preamble, sections };
+}
+var init_instruction_sections = __esm({
+  "../agent/src/import/instruction-sections.ts"() {
+    "use strict";
+  }
+});
+
+// ../agent/src/import/tool-names.ts
+function translateToolNames(text) {
+  const counts = /* @__PURE__ */ new Map();
+  const names = Object.keys(TOOL_NAME_MAP).join("|");
+  const re3 = new RegExp("`(" + names + ")(\\([^`)]*\\))?`", "g");
+  const out = text.replace(re3, (_m, name, args) => {
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+    return "`" + TOOL_NAME_MAP[name] + (args ?? "") + "`";
+  });
+  return { text: out, replaced: [...counts].map(([from, count]) => ({ from, to: TOOL_NAME_MAP[from], count })) };
+}
+function findUnsupported(text) {
+  return UNSUPPORTED.filter((u3) => u3.re.test(text)).map((u3) => u3.label);
+}
+var TOOL_NAME_MAP, UNSUPPORTED;
+var init_tool_names = __esm({
+  "../agent/src/import/tool-names.ts"() {
+    "use strict";
+    TOOL_NAME_MAP = {
+      Read: "read_file",
+      Write: "write_file",
+      Edit: "edit_file",
+      MultiEdit: "edit_file",
+      Glob: "list_directory",
+      Grep: "search",
+      Bash: "bash",
+      TodoWrite: "todo_write"
+    };
+    UNSUPPORTED = [
+      { label: "hooks", re: /\bhooks?\b.*\.(sh|json)|\bPreToolUse\b|\bPostToolUse\b|\bSessionStart\b|\bUserPromptSubmit\b/i },
+      { label: "ToolSearch / deferred tools", re: /\bToolSearch\b|deferred tools?/i },
+      { label: "Claude Code's Task/subagent tools", re: /\bsubagents?\b|\bAgent tool\b|`Task`|subagent_type/i },
+      { label: "Claude Code skills / slash commands", re: /\bSkill tool\b|invoke (?:the )?\w+ skill|\/ship\b|\/handoff\b/i },
+      { label: "MCP tool names (mcp__*)", re: /\bmcp__[A-Za-z0-9_-]+/ },
+      { label: "WebFetch/WebSearch/NotebookEdit tools", re: /`(?:WebFetch|WebSearch|NotebookEdit)`/ },
+      { label: "plan mode / worktree tools", re: /\bEnterPlanMode\b|\bExitPlanMode\b|\bEnterWorktree\b/ }
+    ];
+  }
+});
+
+// ../agent/src/import/coverage.ts
+function extractRuleLines(text) {
+  const out = [];
+  let fence = false;
+  for (const line of text.split("\n")) {
+    if (/^\s*(```|~~~)/.test(line)) {
+      fence = !fence;
+      continue;
+    }
+    if (fence) continue;
+    const n = norm(line);
+    if (n !== "" && RULE_RE.test(n)) out.push(n);
+  }
+  return out;
+}
+function checkCoverage(original, kept, dropped) {
+  const haystack = norm(kept.join("\n"));
+  const droppedHay = norm(dropped.join("\n"));
+  const missing = [];
+  const droppedRules = [];
+  for (const rule of new Set(extractRuleLines(original))) {
+    if (haystack.includes(rule)) continue;
+    if (droppedHay.includes(rule)) droppedRules.push(rule);
+    else missing.push(rule);
+  }
+  return { ok: missing.length === 0, missing, droppedRules };
+}
+var RULE_RE, norm;
+var init_coverage = __esm({
+  "../agent/src/import/coverage.ts"() {
+    "use strict";
+    RULE_RE = /\b(MUST|NEVER|ALWAYS|IMPORTANT|CRITICAL|MANDATORY|DO NOT)\b|\b(never|must not|do not|don't|mandatory)\b/i;
+    norm = (s) => s.replace(/[*_`]/g, "").replace(/\s+/g, " ").trim();
+  }
+});
+
+// ../agent/src/import/adapt-plan.ts
+function prepareAdaptation(original) {
+  const split = splitSections(original);
+  const replaced = /* @__PURE__ */ new Map();
+  const tr = (t) => {
+    const r = translateToolNames(t);
+    for (const x2 of r.replaced) {
+      const cur = replaced.get(x2.from);
+      replaced.set(x2.from, { from: x2.from, to: x2.to, count: (cur?.count ?? 0) + x2.count });
+    }
+    return r.text;
+  };
+  const preamble = tr(split.preamble);
+  const sections = split.sections.map((s) => {
+    const text = tr(s.text);
+    return { slug: s.slug, title: s.title, chars: text.length, unsupported: findUnsupported(text), text };
+  });
+  return { preamble, sections, replaced: [...replaced.values()] };
+}
+function applyPlan(input, decisions, maxCoreChars = MAX_CORE_CHARS) {
+  const bySlug = new Map(input.sections.map((s) => [s.slug, s]));
+  const seen = /* @__PURE__ */ new Set();
+  for (const d of decisions) {
+    if (!bySlug.has(d.slug)) throw new AdaptPlanError(`plan names unknown section "${d.slug}"`);
+    if (seen.has(d.slug)) throw new AdaptPlanError(`plan decides section "${d.slug}" twice`);
+    seen.add(d.slug);
+    if (d.decision === "drop" && !(d.reason && d.reason.trim())) throw new AdaptPlanError(`dropped section "${d.slug}" has no reason`);
+    if (d.decision === "on_demand" && !(d.summary && d.summary.trim())) throw new AdaptPlanError(`on-demand section "${d.slug}" has no summary`);
+  }
+  const missing = input.sections.filter((s) => !seen.has(s.slug)).map((s) => s.slug);
+  if (missing.length > 0) throw new AdaptPlanError(`plan does not decide section(s): ${missing.join(", ")}`);
+  const kept = [];
+  const onDemand = [];
+  const dropped = [];
+  const index = [];
+  for (const d of decisions) {
+    const s = bySlug.get(d.slug);
+    if (d.decision === "keep") kept.push(s.text);
+    else if (d.decision === "on_demand") {
+      onDemand.push({ slug: s.slug, title: s.title, text: s.text });
+      index.push(`- ${s.slug}: ${s.title} \u2014 ${d.summary.trim().replace(/\s+/g, " ")}`);
+    } else dropped.push({ slug: s.slug, title: s.title, reason: d.reason.trim(), unsupported: s.unsupported });
+  }
+  const indexBlock = index.length > 0 ? `
+## More instructions (on demand)
+Use the instructions_read tool with a section name to read one before acting in that area:
+${index.join("\n")}
+` : "";
+  const core = input.preamble + kept.join("") + indexBlock;
+  if (core.length > maxCoreChars) throw new AdaptPlanError(`core is ${core.length} chars, over the ${maxCoreChars} budget: demote larger sections to on_demand`);
+  const translated = input.preamble + input.sections.map((s) => s.text).join("");
+  const coverage = checkCoverage(translated, [core, ...onDemand.map((o) => o.text)], dropped.map((d) => bySlug.get(d.slug).text));
+  return { core, onDemand, dropped, coverage, coreChars: core.length };
+}
+var AdaptPlanError, MAX_CORE_CHARS;
+var init_adapt_plan = __esm({
+  "../agent/src/import/adapt-plan.ts"() {
+    "use strict";
+    init_instruction_sections();
+    init_tool_names();
+    init_coverage();
+    AdaptPlanError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "AdaptPlanError";
+      }
+    };
+    MAX_CORE_CHARS = 6e3;
+  }
+});
+
+// ../agent/src/import/instructions-tool.ts
+function createInstructionsReadTool(client) {
+  return async (input) => {
+    const name = typeof input.name === "string" ? input.name.trim().toLowerCase() : "";
+    if (!SAFE2.test(name)) return { output: 'instructions_read needs a "name" from the on-demand list, e.g. "cloudflare-auth"', is_error: true };
+    try {
+      const asset = await client.get("instructions", `global.sec.${name}`);
+      if (!asset) return { output: `No instructions section "${name}". Use a name from the on-demand list.`, is_error: true };
+      return { output: asset.content };
+    } catch (err) {
+      return { output: `instructions_read failed: ${err instanceof Error ? err.message : String(err)}`, is_error: true };
+    }
+  };
+}
+var INSTRUCTIONS_READ_TOOL, SAFE2;
+var init_instructions_tool = __esm({
+  "../agent/src/import/instructions-tool.ts"() {
+    "use strict";
+    INSTRUCTIONS_READ_TOOL = {
+      name: "instructions_read",
+      description: `Read one on-demand section of the user's imported instructions by its name (listed under "More instructions (on demand)" in your instructions). Read the relevant section before working in that area; these are the user's standing rules.`,
+      input_schema: {
+        type: "object",
+        properties: { name: { type: "string", description: 'The section name exactly as listed, e.g. "cloudflare-auth".' } },
+        required: ["name"]
+      }
+    };
+    SAFE2 = /^[a-z0-9-]{1,40}$/;
+  }
+});
+
 // ../agent/src/index.ts
 var init_src = __esm({
   "../agent/src/index.ts"() {
@@ -5206,6 +5427,11 @@ var init_src = __esm({
     init_profile_prompt();
     init_memory_tool();
     init_profile_loader();
+    init_instruction_sections();
+    init_tool_names();
+    init_coverage();
+    init_adapt_plan();
+    init_instructions_tool();
   }
 });
 
@@ -5296,15 +5522,19 @@ async function prepareProfileUnsafe(deps) {
   if (!result.profile) return EMPTY([`profile: not loaded (${result.error ?? "unknown error"})`]);
   const key = result.profile.projectKey;
   const hasMemory = result.profile.memoryIndex !== null && key !== null;
+  const hasSections = result.profile.instructions?.includes("## More instructions (on demand)") ?? false;
   const section2 = buildProfileSection({ instructions: result.profile.instructions, memoryIndex: result.profile.memoryIndex, hasMemoryTool: hasMemory });
   const lines2 = [
-    `profile: v${result.profile.version} ${result.source === "cache" ? "(STALE: served from cache)" : "(live)"}${result.profile.instructions ? ", instructions" : ""}${hasMemory ? `, memory "${key}"` : ""}${section2.truncated ? ", TRUNCATED to fit the prompt budget" : ""}`
+    `profile: v${result.profile.version} ${result.source === "cache" ? "(STALE: served from cache)" : "(live)"}${result.profile.instructions ? ", instructions" : ""}${hasSections ? ", adapted (on-demand sections)" : ""}${hasMemory ? `, memory "${key}"` : ""}${section2.truncated ? ", TRUNCATED to fit the prompt budget" : ""}`
   ];
   if (result.error) lines2.push(`profile warning: ${result.error}`);
   return {
     promptSection: section2.text,
-    tools: hasMemory ? [MEMORY_READ_TOOL] : [],
-    handlers: hasMemory ? { memory_read: createMemoryReadTool(client, key) } : {},
+    tools: [...hasMemory ? [MEMORY_READ_TOOL] : [], ...hasSections ? [INSTRUCTIONS_READ_TOOL] : []],
+    handlers: {
+      ...hasMemory ? { memory_read: createMemoryReadTool(client, key) } : {},
+      ...hasSections ? { instructions_read: createInstructionsReadTool(client) } : {}
+    },
     statusLines: lines2
   };
 }
@@ -5319,6 +5549,98 @@ var init_profile_runtime = __esm({
   }
 });
 
+// src/import-adapt.ts
+async function sha12(text) {
+  const d = await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text));
+  return [...new Uint8Array(d)].slice(0, 6).map((b2) => b2.toString(16).padStart(2, "0")).join("");
+}
+function formatAdaptReport(r, before, replaced) {
+  const lines2 = [`Adapted instructions: ${before} chars -> core ${r.coreChars} chars + ${r.onDemand.length} on-demand section(s), ${r.dropped.length} dropped.`];
+  for (const x2 of replaced) lines2.push(`  tool name  ${x2.from} -> ${x2.to} (${x2.count}x)`);
+  for (const o of r.onDemand) lines2.push(`  on demand  ${o.slug}  (${o.text.length} chars)`);
+  for (const d of r.dropped) lines2.push(`  DROPPED    ${d.slug}: ${d.reason}${d.unsupported.length ? `  [${d.unsupported.join("; ")}]` : ""}`);
+  if (r.coverage.droppedRules.length > 0) {
+    lines2.push(`  ${r.coverage.droppedRules.length} rule line(s) exist only in dropped sections:`);
+    for (const rule of r.coverage.droppedRules.slice(0, 12)) lines2.push(`    - ${rule.slice(0, 140)}`);
+    if (r.coverage.droppedRules.length > 12) lines2.push(`    ... and ${r.coverage.droppedRules.length - 12} more`);
+  }
+  return lines2;
+}
+async function adaptInstructions(deps, original) {
+  const { client, log } = deps;
+  const hash = await sha12(original);
+  const current = await client.get("instructions", "global");
+  const marker = adaptedMarker(hash);
+  const existingOrig = await client.get("instructions", "global.orig");
+  if (current && existingOrig && existingOrig.content === original && current.description === marker) {
+    log("  unchanged  instructions/global (already adapted from this source)");
+    return true;
+  }
+  const input = prepareAdaptation(original);
+  if (input.sections.length === 0) {
+    log('  adapt: no "## " sections found, storing the file as is');
+    return false;
+  }
+  let decisions;
+  let model;
+  try {
+    const res = await client.adapt(input.sections.map((s) => ({ slug: s.slug, title: s.title, chars: s.chars, unsupported: s.unsupported, excerpt: s.text.slice(0, EXCERPT_CHARS) })));
+    decisions = res.decisions;
+    model = res.model;
+  } catch (err) {
+    log(`  ADAPT FAILED  ${err instanceof ProfileApiError || err instanceof Error ? err.message : String(err)}; the unadapted instructions will be imported instead`);
+    return false;
+  }
+  let result;
+  try {
+    result = applyPlan(input, decisions);
+  } catch (err) {
+    if (!(err instanceof AdaptPlanError)) throw err;
+    log(`  ADAPT REJECTED  ${err.message}; the unadapted instructions will be imported instead`);
+    return false;
+  }
+  if (!result.coverage.ok) {
+    log(`  ADAPT REJECTED  ${result.coverage.missing.length} rule line(s) would be lost, e.g.:`);
+    for (const m2 of result.coverage.missing.slice(0, 5)) log(`    - ${m2.slice(0, 140)}`);
+    log("  The unadapted instructions will be imported instead.");
+    return false;
+  }
+  log(`  classifier model: ${model}`);
+  for (const l of formatAdaptReport(result, original.length, input.replaced)) log(l);
+  if (!deps.assumeYes && !await deps.confirm("Store the adapted instructions?")) {
+    log("  Not stored (declined or no terminal; use --yes to skip the question). The unadapted instructions will be imported instead.");
+    return false;
+  }
+  await client.put("instructions", "global.orig", { content: original, description: "Original CLAUDE.md (never loaded into the prompt)", baseVersion: existingOrig?.version ?? 0 });
+  for (const s of result.onDemand) {
+    const existing = await client.get("instructions", `global.sec.${s.slug}`);
+    await client.put("instructions", `global.sec.${s.slug}`, { content: s.text, description: s.title.slice(0, 200), baseVersion: existing?.version ?? 0 });
+  }
+  await client.put("instructions", "global", { content: result.core, description: marker, baseVersion: current?.version ?? 0 });
+  log(`  imported   instructions/global (adapted: core + ${result.onDemand.length} section(s)); original kept as instructions/global.orig`);
+  return true;
+}
+async function restoreOriginal(client, log) {
+  const orig = await client.get("instructions", "global.orig");
+  if (!orig) {
+    log("No stored original to restore (nothing was adapted).");
+    return false;
+  }
+  const current = await client.get("instructions", "global");
+  await client.put("instructions", "global", { content: orig.content, description: "Global CLAUDE.md", baseVersion: current?.version ?? 0 });
+  log("Restored the original instructions as instructions/global.");
+  return true;
+}
+var EXCERPT_CHARS, adaptedMarker;
+var init_import_adapt = __esm({
+  "src/import-adapt.ts"() {
+    "use strict";
+    init_src();
+    EXCERPT_CHARS = 1e3;
+    adaptedMarker = (hash) => `adapted-from:${hash}`;
+  }
+});
+
 // src/import-claude.ts
 var import_claude_exports = {};
 __export(import_claude_exports, {
@@ -5326,7 +5648,7 @@ __export(import_claude_exports, {
 });
 async function runImportClaude(deps) {
   const flags = deps.argv.filter((a) => a !== "import-claude");
-  const unknown = flags.filter((f) => f !== "--dry-run" && f !== "--overwrite");
+  const unknown = flags.filter((f) => !["--dry-run", "--overwrite", "--adapt", "--yes", "--restore-original"].includes(f));
   if (unknown.length > 0) {
     deps.log(`Unknown option: ${unknown.join(" ")}
 ${USAGE}`);
@@ -5334,6 +5656,26 @@ ${USAGE}`);
   }
   const dryRun = flags.includes("--dry-run");
   const overwrite = flags.includes("--overwrite");
+  const adapt = flags.includes("--adapt");
+  const restore = flags.includes("--restore-original");
+  if (restore && (adapt || dryRun)) {
+    deps.log(`--restore-original cannot be combined with --adapt or --dry-run
+${USAGE}`);
+    return 2;
+  }
+  if (restore) {
+    const apiKey2 = await resolveApiKey({ env: deps.env, readFile: deps.readFile, homedir: deps.homedir });
+    if (!apiKey2) {
+      deps.log("Not signed in. Run `spacecode login` first.");
+      return 1;
+    }
+    try {
+      return await restoreOriginal(createProfileClient({ baseUrl: backendUrl(deps.env), apiKey: apiKey2, fetch: deps.fetch }), deps.log) ? 0 : 1;
+    } catch (err) {
+      deps.log(`FAILED  ${err instanceof Error ? err.message : String(err)}`);
+      return 1;
+    }
+  }
   const root = await deps.gitRoot();
   const projectDirs = root && root !== deps.cwd ? [deps.cwd, root] : [deps.cwd];
   const report = await readClaudeAssets({ fs: deps.fs, home: deps.homedir(), projectDirs });
@@ -5360,7 +5702,18 @@ ${USAGE}`);
   let skipped = 0;
   for (const a of report.assets) {
     try {
+      if (adapt && a.kind === "instructions" && a.name === "global") {
+        if (await adaptInstructions({ client, log: deps.log, confirm: deps.confirm, assumeYes: flags.includes("--yes") }, a.content)) {
+          imported++;
+          continue;
+        }
+      }
       const existing = await client.get(a.kind, a.name);
+      if (existing && existing.description === adaptedMarker(await sha12(a.content))) {
+        skipped++;
+        deps.log(`  unchanged  ${a.kind}/${a.name} (adapted from this source)`);
+        continue;
+      }
       if (existing && existing.content === a.content) {
         skipped++;
         deps.log(`  unchanged  ${a.kind}/${a.name}`);
@@ -5390,7 +5743,8 @@ var init_import_claude = __esm({
     init_src();
     init_api_key();
     init_profile_runtime();
-    USAGE = "Usage: spacecode import-claude [--dry-run] [--overwrite]";
+    init_import_adapt();
+    USAGE = "Usage: spacecode import-claude [--dry-run] [--overwrite] [--adapt [--yes]] [--restore-original]";
   }
 });
 
@@ -101630,7 +101984,17 @@ if (process.argv[2] === "import-claude") {
     cwd: process.cwd(),
     gitRoot,
     fetch,
-    log: (line) => console.log(line)
+    log: (line) => console.log(line),
+    confirm: async (question) => {
+      if (!process.stdin.isTTY) return false;
+      const { createInterface } = await import("node:readline/promises");
+      const rl = createInterface({ input: process.stdin, output: process.stdout });
+      try {
+        return /^y(es)?$/i.test((await rl.question(`${question} [y/N] `)).trim());
+      } finally {
+        rl.close();
+      }
+    }
   });
   process.exit(code);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spacecode",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "SpaceCode - launch cloud dev environments with AI coding agents",
   "license": "MIT",
   "type": "commonjs",