lshed 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.0 — 2026-09-02
+
+First working release. Claude Code only.
+
+- `init` scans `~/.claude` (skills, agents, commands, CLAUDE.md) into a shed and writes `lshed.yaml`
+- `restore <profile>` with managed-set semantics, backups on by default, `--dry-run`
+- `status`, `diff`, `save`
+- Instructions are assembled as an `@`-import list, not merged
+- `file:` sources only; `github:` is parsed but rejected until 0.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 leesongheon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,138 @@
+# lshed
+
+Keep your coding-agent harness — skills, subagents, commands, instructions — in a **shed**, and restore it on any machine with one command.
+
+```
+lshed init --shed ~/lshed          # scan ~/.claude into a shed + write lshed.yaml
+lshed restore research             # apply a profile anywhere
+```
+
+The shed is a plain directory. Put it in a git repo, Dropbox, whatever. lshed does not sync it for you.
+
+## Why
+
+Every new laptop, server, container or WSL box means setting up `~/.claude` again. dotfiles tools move **files**; they don't know what a skill, an agent or an instruction fragment is, they can't compose a subset per machine, and they can't tell which parts they placed and which were yours.
+
+lshed adds three first-class ideas on top of "a directory in git":
+
+| Idea | What it gives you |
+|---|---|
+| **Components** | every skill / agent / command / instruction fragment is one named part in the shed |
+| **Profiles** | named recipes — `research`, `work`, `minimal` — that pick a subset of parts |
+| **Managed set** | lshed remembers what it placed, so switching profiles removes only its own files and never touches yours |
+
+Currently supports **Claude Code** (`~/.claude`). Other agents plug in through an adapter.
+
+## Install
+
+```
+npm install -g lshed
+```
+
+Node 20 or newer.
+
+## Quick start
+
+```bash
+# 1. On the machine that already has your setup
+lshed init --shed ~/lshed
+cd ~/lshed && git init && git add -A && git commit -m "my harness" && git remote add origin <your private repo> && git push -u origin main
+
+# 2. Edit ~/lshed/lshed.yaml — add profiles, drop parts you don't need everywhere
+
+# 3. On any other machine
+git clone <your private repo> ~/lshed
+lshed restore research --shed ~/lshed      # --shed only needed the first time
+```
+
+## The manifest
+
+`lshed.yaml` lives at the root of the shed. `init` generates it; edit it by hand from then on.
+
+```yaml
+version: 1
+agent: claude-code
+
+components:
+  skills:
+    - id: paper-review            # source defaults to file:./skills/paper-review
+    - id: grading-helper
+  agents:
+    - id: reviewer                # file:./agents/reviewer.md
+  commands:
+    - id: summarize
+  instructions:
+    - id: base                    # file:./instructions/base.md
+    - id: research-style
+
+profiles:
+  research:
+    skills: [paper-review]
+    agents: [reviewer]
+    instructions: [base, research-style]    # order matters
+  teaching:
+    skills: [grading-helper]
+    commands: [summarize]
+    instructions: [base]
+```
+
+- `source` accepts `file:<path relative to the shed>`. `github:owner/repo@ref` is parsed and reserved for a future release; using it today is an error, not silent misbehaviour.
+- Category names come from the adapter. For Claude Code: `skills`, `agents`, `commands`, `instructions`.
+- Instructions are not merged. `restore` writes a `CLAUDE.md` that `@`-imports each fragment in order, so a fragment edit shows up without re-running anything. Your original `CLAUDE.md` is backed up the first time.
+
+## Commands
+
+```
+lshed init [--shed <dir>] [--profile <name>]   scan the current environment into a shed
+lshed restore [profile] [--dry-run] [--no-backup]
+lshed status                                    applied profile, managed paths, drift
+lshed diff                                      files that differ between local and shed
+lshed save [ids...]                             copy local edits back into the shed
+```
+
+Global options: `--shed <dir>` (or `LSHED_HOME`; after the first restore lshed remembers it), `--root <dir>` (agent config root, default `~/.claude`).
+
+### What `restore` does
+
+1. Removes paths that the **previous** profile placed and the new one doesn't need.
+2. Copies every part of the new profile into place.
+3. Regenerates the instructions file.
+
+Anything it overwrites or removes is backed up first under `~/.claude/lshed/backups/<timestamp>/`, unless you pass `--no-backup`. Files lshed never placed are left alone. `--dry-run` prints the plan and writes nothing.
+
+### Ownership
+
+The shed is the source of truth. `save` copies local edits back for `file:` parts only. Remote parts will be read-only and refreshed with `update` once remote sources land.
+
+## Where things live
+
+```
+<shed>/
+  lshed.yaml
+  skills/<id>/            agents/<id>.md        commands/<id>.md        instructions/<id>.md
+
+~/.claude/
+  skills/ agents/ commands/ CLAUDE.md           ← placed by restore
+  lshed/state.json                              ← which profile, which paths are managed
+  lshed/instructions/<id>.md                    ← fragments imported by CLAUDE.md
+  lshed/backups/<timestamp>/                    ← whatever restore replaced
+```
+
+`state.json` is per machine and is not part of the shed.
+
+## Not in scope (yet)
+
+- MCP servers and secrets. Planned: the manifest names the keys, values are injected locally, nothing secret enters the shed.
+- `settings.json` merging (hooks, permissions).
+- Remote sources (`github:`), lock file, `update`, `list --unused`, `prune`.
+- Windows and macOS have not been tested. The code avoids platform-specific paths, but treat 0.1 as Linux/WSL.
+
+## Troubleshooting
+
+- **"창고 위치를 모릅니다"** — pass `--shed <dir>` or set `LSHED_HOME`. After one successful `restore`, lshed remembers it.
+- **restore replaced my `CLAUDE.md`** — it is in `~/.claude/lshed/backups/<timestamp>/CLAUDE.md`. Move its content into a fragment in the shed and add that fragment to your profile.
+- **I edited a skill locally and want to keep it** — `lshed diff` to see, `lshed save <id>` to push it into the shed, then commit the shed.
+
+## License
+
+MIT

package/dist/cli.js

@@ -0,0 +1,605 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import { createRequire } from "module";
+import os2 from "os";
+import path9 from "path";
+
+// src/adapters/claude-code.ts
+import { promises as fs } from "fs";
+import path from "path";
+import os from "os";
+var CATEGORIES = [
+  { name: "skills", root: "skills", kind: "dir" },
+  { name: "agents", root: "agents", kind: "file" },
+  { name: "commands", root: "commands", kind: "file" }
+  // instructions 는 단일 파일(CLAUDE.md)이라 스캔 대상이 아니라 생성 대상이다 (§3.3)
+];
+var ClaudeCodeAdapter = class {
+  name = "claude-code";
+  root;
+  constructor(root) {
+    this.root = root ?? path.join(os.homedir(), ".claude");
+  }
+  categories() {
+    return CATEGORIES;
+  }
+  instructionsStrategy() {
+    return "import";
+  }
+  instructionsFileName() {
+    return "CLAUDE.md";
+  }
+  async scan() {
+    const out = [];
+    for (const cat of CATEGORIES) {
+      const dir = path.join(this.root, cat.root);
+      let entries;
+      try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const e of entries) {
+        if (e.name.startsWith(".")) continue;
+        if (cat.kind === "dir" && e.isDirectory()) {
+          out.push({ category: cat.name, id: e.name, path: path.join(dir, e.name) });
+        } else if (cat.kind === "file" && e.isFile() && e.name.endsWith(".md")) {
+          out.push({ category: cat.name, id: e.name.slice(0, -3), path: path.join(dir, e.name) });
+        }
+      }
+    }
+    return out;
+  }
+};
+
+// src/core/init.ts
+import { promises as fs5 } from "fs";
+import path7 from "path";
+
+// src/core/context.ts
+import { promises as fs3 } from "fs";
+import path4 from "path";
+
+// src/manifest.ts
+import { z } from "zod";
+import YAML from "yaml";
+
+// src/source.ts
+var GITHUB_RE = /^([\w.-]+)\/([\w.-]+)(?:@([^#]+))?(?:#(.+))?$/;
+function parseSource(raw) {
+  const idx = raw.indexOf(":");
+  if (idx <= 0) {
+    throw new Error(`source\uC5D0 \uC2A4\uD0B4\uC774 \uC5C6\uC2B5\uB2C8\uB2E4: "${raw}" (\uC608: file:./skills/x, github:user/repo@v1)`);
+  }
+  const scheme = raw.slice(0, idx);
+  const rest = raw.slice(idx + 1);
+  switch (scheme) {
+    case "file":
+      if (!rest) throw new Error(`file: \uB4A4\uC5D0 \uACBD\uB85C\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4: "${raw}"`);
+      return { scheme, path: rest };
+    case "github": {
+      const m = GITHUB_RE.exec(rest);
+      if (!m) throw new Error(`github: \uD615\uC2DD\uC774 \uC544\uB2D9\uB2C8\uB2E4: "${raw}" (\uC608: github:user/repo@v1.0#sub/path)`);
+      const [, owner, repo, ref, subpath] = m;
+      return { scheme, owner, repo, ref, subpath };
+    }
+    default:
+      throw new Error(`\uC54C \uC218 \uC5C6\uB294 \uC2A4\uD0B4 "${scheme}": "${raw}"`);
+  }
+}
+
+// src/manifest.ts
+var ComponentSchema = z.object({
+  id: z.string().regex(/^[\w.-]+$/, "id\uB294 \uC601\uBB38\xB7\uC22B\uC790\xB7._- \uB9CC \uD5C8\uC6A9"),
+  source: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var ComponentsSchema = z.record(z.string(), z.array(ComponentSchema));
+var ProfileSchema = z.record(z.string(), z.array(z.string()));
+var ManifestSchema = z.object({
+  version: z.literal(1),
+  agent: z.string().default("claude-code"),
+  components: ComponentsSchema.default({}),
+  profiles: z.record(z.string(), ProfileSchema).default({})
+});
+var ManifestError = class extends Error {
+};
+function parseManifest(text, knownCategories2) {
+  const raw = YAML.parse(text);
+  const result = ManifestSchema.safeParse(raw);
+  if (!result.success) {
+    const lines = result.error.issues.map((i) => `  ${i.path.join(".") || "(root)"}: ${i.message}`);
+    throw new ManifestError(`lshed.yaml \uD615\uC2DD \uC624\uB958:
+${lines.join("\n")}`);
+  }
+  const m = result.data;
+  const problems = [];
+  for (const [cat, comps] of Object.entries(m.components)) {
+    if (knownCategories2 && !knownCategories2.includes(cat)) {
+      problems.push(`\uC54C \uC218 \uC5C6\uB294 \uCE74\uD14C\uACE0\uB9AC "${cat}" (\uC5B4\uB311\uD130 ${m.agent}: ${knownCategories2.join(", ")})`);
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const c of comps) {
+      if (seen.has(c.id)) problems.push(`${cat}: id "${c.id}" \uC911\uBCF5`);
+      seen.add(c.id);
+      try {
+        parseSource(effectiveSource(cat, c));
+      } catch (e) {
+        problems.push(`${cat}/${c.id}: ${e.message}`);
+      }
+    }
+  }
+  for (const [profile, cats] of Object.entries(m.profiles)) {
+    for (const [cat, ids] of Object.entries(cats)) {
+      const available = new Set((m.components[cat] ?? []).map((c) => c.id));
+      for (const id of ids) {
+        if (!available.has(id)) problems.push(`profiles.${profile}.${cat}: "${id}" \uB294 components\uC5D0 \uC5C6\uC74C`);
+      }
+    }
+  }
+  if (problems.length) throw new ManifestError(`lshed.yaml \uCC38\uC870 \uC624\uB958:
+${problems.map((p) => "  " + p).join("\n")}`);
+  return m;
+}
+function effectiveSource(category, c, kind = "dir") {
+  return c.source ?? `file:./${category}/${c.id}${kind === "file" ? ".md" : ""}`;
+}
+function stringifyManifest(m) {
+  return YAML.stringify(m, { lineWidth: 0 });
+}
+
+// src/resolvers/file.ts
+import path2 from "path";
+function resolveSource(shed, raw) {
+  const s = parseSource(raw);
+  if (s.scheme === "file") return path2.resolve(shed, s.path);
+  throw new Error(`"${raw}": ${s.scheme}: \uCD9C\uCC98\uB294 v0.2\uC5D0\uC11C \uC9C0\uC6D0\uB429\uB2C8\uB2E4. \uC9C0\uAE08\uC740 file: \uB9CC \uC0AC\uC6A9\uD560 \uC218 \uC788\uC2B5\uB2C8\uB2E4.`);
+}
+function isSaveable(raw) {
+  return parseSource(raw).scheme === "file";
+}
+
+// src/state.ts
+import { promises as fs2 } from "fs";
+import path3 from "path";
+import { z as z2 } from "zod";
+var StateSchema = z2.object({
+  profile: z2.string(),
+  shed: z2.string(),
+  /** 어댑터 루트 기준 상대 경로 (POSIX 구분자). lshed가 놓은 것만. */
+  managed: z2.array(z2.string()),
+  appliedAt: z2.string()
+});
+var LSHED_DIR = "lshed";
+function statePath(adapter) {
+  return path3.join(adapter.root, LSHED_DIR, "state.json");
+}
+async function readState(adapter) {
+  try {
+    const raw = JSON.parse(await fs2.readFile(statePath(adapter), "utf8"));
+    return StateSchema.parse(raw);
+  } catch (e) {
+    if (e.code === "ENOENT") return null;
+    throw new Error(`state.json \uC744 \uC77D\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4 (${statePath(adapter)}): ${e.message}`);
+  }
+}
+async function writeState(adapter, state) {
+  const p = statePath(adapter);
+  await fs2.mkdir(path3.dirname(p), { recursive: true });
+  await fs2.writeFile(p, JSON.stringify(state, null, 2) + "\n");
+}
+
+// src/core/context.ts
+var MANIFEST_FILE = "lshed.yaml";
+var INSTRUCTIONS = "instructions";
+var FRAGMENTS_DIR = `${LSHED_DIR}/instructions`;
+function manifestPath(ctx) {
+  return path4.join(ctx.shed, MANIFEST_FILE);
+}
+function knownCategories(adapter) {
+  return [...adapter.categories().map((c) => c.name), INSTRUCTIONS];
+}
+async function loadManifest(ctx) {
+  let text;
+  try {
+    text = await fs3.readFile(manifestPath(ctx), "utf8");
+  } catch {
+    throw new Error(`\uCC3D\uACE0\uC5D0 ${MANIFEST_FILE} \uC774 \uC5C6\uC2B5\uB2C8\uB2E4: ${ctx.shed}
+  \uBA3C\uC800 'lshed init --shed ${ctx.shed}' \uB97C \uC2E4\uD589\uD558\uC138\uC694.`);
+  }
+  return parseManifest(text, knownCategories(ctx.adapter));
+}
+function targetRel(cat, id) {
+  if (cat === INSTRUCTIONS) return `${FRAGMENTS_DIR}/${id}.md`;
+  return cat.kind === "dir" ? `${cat.root}/${id}` : `${cat.root}/${id}.md`;
+}
+function sourcePath(ctx, category, c) {
+  const cat = ctx.adapter.categories().find((k) => k.name === category);
+  const kind = category === INSTRUCTIONS ? "file" : cat?.kind ?? "dir";
+  return resolveSource(ctx.shed, effectiveSource(category, c, kind));
+}
+function findComponent(m, category, id) {
+  const c = (m.components[category] ?? []).find((x) => x.id === id);
+  if (!c) throw new Error(`${category}/${id} \uB294 components \uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4`);
+  return c;
+}
+function planProfile(ctx, m, profile) {
+  const p = m.profiles[profile];
+  if (!p) {
+    const names = Object.keys(m.profiles);
+    throw new Error(`\uD504\uB85C\uD544 "${profile}" \uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uC788\uB294 \uD504\uB85C\uD544: ${names.length ? names.join(", ") : "(\uC5C6\uC74C)"}`);
+  }
+  const items = [];
+  for (const [category, ids] of Object.entries(p)) {
+    const cat = category === INSTRUCTIONS ? INSTRUCTIONS : ctx.adapter.categories().find((k) => k.name === category);
+    if (!cat) throw new Error(`\uD504\uB85C\uD544 "${profile}": \uC5B4\uB311\uD130 ${ctx.adapter.name} \uC740 \uCE74\uD14C\uACE0\uB9AC "${category}" \uB97C \uBAA8\uB985\uB2C8\uB2E4`);
+    for (const id of ids) {
+      const component = findComponent(m, category, id);
+      items.push({ category, id, rel: targetRel(cat, id), src: sourcePath(ctx, category, component), component });
+    }
+  }
+  return items;
+}
+function abs(ctx, rel) {
+  return path4.join(ctx.adapter.root, ...rel.split("/"));
+}
+
+// src/fsutil.ts
+import { promises as fs4 } from "fs";
+import { createHash } from "crypto";
+import path5 from "path";
+async function exists(p) {
+  try {
+    await fs4.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function isDir(p) {
+  try {
+    return (await fs4.stat(p)).isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function listFiles(root) {
+  if (!await exists(root)) return [];
+  if (!await isDir(root)) return [""];
+  const out = [];
+  async function walk(dir, rel) {
+    const entries = await fs4.readdir(dir, { withFileTypes: true });
+    for (const e of entries) {
+      const r = rel ? `${rel}/${e.name}` : e.name;
+      if (e.isDirectory()) await walk(path5.join(dir, e.name), r);
+      else if (e.isFile()) out.push(r);
+    }
+  }
+  await walk(root, "");
+  return out.sort();
+}
+async function hashFile(p) {
+  return createHash("sha256").update(await fs4.readFile(p)).digest("hex");
+}
+async function hashTree(root) {
+  if (!await exists(root)) return null;
+  const h = createHash("sha256");
+  for (const rel of await listFiles(root)) {
+    h.update(rel).update("\0").update(await fs4.readFile(rel ? path5.join(root, rel) : root)).update("\0");
+  }
+  return h.digest("hex");
+}
+async function copyTree(src, dst) {
+  await fs4.rm(dst, { recursive: true, force: true });
+  await fs4.mkdir(path5.dirname(dst), { recursive: true });
+  await fs4.cp(src, dst, { recursive: true });
+}
+async function removeTree(p) {
+  await fs4.rm(p, { recursive: true, force: true });
+}
+async function diffTrees(local, shed) {
+  const l = new Set(await listFiles(local));
+  const s = new Set(await listFiles(shed));
+  const out = [];
+  for (const f of [.../* @__PURE__ */ new Set([...l, ...s])].sort()) {
+    const lp = f ? path5.join(local, f) : local;
+    const sp = f ? path5.join(shed, f) : shed;
+    if (l.has(f) && !s.has(f)) out.push({ status: "A", file: f });
+    else if (!l.has(f) && s.has(f)) out.push({ status: "D", file: f });
+    else if (await hashFile(lp) !== await hashFile(sp)) out.push({ status: "M", file: f });
+  }
+  return out;
+}
+
+// src/core/instructions.ts
+import path6 from "path";
+var MARKER = "<!-- generated by lshed";
+function instructionsFile(ctx) {
+  return path6.join(ctx.adapter.root, ctx.adapter.instructionsFileName());
+}
+function isGenerated(text) {
+  return text.trimStart().startsWith(MARKER);
+}
+function renderInstructions(ctx, profile, fragments) {
+  const head = `${MARKER}; profile: ${profile} -->
+<!-- Do not edit this file. Edit the fragments in your shed and run 'lshed restore'. -->
+
+`;
+  if (ctx.adapter.instructionsStrategy() === "import") {
+    return head + fragments.map((f) => `@${FRAGMENTS_DIR}/${f.id}.md`).join("\n") + "\n";
+  }
+  return head + fragments.map((f) => `<!-- ${f.id} -->
+${f.content.trimEnd()}
+`).join("\n");
+}
+
+// src/core/init.ts
+async function init(ctx, opts = {}) {
+  const profileName = opts.profile ?? "default";
+  if (await exists(manifestPath(ctx))) {
+    throw new Error(`\uC774\uBBF8 \uCD08\uAE30\uD654\uB41C \uCC3D\uACE0\uC785\uB2C8\uB2E4: ${manifestPath(ctx)}
+  \uB2E4\uB978 \uD658\uACBD\uC758 \uC124\uC815\uC744 \uC774 \uCC3D\uACE0\uB85C \uAC00\uC838\uC624\uB824\uBA74 'lshed restore' \uD6C4 'lshed save' \uB97C \uC4F0\uC138\uC694.`);
+  }
+  const found = await ctx.adapter.scan();
+  const m = { version: 1, agent: ctx.adapter.name, components: {}, profiles: { [profileName]: {} } };
+  const managed = [];
+  let copied = 0;
+  for (const cat of ctx.adapter.categories()) {
+    const mine = found.filter((f) => f.category === cat.name);
+    if (!mine.length) continue;
+    m.components[cat.name] = [];
+    m.profiles[profileName][cat.name] = [];
+    for (const f of mine) {
+      const dst = path7.join(ctx.shed, cat.root, cat.kind === "dir" ? f.id : `${f.id}.md`);
+      await copyTree(f.path, dst);
+      m.components[cat.name].push({ id: f.id });
+      m.profiles[profileName][cat.name].push(f.id);
+      managed.push(targetRel(cat, f.id));
+      copied++;
+      ctx.log(`  + ${cat.name}/${f.id}`);
+    }
+  }
+  const instr = instructionsFile(ctx);
+  if (await exists(instr)) {
+    const text = await fs5.readFile(instr, "utf8");
+    if (!isGenerated(text)) {
+      const dst = path7.join(ctx.shed, INSTRUCTIONS, "main.md");
+      await fs5.mkdir(path7.dirname(dst), { recursive: true });
+      await fs5.writeFile(dst, text);
+      const fragRel = targetRel(INSTRUCTIONS, "main");
+      await copyTree(dst, abs(ctx, fragRel));
+      managed.push(fragRel);
+      m.components[INSTRUCTIONS] = [{ id: "main" }];
+      m.profiles[profileName][INSTRUCTIONS] = ["main"];
+      copied++;
+      ctx.log(`  + ${INSTRUCTIONS}/main  (${path7.basename(instr)})`);
+    }
+  }
+  await fs5.mkdir(ctx.shed, { recursive: true });
+  await fs5.writeFile(manifestPath(ctx), `# lshed manifest \u2014 edit freely. Reference: https://github.com/LeeSongHeon-LSH/lshed
+` + stringifyManifest(m));
+  await writeState(ctx.adapter, { profile: profileName, shed: ctx.shed, managed, appliedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  ctx.log(`
+${MANIFEST_FILE} \uC0DD\uC131: ${manifestPath(ctx)}  (\uBD80\uD488 ${copied}\uAC1C, \uD504\uB85C\uD544 "${profileName}")`);
+  return { manifest: m, copied };
+}
+
+// src/core/restore.ts
+import { promises as fs6 } from "fs";
+import path8 from "path";
+async function restore(ctx, profileArg, opts = {}) {
+  const backup = opts.backup ?? true;
+  const state = await readState(ctx.adapter);
+  const profile = profileArg ?? state?.profile;
+  if (!profile) throw new Error("\uD504\uB85C\uD544\uC744 \uC9C0\uC815\uD558\uC138\uC694: lshed restore <profile>  (\uC774\uC804\uC5D0 \uC801\uC6A9\uD55C \uD504\uB85C\uD544\uC774 \uC5C6\uC2B5\uB2C8\uB2E4)");
+  const m = await loadManifest(ctx);
+  const plan = planProfile(ctx, m, profile);
+  for (const it of plan) {
+    if (!await exists(it.src)) throw new Error(`${it.category}/${it.id}: \uCC3D\uACE0\uC5D0 \uD30C\uC77C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4: ${it.src}`);
+  }
+  const instrRel = ctx.adapter.instructionsFileName();
+  const fragments = plan.filter((p) => p.category === INSTRUCTIONS);
+  const newManaged = new Set(plan.map((p) => p.rel));
+  if (fragments.length) newManaged.add(instrRel);
+  const oldManaged = new Set(state?.managed ?? []);
+  const toRemove = [...oldManaged].filter((r) => !newManaged.has(r)).sort();
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  const backupDir = path8.join(ctx.adapter.root, LSHED_DIR, "backups", stamp);
+  const backedUp = [];
+  const placed = [];
+  async function backUp(rel) {
+    const from = abs(ctx, rel);
+    if (!await exists(from)) return;
+    backedUp.push(rel);
+    if (opts.dryRun || !backup) return;
+    await copyTree(from, path8.join(backupDir, ...rel.split("/")));
+  }
+  for (const rel of toRemove) {
+    ctx.log(`  - ${rel}`);
+    await backUp(rel);
+    if (!opts.dryRun) await removeTree(abs(ctx, rel));
+  }
+  for (const it of plan) {
+    const target = abs(ctx, it.rel);
+    const same = await hashTree(target) === await hashTree(it.src);
+    const mark = same ? "=" : await exists(target) ? "~" : "+";
+    ctx.log(`  ${mark} ${it.rel}`);
+    if (same) {
+      placed.push(it.rel);
+      continue;
+    }
+    if (await exists(target)) await backUp(it.rel);
+    if (!opts.dryRun) await copyTree(it.src, target);
+    placed.push(it.rel);
+  }
+  const instrPath = instructionsFile(ctx);
+  if (fragments.length) {
+    const contents = [];
+    for (const f of fragments) contents.push({ id: f.id, content: await fs6.readFile(f.src, "utf8") });
+    const rendered = renderInstructions(ctx, profile, contents);
+    const existing = await exists(instrPath) ? await fs6.readFile(instrPath, "utf8") : null;
+    if (existing !== rendered) {
+      const mark = existing === null ? "+" : "~";
+      ctx.log(`  ${mark} ${instrRel}${existing !== null && !isGenerated(existing) ? "  (\uAE30\uC874 \uD30C\uC77C\uC740 lshed \uC0DD\uC131\uBB3C\uC774 \uC544\uB2D8 \u2192 \uBC31\uC5C5)" : ""}`);
+      if (existing !== null) await backUp(instrRel);
+      if (!opts.dryRun) await fs6.writeFile(instrPath, rendered);
+    } else {
+      ctx.log(`  = ${instrRel}`);
+    }
+    placed.push(instrRel);
+  }
+  if (opts.dryRun) {
+    ctx.log(`
+(dry-run) \uBCC0\uACBD \uC5C6\uC74C. \uBC30\uCE58 ${placed.length}, \uC81C\uAC70 ${toRemove.length}, \uBC31\uC5C5 \uC608\uC815 ${backedUp.length}`);
+    return { profile, placed, removed: toRemove, backedUp, backupDir: null };
+  }
+  await writeState(ctx.adapter, { profile, shed: ctx.shed, managed: [...newManaged].sort(), appliedAt: (/* @__PURE__ */ new Date()).toISOString() });
+  const bdir = backup && backedUp.length ? backupDir : null;
+  ctx.log(`
+\uD504\uB85C\uD544 "${profile}" \uC801\uC6A9: \uBC30\uCE58 ${placed.length}, \uC81C\uAC70 ${toRemove.length}${bdir ? `, \uBC31\uC5C5 ${backedUp.length} \u2192 ${bdir}` : ""}`);
+  return { profile, placed, removed: toRemove, backedUp, backupDir: bdir };
+}
+
+// src/core/diff.ts
+async function diff(ctx) {
+  const state = await readState(ctx.adapter);
+  if (!state) throw new Error("\uC801\uC6A9\uB41C \uD504\uB85C\uD544\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 'lshed restore <profile>' \uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+  const m = await loadManifest(ctx);
+  const out = [];
+  for (const item of planProfile(ctx, m, state.profile)) {
+    const changes = await diffTrees(abs(ctx, item.rel), item.src);
+    if (changes.length) out.push({ item, changes });
+  }
+  return out;
+}
+function formatDiff(diffs) {
+  if (!diffs.length) return "\uB85C\uCEEC\uACFC \uCC3D\uACE0\uAC00 \uC77C\uCE58\uD569\uB2C8\uB2E4.";
+  const lines = [];
+  for (const d of diffs) {
+    lines.push(`${d.item.category}/${d.item.id}`);
+    for (const c of d.changes) lines.push(`  ${c.status} ${c.file || "(file)"}`);
+  }
+  lines.push("", "A: \uB85C\uCEEC\uC5D0\uB9CC \uC788\uC74C  M: \uB0B4\uC6A9 \uB2E4\uB984  D: \uCC3D\uACE0\uC5D0\uB9CC \uC788\uC74C", "\uB85C\uCEEC \uD3B8\uC9D1\uC744 \uCC3D\uACE0\uC5D0 \uBC18\uC601\uD558\uB824\uBA74: lshed save");
+  return lines.join("\n");
+}
+
+// src/core/status.ts
+async function status(ctx) {
+  const state = await readState(ctx.adapter);
+  if (!state) return { state: null, drifted: [] };
+  const d = await diff(ctx);
+  return { state, drifted: d.map((x) => `${x.item.category}/${x.item.id}`) };
+}
+function formatStatus(s, adapterRoot) {
+  if (!s.state) return `\uC801\uC6A9\uB41C \uD504\uB85C\uD544\uC774 \uC5C6\uC2B5\uB2C8\uB2E4 (${adapterRoot}).
+  lshed init --shed <dir>   \uB610\uB294   lshed restore <profile>`;
+  const lines = [
+    `\uD504\uB85C\uD544   ${s.state.profile}`,
+    `\uCC3D\uACE0     ${s.state.shed}`,
+    `\uC801\uC6A9     ${s.state.appliedAt}`,
+    `\uAD00\uB9AC \uC911  ${s.state.managed.length}\uAC1C \uACBD\uB85C (${adapterRoot})`
+  ];
+  lines.push(s.drifted.length ? `\uB4DC\uB9AC\uD504\uD2B8 ${s.drifted.length}\uAC1C: ${s.drifted.join(", ")}  \u2192 lshed diff` : "\uB4DC\uB9AC\uD504\uD2B8 \uC5C6\uC74C");
+  return lines.join("\n");
+}
+
+// src/core/save.ts
+async function save(ctx, ids = []) {
+  const state = await readState(ctx.adapter);
+  if (!state) throw new Error("\uC801\uC6A9\uB41C \uD504\uB85C\uD544\uC774 \uC5C6\uC2B5\uB2C8\uB2E4. \uBA3C\uC800 'lshed restore <profile>' \uC744 \uC2E4\uD589\uD558\uC138\uC694.");
+  const m = await loadManifest(ctx);
+  let plan = planProfile(ctx, m, state.profile);
+  if (ids.length) {
+    plan = ids.map((raw) => {
+      const [a, b] = raw.includes("/") ? raw.split("/", 2) : [void 0, raw];
+      const hits = plan.filter((p) => p.id === b && (a === void 0 || p.category === a));
+      if (!hits.length) throw new Error(`"${raw}" \uB294 \uD604\uC7AC \uD504\uB85C\uD544(${state.profile})\uC5D0 \uC5C6\uC2B5\uB2C8\uB2E4`);
+      if (hits.length > 1) throw new Error(`"${raw}" \uAC00 \uBAA8\uD638\uD569\uB2C8\uB2E4: ${hits.map((h) => `${h.category}/${h.id}`).join(", ")}`);
+      return hits[0];
+    });
+  }
+  const saved = [];
+  for (const it of plan) {
+    const kind = it.category === INSTRUCTIONS ? "file" : ctx.adapter.categories().find((c) => c.name === it.category).kind;
+    const src = effectiveSource(it.category, it.component, kind);
+    if (!isSaveable(src)) {
+      ctx.log(`  ! ${it.category}/${it.id}: \uC6D0\uACA9 \uCD9C\uCC98(${src})\uB294 save \uD560 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4`);
+      continue;
+    }
+    const local = abs(ctx, it.rel);
+    if (!await exists(local)) {
+      ctx.log(`  ! ${it.category}/${it.id}: \uB85C\uCEEC\uC5D0 \uC5C6\uC74C (\uAC74\uB108\uB700)`);
+      continue;
+    }
+    if (await hashTree(local) === await hashTree(it.src)) continue;
+    await copyTree(local, it.src);
+    saved.push(`${it.category}/${it.id}`);
+    ctx.log(`  \u2713 ${it.category}/${it.id} \u2192 \uCC3D\uACE0`);
+  }
+  ctx.log(saved.length ? `
+${saved.length}\uAC1C \uBC18\uC601. \uCC3D\uACE0\uB97C \uCEE4\uBC0B/\uB3D9\uAE30\uD654\uD558\uC138\uC694: ${ctx.shed}` : "\uBC18\uC601\uD560 \uBCC0\uACBD\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.");
+  return saved;
+}
+
+// src/cli.ts
+var { version } = createRequire(import.meta.url)("../package.json");
+var program = new Command().name("lshed").description("Keep your coding-agent harness (skills, agents, commands, instructions) in a shed and restore it anywhere by profile.").version(version).option("--shed <dir>", "shed directory (default: $LSHED_HOME, then the shed recorded by the last restore)").option("--root <dir>", "agent config root (default: ~/.claude)");
+function adapterFromOpts() {
+  const { root } = program.opts();
+  return new ClaudeCodeAdapter(root ? path9.resolve(root) : void 0);
+}
+async function ctxFor(cmd) {
+  const adapter = adapterFromOpts();
+  const { shed: flag } = program.opts();
+  let shed = flag ?? process.env.LSHED_HOME;
+  if (!shed && cmd === "other") shed = (await readState(adapter))?.shed;
+  if (!shed && cmd === "init") shed = path9.join(os2.homedir(), "lshed");
+  if (!shed) throw new Error("\uCC3D\uACE0 \uC704\uCE58\uB97C \uBAA8\uB985\uB2C8\uB2E4. --shed <dir> \uB610\uB294 LSHED_HOME \uC744 \uC9C0\uC815\uD558\uC138\uC694.");
+  return { adapter, shed: path9.resolve(shed), log: (l) => console.log(l) };
+}
+async function run(fn) {
+  try {
+    await fn();
+  } catch (e) {
+    console.error(`\uC624\uB958: ${e.message}`);
+    process.exitCode = 1;
+  }
+}
+program.command("init").description("scan the current environment into a shed and write lshed.yaml").option("--profile <name>", "name of the initial profile", "default").action((o) => run(async () => {
+  const ctx = await ctxFor("init");
+  console.log(`\uC2A4\uCE94: ${ctx.adapter.root}  \u2192  \uCC3D\uACE0: ${ctx.shed}`);
+  await init(ctx, { profile: o.profile });
+  console.log(`
+\uB2E4\uC74C: \uCC3D\uACE0\uB97C git \uC73C\uB85C \uAD00\uB9AC\uD558\uC138\uC694.  cd ${ctx.shed} && git init`);
+}));
+program.command("restore [profile]").description("apply a profile (defaults to the last applied one)").option("--dry-run", "print what would change without touching anything").option("--no-backup", "skip backing up files that get replaced or removed").action((profile, o) => run(async () => {
+  const ctx = await ctxFor("other");
+  await restore(ctx, profile, { dryRun: o.dryRun, backup: o.backup });
+}));
+program.command("status").description("show the applied profile, managed paths and drift").action(() => run(async () => {
+  const adapter = adapterFromOpts();
+  const state = await readState(adapter);
+  if (!state) {
+    console.log(formatStatus({ state: null, drifted: [] }, adapter.root));
+    return;
+  }
+  const ctx = await ctxFor("other");
+  console.log(formatStatus(await status(ctx), adapter.root));
+}));
+program.command("diff").description("list files that differ between the local harness and the shed").action(() => run(async () => {
+  const ctx = await ctxFor("other");
+  console.log(formatDiff(await diff(ctx)));
+}));
+program.command("save [ids...]").description("copy local edits back into the shed (file: sources only)").action((ids) => run(async () => {
+  const ctx = await ctxFor("other");
+  await save(ctx, ids);
+}));
+program.command("scan").description("(debug) list components found in the agent config root").action(() => run(async () => {
+  const adapter = adapterFromOpts();
+  const found = await adapter.scan();
+  for (const c of found) console.log(`${c.category}/${c.id}	${c.path}`);
+  console.error(`${found.length}\uAC1C \uBC1C\uACAC (root: ${adapter.root})`);
+}));
+program.parseAsync();

package/package.json

@@ -1,13 +1,59 @@
 {
   "name": "lshed",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "description": "Portable harness environment manager for coding agents",
-  "main": "index.js",
+  "license": "MIT",
+  "author": "leesongheon <leesongheon1209@gmail.com>",
+  "type": "module",
+  "bin": {
+    "lshed": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsup",
+    "dev": "tsx src/cli.ts",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
   },
-  "keywords": [],
-  "author": "",
-  "license": "MIT",
-  "type": "commonjs"
+  "keywords": [
+    "claude-code",
+    "harness",
+    "dotfiles",
+    "skills",
+    "mcp",
+    "cli"
+  ],
+  "dependencies": {
+    "commander": "^15.0.0",
+    "yaml": "^2.9.0",
+    "zod": "^4.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "tsup": "^8.5.1",
+    "tsx": "^4.23.13",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.11"
+  },
+  "allowScripts": {
+    "esbuild@0.27.7": true,
+    "esbuild@0.28.2": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LeeSongHeon-LSH/lshed.git"
+  },
+  "homepage": "https://github.com/LeeSongHeon-LSH/lshed#readme",
+  "bugs": {
+    "url": "https://github.com/LeeSongHeon-LSH/lshed/issues"
+  }
 }