aicsync 0.1.0__py3-none-any.whl

aics/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

aics/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

aics/bundle.py

@@ -0,0 +1,180 @@
+import hashlib
+import json
+import shutil
+import tarfile
+from pathlib import Path
+
+from .config import CLAUDE_DIR, CURSOR_DIR
+from .render import now_iso, host, render_markdown
+from .sanitize import sanitize
+from .scan import scan_claude, scan_cursor
+
+_c = {
+    "reset": "0",
+    "bold": "1",
+    "dim": "2",
+    "red": "31",
+    "green": "32",
+    "yellow": "33",
+    "blue": "34",
+    "magenta": "35",
+    "cyan": "36",
+    "gray": "90",
+}
+
+
+def sha256_file(p: Path):
+    h = hashlib.sha256()
+    with open(p, "rb") as f:
+        for chunk in iter(lambda: f.read(65536), b""):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def copy_dir(src: Path, dst: Path):
+    if not src.exists():
+        return []
+    copied = []
+    dst.mkdir(parents=True, exist_ok=True)
+    for item in src.iterdir():
+        if item.name.startswith("."):
+            continue
+        target = dst / item.name
+        if item.is_dir():
+            shutil.copytree(item, target, dirs_exist_ok=True)
+            for f in target.rglob("*"):
+                if f.is_file():
+                    copied.append(str(f.relative_to(dst.parent.parent)))
+        else:
+            shutil.copy2(item, target)
+            copied.append(str(target.relative_to(dst.parent.parent)))
+    return copied
+
+
+def export_bundle(out_dir: Path, include_secrets=False):
+    claude = scan_claude()
+    cursor = scan_cursor()
+    csettings, cred = sanitize(claude["settings"], include_secrets)
+    cursor_settings, rred = sanitize(cursor["settings"], include_secrets)
+    claude["settings"] = csettings
+    cursor["settings"] = cursor_settings
+    redacted = cred + rred
+
+    out_dir.mkdir(parents=True, exist_ok=True)
+    assets = out_dir / "assets"
+    asset_files = []
+    for kind in ("skills", "commands", "agents"):
+        asset_files += copy_dir(CLAUDE_DIR / kind, assets / "claude" / kind)
+    asset_files += copy_dir(CURSOR_DIR / "rules", assets / "cursor" / "rules")
+
+    (out_dir / "claude_mcp.json").write_text(
+        json.dumps(
+            {
+                "global": claude["mcpServers"],
+                "projects": claude["projects"],
+                "settings": csettings,
+                "plugins": claude["plugins"],
+                "enabledPlugins": claude["enabledPlugins"],
+            },
+            indent=2,
+            ensure_ascii=False,
+        )
+    )
+    (out_dir / "cursor_config.json").write_text(
+        json.dumps(
+            {"mcp": cursor["mcp"], "settings": cursor_settings, "extensions": cursor["extensions"]},
+            indent=2,
+            ensure_ascii=False,
+        )
+    )
+    (out_dir / "INSTALL.md").write_text(render_markdown(claude, cursor, redacted, guide=True))
+
+    manifest = {
+        "tool": "aics",
+        "version": 1,
+        "exportedAt": now_iso(),
+        "sourceHost": host(),
+        "clients": ["claude", "cursor"],
+        "redacted": redacted,
+        "assets": asset_files,
+        "counts": {
+            "claude": {
+                "mcp": len(claude["mcpServers"]),
+                "plugins": len(claude["plugins"]),
+                "skills": len(claude["skills"]),
+                "commands": len(claude["commands"]),
+                "agents": len(claude["agents"]),
+            },
+            "cursor": {
+                "mcp": len(cursor["mcp"]),
+                "rules": len(cursor["rules"]),
+                "extensions": len(cursor["extensions"]),
+            },
+        },
+    }
+    (out_dir / "manifest.json").write_text(json.dumps(manifest, indent=2, ensure_ascii=False))
+    return manifest
+
+
+def make_tar(bundle_dir: Path) -> Path:
+    tar_path = bundle_dir.parent / f"{bundle_dir.name}.tar.gz"
+    with tarfile.open(tar_path, "w:gz") as tar:
+        tar.add(bundle_dir, arcname=bundle_dir.name)
+    return tar_path
+
+
+def load_manifest(bundle: Path):
+    mf = bundle / "manifest.json"
+    if not mf.exists():
+        return None
+    return json.loads(mf.read_text())
+
+
+def list_bundle(bundle: Path, color=False) -> str:
+    def p(text, *styles):
+        return f"\033[{';'.join(_c[s] for s in styles)}m{text}\033[0m" if color else text
+
+    m = load_manifest(bundle)
+    if not m:
+        return f"not an aics bundle (no manifest.json): {bundle}"
+    out = [p(f"bundle @ {bundle}", "bold", "cyan"), f"exported: {m['exportedAt']} from {m['sourceHost']}"]
+    for c, counts in m["counts"].items():
+        out.append(f"{c}: " + ", ".join(f"{k}={v}" for k, v in counts.items()))
+    out.append(f"assets: {len(m['assets'])} files")
+    out.append(f"redacted: {len(m['redacted'])} fields")
+    return "\n".join(out) + "\n"
+
+
+def diff_bundle(bundle: Path, color=False) -> str:
+    def p(text, *styles):
+        return f"\033[{';'.join(_c[s] for s in styles)}m{text}\033[0m" if color else text
+
+    m = load_manifest(bundle)
+    if not m:
+        return "not an aics bundle"
+    claude = scan_claude()
+    cursor = scan_cursor()
+    out = [p("diff (bundle -> local):", "bold", "cyan")]
+    bc = m["counts"]["claude"]
+    cc = {
+        "mcp": len(claude["mcpServers"]),
+        "plugins": len(claude["plugins"]),
+        "skills": len(claude["skills"]),
+        "commands": len(claude["commands"]),
+        "agents": len(claude["agents"]),
+    }
+    for k in bc:
+        sign = "==" if bc[k] == cc[k] else ("+local" if cc[k] > bc[k] else "+bundle")
+        style = "green" if sign == "==" else "yellow"
+        out.append(f"  claude.{k}: bundle={bc[k]} local={cc[k]} " + p(sign, style))
+    bcur = m["counts"]["cursor"]
+    curc = {
+        "mcp": len(cursor["mcp"]),
+        "rules": len(cursor["rules"]),
+        "extensions": len(cursor["extensions"]),
+    }
+    for k in bcur:
+        sign = "==" if bcur[k] == curc[k] else ("+local" if curc[k] > bcur[k] else "+bundle")
+        style = "green" if sign == "==" else "yellow"
+        out.append(f"  cursor.{k}: bundle={bcur[k]} local={curc[k]} " + p(sign, style))
+    return "\n".join(out) + "\n"

aics/cli.py

@@ -0,0 +1,186 @@
+import argparse
+import sys
+from pathlib import Path
+
+from . import __version__
+from .bundle import diff_bundle, export_bundle, list_bundle, load_manifest, make_tar
+from .errors import AicsError
+from .log import info, set_quiet, set_verbose
+from .render import render_markdown
+from .sanitize import sanitize
+from .scan import scan_claude, scan_cursor
+from .tui import confirm, header, paint, pick, prompt_default, prompt_required, supports
+
+
+def _empty_cursor():
+    return {"mcp": {}, "rules": [], "settings": {}, "extensions": []}
+
+
+def _empty_claude():
+    return {
+        "mcpServers": {},
+        "projects": {},
+        "settings": {},
+        "plugins": [],
+        "enabledPlugins": {},
+        "skills": [],
+        "commands": [],
+        "agents": [],
+    }
+
+
+def cmd_status(args):
+    color = supports()
+    claude = scan_claude()
+    cursor = scan_cursor()
+    cs, cred = sanitize(claude["settings"])
+    curs, rred = sanitize(cursor["settings"])
+    claude["settings"] = cs
+    cursor["settings"] = curs
+    if args.client == "claude":
+        sys.stdout.write(render_markdown(claude, _empty_cursor(), guide=False, color=color))
+    elif args.client == "cursor":
+        sys.stdout.write(render_markdown(_empty_claude(), cursor, guide=False, color=color))
+    else:
+        sys.stdout.write(render_markdown(claude, cursor, cred + rred, guide=False, color=color))
+
+
+def cmd_export(args):
+    out = Path(args.output).expanduser().resolve()
+    mf = export_bundle(out, include_secrets=args.include_secrets)
+    info(f"exported to {out}")
+    info(f"redacted {len(mf['redacted'])} secret fields" + (" (secrets kept)" if args.include_secrets else ""))
+    if args.tar:
+        info(f"tar: {make_tar(out)}")
+
+
+def cmd_list(args):
+    sys.stdout.write(list_bundle(Path(args.bundle).expanduser().resolve(), color=supports()))
+
+
+def cmd_diff(args):
+    sys.stdout.write(diff_bundle(Path(args.bundle).expanduser().resolve(), color=supports()))
+
+
+def build_parser():
+    ap = argparse.ArgumentParser(prog="aics", description="AI client config sync (Claude Code / Cursor)")
+    ap.add_argument("-V", "--version", action="version", version=f"aics {__version__}")
+    ap.add_argument("-v", "--verbose", action="store_true", help="verbose logging to stderr")
+    ap.add_argument("-q", "--quiet", action="store_true", help="suppress progress logs")
+    sub = ap.add_subparsers(dest="cmd", required=False)
+
+    sp = sub.add_parser("status", help="show local claude/cursor config inventory")
+    sp.add_argument("--client", choices=["claude", "cursor"])
+    sp.set_defaults(func=cmd_status)
+
+    sp = sub.add_parser("export", help="export config bundle to a directory")
+    sp.add_argument("-o", "--output", default="./aics-bundle")
+    sp.add_argument("--include-secrets", action="store_true")
+    sp.add_argument("--tar", action="store_true")
+    sp.set_defaults(func=cmd_export)
+
+    sp = sub.add_parser("list", help="list bundle contents")
+    sp.add_argument("bundle")
+    sp.set_defaults(func=cmd_list)
+
+    sp = sub.add_parser("diff", help="compare bundle vs local")
+    sp.add_argument("bundle")
+    sp.set_defaults(func=cmd_diff)
+
+    sp = sub.add_parser("install", help="apply a bundle to local machine")
+    sp.add_argument("bundle")
+    sp.add_argument("--client", choices=["claude", "cursor"])
+    sp.add_argument("--force", action="store_true", help="overwrite existing items")
+    sp.add_argument("--yes", action="store_true", help="run network installs (plugins/extensions)")
+    sp.set_defaults(func=_cmd_install)
+
+    sp = sub.add_parser("convert", help="convert a Claude SKILL.md to a Cursor .mdc rule")
+    sp.add_argument("--skill", required=True)
+    sp.add_argument("--out", required=True)
+    sp.set_defaults(func=_cmd_convert)
+
+    return ap
+
+
+def _cmd_install(args):
+    bundle = Path(args.bundle).expanduser().resolve()
+    if not load_manifest(bundle):
+        raise AicsError(f"not an aics bundle: {bundle}")
+    if sys.stdin.isatty() and not args.yes:
+        sys.stdout.write(diff_bundle(bundle, color=supports()))
+        if not confirm("Apply these changes?"):
+            info("aborted")
+            return
+    from .installer import cmd_install
+
+    cmd_install(args)
+
+
+def _cmd_convert(args):
+    from .convert import cmd_convert
+
+    cmd_convert(args)
+
+
+def menu():
+    from types import SimpleNamespace
+
+    print(f"\n{paint('aics', 'bold', 'cyan')} {paint('— AI client config sync', 'dim')}\n")
+    items = [
+        ("status", "show local config inventory"),
+        ("export", "pack a bundle"),
+        ("list", "show a bundle's contents"),
+        ("diff", "compare a bundle vs local"),
+        ("install", "apply a bundle"),
+        ("convert", "Claude skill → Cursor rule"),
+        ("quit", "exit"),
+    ]
+    i = pick("choose an action", [f"{n} — {d}" for n, d in items])
+    if i is None:
+        return
+    name = items[i][0]
+    if name == "quit":
+        return
+    if name == "status":
+        cmd_status(SimpleNamespace(client=None))
+    elif name == "export":
+        out = prompt_default("output dir", "./aics-bundle")
+        sec = confirm("include plaintext secrets?")
+        tar = confirm("also create tar.gz?")
+        cmd_export(SimpleNamespace(output=out, include_secrets=sec, tar=tar))
+    elif name == "list":
+        cmd_list(SimpleNamespace(bundle=prompt_required("bundle path")))
+    elif name == "diff":
+        cmd_diff(SimpleNamespace(bundle=prompt_required("bundle path")))
+    elif name == "install":
+        _cmd_install(SimpleNamespace(
+            bundle=prompt_required("bundle path"),
+            client=None,
+            force=False,
+            yes=confirm("also run network installs (plugins/extensions)?"),
+        ))
+    elif name == "convert":
+        cmd_convert(SimpleNamespace(
+            skill=prompt_required("skill SKILL.md path"),
+            out=prompt_required("output .mdc path"),
+        ))
+
+
+def main(argv=None):
+    ap = build_parser()
+    args = ap.parse_args(argv)
+    set_verbose(args.verbose)
+    set_quiet(args.quiet)
+    if not getattr(args, "cmd", None):
+        if sys.stdin.isatty():
+            menu()
+            return
+        ap.print_help()
+        sys.exit(0)
+    try:
+        args.func(args)
+    except AicsError as e:
+        print(f"error: {e}", file=sys.stderr)
+        sys.exit(1)
+    except KeyboardInterrupt:
+        sys.exit(130)

aics/config.py

@@ -0,0 +1,19 @@
+import os
+import re
+from pathlib import Path
+
+
+def _resolve_home() -> Path:
+    return Path(os.environ.get("AICS_HOME") or os.environ.get("HOME") or os.path.expanduser("~"))
+
+
+HOME = _resolve_home()
+CLAUDE_DIR = HOME / ".claude"
+CLAUDE_JSON = HOME / ".claude.json"
+CURSOR_DIR = HOME / ".cursor"
+CURSOR_MCP = CURSOR_DIR / "mcp.json"
+CURSOR_EXT_JSON = CURSOR_DIR / "extensions" / "extensions.json"
+CURSOR_USER_SETTINGS = HOME / "Library" / "Application Support" / "Cursor" / "User" / "settings.json"
+AICS_DIR = HOME / ".aics"
+
+SECRET_RE = re.compile(r"token|key|secret|password|auth|credential", re.I)

aics/convert.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+from .log import info
+
+
+def convert_skill_to_rule(skill_path: Path, out_path: Path):
+    text = skill_path.read_text()
+    front = {}
+    body = text
+    if text.startswith("---"):
+        end = text.find("---", 3)
+        if end != -1:
+            block = text[3:end]
+            body = text[end + 3 :].lstrip("\n")
+            for line in block.splitlines():
+                if ":" in line:
+                    k, v = line.split(":", 1)
+                    front[k.strip()] = v.strip()
+    desc = front.get("description") or ""
+    rule = "---\n"
+    rule += f"description: {desc}\n"
+    rule += "globs: \n"
+    rule += "alwaysApply: false\n"
+    rule += "---\n\n"
+    rule += body.strip() + "\n"
+    rule += "\n<!-- TODO: Cursor rules have no skill auto-trigger; review when this should apply. -->\n"
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    out_path.write_text(rule)
+    info(f"wrote {out_path}")
+
+
+def cmd_convert(args):
+    convert_skill_to_rule(Path(args.skill).expanduser(), Path(args.out).expanduser())

aics/errors.py

@@ -0,0 +1,10 @@
+import sys
+
+
+class AicsError(Exception):
+    pass
+
+
+def fail(msg: str, code: int = 1):
+    print(f"error: {msg}", file=sys.stderr)
+    sys.exit(code)

aics/installer.py

@@ -0,0 +1,178 @@
+import json
+import shutil
+import subprocess
+
+from .config import (
+    AICS_DIR,
+    CLAUDE_DIR,
+    CLAUDE_JSON,
+    CURSOR_DIR,
+    CURSOR_MCP,
+    CURSOR_USER_SETTINGS,
+)
+from .log import info
+from .render import now_iso
+from .scan import read_json
+
+
+def merge(dst, src, force=False):
+    for k, v in src.items():
+        if isinstance(v, dict) and isinstance(dst.get(k), dict):
+            merge(dst[k], v, force)
+        elif force or k not in dst or dst[k] is None:
+            dst[k] = v
+    return dst
+
+
+def backup_current(ts):
+    bdir = AICS_DIR / "backup" / ts
+    bdir.mkdir(parents=True, exist_ok=True)
+    targets = [
+        CLAUDE_JSON,
+        CLAUDE_DIR / "settings.json",
+        CLAUDE_DIR / "settings.local.json",
+        CURSOR_MCP,
+        CURSOR_USER_SETTINGS,
+    ]
+    for t in targets:
+        if t.exists():
+            rel = t.relative_to(AICS_DIR.parent)
+            dst = bdir / rel
+            dst.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(t, dst)
+    for kind in ("skills", "commands", "agents"):
+        d = CLAUDE_DIR / kind
+        if d.exists():
+            shutil.copytree(d, bdir / "claude" / kind, dirs_exist_ok=True)
+    crd = CURSOR_DIR / "rules"
+    if crd.exists():
+        shutil.copytree(crd, bdir / "cursor" / "rules", dirs_exist_ok=True)
+    return bdir
+
+
+def _copy_assets(src, dst, force=False):
+    if not src.exists():
+        return 0
+    dst.mkdir(parents=True, exist_ok=True)
+    n = 0
+    for item in src.iterdir():
+        if item.name.startswith("."):
+            continue
+        target = dst / item.name
+        if target.exists() and not force:
+            continue
+        if item.is_dir():
+            shutil.copytree(item, target, dirs_exist_ok=True)
+        else:
+            shutil.copy2(item, target)
+        n += 1
+    return n
+
+
+def apply_claude(bundle, force=False, yes=False):
+    data = read_json(bundle / "claude_mcp.json")
+    cj = read_json(CLAUDE_JSON)
+    cj.setdefault("mcpServers", {})
+    merged = 0
+    total = 0
+    for name, srv in (data.get("global") or {}).items():
+        total += 1
+        if name not in cj["mcpServers"] or force:
+            cj["mcpServers"][name] = srv
+            merged += 1
+    CLAUDE_JSON.write_text(json.dumps(cj, indent=2, ensure_ascii=False))
+    info(f"claude mcp: merged {merged} (skipped {total - merged})")
+
+    settings = data.get("settings") or {}
+    local_s = read_json(CLAUDE_DIR / "settings.json")
+    env = settings.get("env") or {}
+    skipped = [k for k, v in env.items() if v is None]
+    merge(local_s, settings, force)
+    (CLAUDE_DIR / "settings.json").parent.mkdir(parents=True, exist_ok=True)
+    (CLAUDE_DIR / "settings.json").write_text(json.dumps(local_s, indent=2, ensure_ascii=False))
+    if skipped:
+        info(f"claude settings: skipped redacted env keys (fill manually): {', '.join(skipped)}")
+
+    for kind in ("skills", "commands", "agents"):
+        n = _copy_assets(bundle / "assets" / "claude" / kind, CLAUDE_DIR / kind, force)
+        if n:
+            info(f"claude {kind}: copied {n}")
+
+    plugins = data.get("plugins") or []
+    if not plugins:
+        return
+    if not yes:
+        print("# claude plugins (run these, or use --yes):")
+        for p in plugins:
+            mp = f"@{p['marketplace']}" if p["marketplace"] else ""
+            print(f"claude plugin install {p['name']}{mp}")
+        return
+    for p in plugins:
+        mp = f"@{p['marketplace']}" if p["marketplace"] else ""
+        cmd = ["claude", "plugin", "install", f"{p['name']}{mp}"]
+        info(f"  $ {' '.join(cmd)}")
+        subprocess.run(cmd)
+
+
+def apply_cursor(bundle, force=False, yes=False):
+    data = read_json(bundle / "cursor_config.json")
+    local = read_json(CURSOR_MCP)
+    local.setdefault("mcpServers", {})
+    merged = 0
+    total = 0
+    for name, srv in (data.get("mcp") or {}).items():
+        total += 1
+        if name not in local["mcpServers"] or force:
+            local["mcpServers"][name] = srv
+            merged += 1
+    CURSOR_MCP.parent.mkdir(parents=True, exist_ok=True)
+    CURSOR_MCP.write_text(json.dumps(local, indent=2, ensure_ascii=False))
+    if total:
+        info(f"cursor mcp: merged {merged} (skipped {total - merged})")
+
+    n = _copy_assets(bundle / "assets" / "cursor" / "rules", CURSOR_DIR / "rules", force)
+    if n:
+        info(f"cursor rules: copied {n}")
+
+    settings = data.get("settings") or {}
+    if settings:
+        local_s = read_json(CURSOR_USER_SETTINGS)
+        merge(local_s, settings, force)
+        CURSOR_USER_SETTINGS.parent.mkdir(parents=True, exist_ok=True)
+        CURSOR_USER_SETTINGS.write_text(json.dumps(local_s, indent=2, ensure_ascii=False))
+        info("cursor settings: merged")
+
+    exts = data.get("extensions") or []
+    if not exts:
+        return
+    if not yes:
+        print("# cursor extensions (run these, or use --yes):")
+        for e in exts:
+            ver = f"@{e['version']}" if e["version"] else ""
+            print(f"cursor --install-extension {e['id']}{ver}")
+        return
+    for e in exts:
+        ver = f"@{e['version']}" if e["version"] else ""
+        cmd = ["cursor", "--install-extension", f"{e['id']}{ver}"]
+        info(f"  $ {' '.join(cmd)}")
+        subprocess.run(cmd)
+
+
+def cmd_install(args):
+    from pathlib import Path
+
+    from .bundle import load_manifest
+    from .errors import AicsError
+
+    bundle = Path(args.bundle).expanduser().resolve()
+    if not load_manifest(bundle):
+        raise AicsError(f"not an aics bundle: {bundle}")
+    ts = now_iso().replace(":", "-")
+    bdir = backup_current(ts)
+    info(f"backup -> {bdir}")
+    if args.client in ("claude", None):
+        info("[claude]")
+        apply_claude(bundle, force=args.force, yes=args.yes)
+    if args.client in ("cursor", None):
+        info("[cursor]")
+        apply_cursor(bundle, force=args.force, yes=args.yes)

aics/log.py

@@ -0,0 +1,24 @@
+import sys
+
+_VERBOSE = False
+_QUIET = False
+
+
+def set_verbose(v: bool):
+    global _VERBOSE
+    _VERBOSE = v
+
+
+def set_quiet(q: bool):
+    global _QUIET
+    _QUIET = q
+
+
+def info(msg: str):
+    if not _QUIET:
+        print(msg, file=sys.stderr)
+
+
+def debug(msg: str):
+    if _VERBOSE and not _QUIET:
+        print(msg, file=sys.stderr)

aics/render.py

@@ -0,0 +1,127 @@
+import json
+import os
+import shlex
+
+from .config import HOME
+
+_c = {
+    "reset": "0",
+    "bold": "1",
+    "dim": "2",
+    "red": "31",
+    "green": "32",
+    "yellow": "33",
+    "blue": "34",
+    "magenta": "35",
+    "cyan": "36",
+    "gray": "90",
+}
+
+
+def now_iso():
+    from datetime import datetime, timezone
+
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def host():
+    return os.uname().nodename if hasattr(os, "uname") else os.getenv("HOSTNAME", "unknown")
+
+
+def mcp_cmd_claude(name, srv):
+    if srv.get("url"):
+        tr = srv.get("type") or "sse"
+        return f"claude mcp add --transport {tr} {shlex.quote(name)} {shlex.quote(srv['url'])}"
+    cmd = srv.get("command", "")
+    args = srv.get("args") or []
+    full = " ".join(shlex.quote(x) for x in [cmd] + list(args))
+    return f"claude mcp add {shlex.quote(name)} -- {full}"
+
+
+def mcp_env_note(srv):
+    env = srv.get("env") or {}
+    keys = [k for k in env if env.get(k) is None or env.get(k) == ""]
+    if not keys:
+        return ""
+    return f"  # env to fill: {', '.join(keys)}"
+
+
+def render_markdown(claude, cursor, redacted=None, guide=False, color=False):
+    def h(text, *styles):
+        return f"\033[{';'.join(_c[s] for s in styles)}m{text}\033[0m" if color else text
+
+    lines = []
+    if guide:
+        lines += [
+            h("# AICS Install Guide", "bold", "cyan"),
+            "",
+            f"Exported: {now_iso()} from host `{host()}`",
+            "",
+            "An agent can execute this guide section by section.",
+            "",
+        ]
+    redacted = redacted or []
+
+    lines += [h("## Claude Code", "bold", "cyan"), ""]
+    lines += [f"- MCP servers: {len(claude['mcpServers'])}"]
+    if claude["mcpServers"]:
+        lines += ["", "```bash"]
+        for n, s in claude["mcpServers"].items():
+            lines.append(mcp_cmd_claude(n, s))
+            note = mcp_env_note(s)
+            if note:
+                lines.append(note)
+        lines += ["```"]
+    lines += [f"- Plugins: {len(claude['plugins'])}"]
+    if claude["plugins"]:
+        enabled = claude["enabledPlugins"]
+        lines += ["", "```bash"]
+        for p in claude["plugins"]:
+            mp = f"@{p['marketplace']}" if p["marketplace"] else ""
+            lines.append(f"claude plugin install {p['name']}{mp}")
+            if not enabled.get(f"{p['name']}@{p['marketplace']}", True):
+                lines.append(f"  # disabled in source — review before enabling")
+        lines += ["```"]
+    for kind in ("skills", "commands", "agents"):
+        items = claude[kind]
+        lines += [f"- {kind}: {len(items)}"]
+        if items:
+            lines += [""]
+            lines += [f"  {', '.join(items)}"]
+            if guide:
+                lines += ["", "```bash", f"cp -r assets/claude/{kind}/* ~/.claude/{kind}/", "```"]
+    s = claude["settings"]
+    env = (s.get("env") or {}) if s else {}
+    model = s.get("model")
+    if env or model:
+        lines += ["- settings:"]
+        if model:
+            lines += [f"  - model: `{model}`"]
+        for k, v in env.items():
+            mark = " *(redacted — fill value)*" if v is None else f" = `{v}`"
+            lines += [f"  - env `{k}`{mark}"]
+
+    lines += ["", h("## Cursor", "bold", "cyan"), ""]
+    lines += [f"- MCP servers: {len(cursor['mcp'])}"]
+    if cursor["mcp"]:
+        lines += ["Merge into `~/.cursor/mcp.json` under `mcpServers`:", "", "```json"]
+        lines.append(json.dumps({"mcpServers": cursor["mcp"]}, indent=2, ensure_ascii=False))
+        lines += ["```"]
+    lines += [f"- Rules: {len(cursor['rules'])}"]
+    if cursor["rules"]:
+        lines += [f"  {', '.join(cursor['rules'])}"]
+        if guide:
+            lines += ["", "```bash", "cp -r assets/cursor/rules/* ~/.cursor/rules/", "```"]
+    lines += [f"- Extensions: {len(cursor['extensions'])}"]
+    if cursor["extensions"]:
+        lines += ["", "```bash"]
+        for e in cursor["extensions"]:
+            ver = f"@{e['version']}" if e["version"] else ""
+            lines.append(f"cursor --install-extension {e['id']}{ver}")
+        lines += ["```"]
+
+    if redacted:
+        lines += ["", h("## Redacted (fill on target)", "bold", "red"), ""]
+        for r in redacted:
+            lines.append(f"- `{r['key']}` at `{r['path']}`")
+    return "\n".join(lines) + "\n"

aics/sanitize.py

@@ -0,0 +1,25 @@
+from .config import SECRET_RE
+
+
+def sanitize(obj, include_secrets=False, path="$"):
+    redacted = []
+    if isinstance(obj, list):
+        out = []
+        for i, v in enumerate(obj):
+            r = sanitize(v, include_secrets, f"{path}[{i}]")
+            out.append(r[0])
+            redacted += r[1]
+        return out, redacted
+    if isinstance(obj, dict):
+        out = {}
+        for k, v in obj.items():
+            p = f"{path}.{k}"
+            if not include_secrets and isinstance(v, str) and SECRET_RE.search(k):
+                redacted.append({"path": p, "key": k})
+                out[k] = None
+            else:
+                r = sanitize(v, include_secrets, p)
+                out[k] = r[0]
+                redacted += r[1]
+        return out, redacted
+    return obj, redacted

aics/scan.py

@@ -0,0 +1,74 @@
+import json
+
+from .config import CLAUDE_DIR, CLAUDE_JSON, CURSOR_DIR, CURSOR_EXT_JSON, CURSOR_MCP, CURSOR_USER_SETTINGS
+
+
+def read_json(p):
+    try:
+        return json.loads(p.read_text())
+    except Exception:
+        return {}
+
+
+def scan_claude():
+    inv = {
+        "mcpServers": {},
+        "projects": {},
+        "settings": {},
+        "plugins": [],
+        "enabledPlugins": {},
+        "skills": [],
+        "commands": [],
+        "agents": [],
+    }
+    cj = read_json(CLAUDE_JSON)
+    inv["mcpServers"] = cj.get("mcpServers", {}) or {}
+    projects = {}
+    for pth, pdata in (cj.get("projects") or {}).items():
+        ms = (pdata or {}).get("mcpServers") or {}
+        if ms:
+            projects[pth] = {"mcpServers": ms}
+    inv["projects"] = projects
+    inv["settings"] = read_json(CLAUDE_DIR / "settings.json")
+    inv["enabledPlugins"] = inv["settings"].get("enabledPlugins", {}) or {}
+    ip = read_json(CLAUDE_DIR / "plugins" / "installed_plugins.json")
+    plugins = []
+    for key, installs in (ip.get("plugins") or {}).items():
+        if "@" in key:
+            name, marketplace = key.split("@", 1)
+        else:
+            name, marketplace = key, ""
+        meta = installs[0] if installs else {}
+        plugins.append(
+            {
+                "name": name,
+                "marketplace": marketplace,
+                "version": meta.get("version", ""),
+                "sha": meta.get("gitCommitSha"),
+            }
+        )
+    inv["plugins"] = plugins
+    for kind in ("skills", "commands", "agents"):
+        d = CLAUDE_DIR / kind
+        inv[kind] = (
+            sorted(x.name for x in d.iterdir() if x.is_dir() and not x.name.startswith("."))
+            if d.exists()
+            else []
+        )
+    return inv
+
+
+def scan_cursor():
+    inv = {"mcp": {}, "rules": [], "settings": {}, "extensions": []}
+    inv["mcp"] = (read_json(CURSOR_MCP) or {}).get("mcpServers", {}) or {}
+    rd = CURSOR_DIR / "rules"
+    inv["rules"] = sorted(f.name for f in rd.glob("*.mdc")) if rd.exists() else []
+    inv["settings"] = read_json(CURSOR_USER_SETTINGS)
+    exts = read_json(CURSOR_EXT_JSON)
+    out = []
+    for e in exts or []:
+        eid = (e.get("identifier") or {}).get("id", "")
+        if eid:
+            out.append({"id": eid, "version": e.get("version", "")})
+    inv["extensions"] = out
+    return inv

aics/tui.py

@@ -0,0 +1,78 @@
+import os
+import sys
+
+_CODES = {
+    "reset": "0",
+    "bold": "1",
+    "dim": "2",
+    "red": "31",
+    "green": "32",
+    "yellow": "33",
+    "blue": "34",
+    "magenta": "35",
+    "cyan": "36",
+    "gray": "90",
+}
+
+
+def supports(stream=sys.stdout) -> bool:
+    return (
+        os.environ.get("NO_COLOR") is None
+        and stream.isatty()
+        and os.environ.get("TERM", "") != "dumb"
+    )
+
+
+def paint(text, *styles, stream=sys.stdout):
+    if not supports(stream):
+        return text
+    codes = ";".join(_CODES[s] for s in styles)
+    return f"\033[{codes}m{text}\033[0m"
+
+
+def header(text, stream=sys.stdout):
+    return paint(text, "bold", "cyan", stream=stream)
+
+
+def confirm(prompt: str) -> bool:
+    mark = paint("[y/N]", "yellow")
+    try:
+        ans = input(f"{prompt} {mark} ").strip().lower()
+    except EOFError:
+        return False
+    return ans in ("y", "yes")
+
+
+def prompt_default(label: str, default: str) -> str:
+    try:
+        ans = input(f"{label} [{default}]: ").strip()
+    except EOFError:
+        return default
+    return ans or default
+
+
+def prompt_required(label: str) -> str:
+    while True:
+        try:
+            ans = input(f"{label}: ").strip()
+        except EOFError:
+            return ""
+        if ans:
+            return ans
+        print(paint("  required", "red"), file=sys.stderr)
+
+
+def pick(title: str, options: list) -> int | None:
+    print(header(title))
+    for i, o in enumerate(options, 1):
+        print(f"  {paint(str(i), 'green')}) {o}")
+    while True:
+        try:
+            ans = input(paint("> ", "blue")).strip()
+        except EOFError:
+            return None
+        if ans == "":
+            return None
+        if ans.isdigit() and 1 <= int(ans) <= len(options):
+            return int(ans) - 1
+        print(paint("  invalid choice", "red"), file=sys.stderr)

aicsync-0.1.0.dist-info/METADATA

@@ -0,0 +1,195 @@
+Metadata-Version: 2.5
+Name: aicsync
+Version: 0.1.0
+Summary: AI client config sync CLI — back up / migrate Claude Code & Cursor config (MCP, skills, plugins, rules, extensions).
+Project-URL: Homepage, https://github.com/hanjinxin/aics
+Author: hanjinxin
+License-Expression: MIT
+License-File: LICENSE
+Keywords: backup,claude-code,cli,config,cursor,mcp,sync
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+
+# aics
+
+**AI client config sync** — 在不同机器之间备份/迁移你的 Claude Code 与 Cursor 配置(MCP、skills、plugins、commands、agents、rules、extensions)。
+
+纯 Python 标准库,零依赖,零构建。`python3 aics.py` 直接跑。
+
+## 为什么需要
+
+你在 Claude Code 和 Cursor 上攒了一套个人配置——MCP servers、skills、plugins、自定义命令、Cursor rules、扩展。换机器或重装系统时,这些散落在 `~/.claude.json`、`~/.claude/`、`~/.cursor/` 各处的配置没法一键带走,手动拷贝既容易漏,又容易把明文密钥(API token)带走泄露到别处。
+
+市面已有的工具(Smithery、社区 mcp-sync)只管「从零安装 MCP server」,没有「把我这套配置整体打包、到新机器一键还原」的同端迁移工具。aics 填这个空。
+
+## 安装
+
+```bash
+git clone <your-repo> aics && cd aics
+chmod +x aics.py bin/aics
+# 可选:加到 PATH
+ln -s "$(pwd)/bin/aics" /usr/local/bin/aics
+```
+
+要求:Python 3.10+(仅标准库)。
+
+## 全局选项
+
+```
+-V, --version     版本号
+-v, --verbose     详细日志输出到 stderr
+-q, --quiet       静默(抑制进度日志)
+-h, --help        帮助
+```
+
+结果走 stdout,日志/错误走 stderr,可安全用于管道。退出码:0 成功,1 失败,130 中断。可用 `AICS_HOME` 环境变量覆盖目标 home(测试/沙箱用)。
+
+## 交互模式
+
+aics 是 **CLI + interactive layer**(非全屏 TUI)。TTY 里自动开,管道/agent 走纯文本:
+
+- **无参 `aics`**:TTY 进数字菜单(status/export/list/diff/install/convert/quit),逐项收参;非 TTY 打印 help。
+- **颜色**:TTY 时 status/diff/list 自动加色(标题青、`==` 绿、`+bundle` 黄、redacted 红)。设 `NO_COLOR` 或非 TTY → 纯文本。
+- **install 确认门**:TTY 且非 `--yes` 时,先打彩色 diff,再 `Apply these changes? [y/N]`。答 n 中止(不备份不改);答 y 才备份+应用。非 TTY / `--yes` 跳过确认,自动化路径不变。
+
+人类有颜色有确认有菜单,agent / `aics install bundle | bash` / CI 走的仍是干净 stdout + 退出码。
+
+## 命令
+
+
+
+### `status` — 看本机有什么
+
+```bash
+python3 aics.py status              # 两端都看
+python3 aics.py status --client claude
+```
+
+输出 markdown 清单:每个 MCP server 的安装命令、每个 plugin 的 `claude plugin install` 命令、skills/commands/agents 列表、Cursor 扩展列表。密钥默认脱敏。
+
+### `export` — 打包配置
+
+```bash
+python3 aics.py export -o ./my-bundle          # 默认脱敏
+python3 aics.py export -o ./my-bundle --tar     # 额外打 tar.gz
+python3 aics.py export -o ./my-bundle --include-secrets   # 保留明文密钥
+```
+
+生成 bundle 目录:
+
+```
+my-bundle/
+├── INSTALL.md            # agent 可读的安装指南(含每项的安装命令)
+├── manifest.json         # 机器可读索引(counts / redacted / assets)
+├── claude_mcp.json       # MCP servers + settings + plugins 清单
+├── cursor_config.json    # MCP + settings + extensions 清单
+└── assets/
+    ├── claude/{skills,commands,agents}/   # 纯文本资产,直接拷贝
+    └── cursor/rules/                     # .mdc 规则文件
+```
+
+
+
+### `list` — 看 bundle 内容
+
+```bash
+python3 aics.py list ./my-bundle
+```
+
+
+
+### `diff` — bundle vs 本机
+
+```bash
+python3 aics.py diff ./my-bundle
+```
+
+逐项对比 MCP/plugins/skills/extensions 的数量差异。
+
+### `install` — 应用到本机
+
+```bash
+python3 aics.py install ./my-bundle                # 文件类直接应用,网络类只打印
+python3 aics.py install ./my-bundle --client claude
+python3 aics.py install ./my-bundle --force         # 覆盖已存在项
+python3 aics.py install ./my-bundle --yes           # 连网络安装(plugins/扩展)一起跑
+```
+
+行为:
+
+- **执行前**先备份当前配置到 `~/.aics/backup/<timestamp>/`
+- **文件类**(MCP JSON 合并、skills/commands/agents/rules 拷贝、settings 合并)直接执行,幂等(已存在跳过,`--force` 才覆盖)
+- **网络类**(`claude plugin install`、`cursor --install-extension`)默认只打印命令,`--yes` 才真跑
+- **密钥**:脱敏字段保持空值并提示手动回填,绝不猜值
+
+
+
+### `convert` — Claude skill → Cursor rule
+
+```bash
+python3 aics.py convert --skill ~/.claude/skills/foo/SKILL.md --out foo.mdc
+```
+
+把 SKILL.md 的 frontmatter 翻译成 Cursor `.mdc` 格式,无法表达的触发语义打 `<!-- TODO -->`。
+
+## 两条使用路径
+
+```mermaid
+flowchart LR
+    A["aics export"] --> B["bundle + INSTALL.md"]
+    B --> C{谁来装?}
+    C -->|让 CLI 自己装| D["aics install bundle --yes"]
+    C -->|交给 agent| E["agent 读 INSTALL.md\n逐段执行命令"]
+    B -.->|密钥| F["redacted 列表\n手动回填"]
+```
+
+## Agent 用法
+
+非 TTY 自动无色、无确认门、无菜单。stdout 只放结果(可 grep/parse),stderr 放进度日志。exit code:0 成功 / 1 失败 / 130 中断。
+
+最小三步:
+
+```bash
+aics export -o b        # 打包(密钥默认脱敏,产物 b/INSTALL.md + manifest.json)
+aics install b --yes   # 应用(非交互,--yes 连网络安装一起跑,幂等可重试)
+aics diff b            # 验证(全 == 即还原完成)
+```
+
+要点:
+- `aics status` stdout 是 markdown,`claude mcp add ...` / `claude plugin install ...` 行可直接执行。
+- 密钥在 bundle 里是 null,**agent 不猜值**;把 `manifest.json` 的 `redacted` 列表抛给用户回填。
+- 沙箱试跑:`AICS_HOME=/tmp/sb aics install b --yes`,不碰真实 home。
+- `install` 幂等,重复执行跳过已存在项。
+
+
+
+
+
+## 设计:插件为什么是「重装」而不是「拷贝」
+
+`~/.claude/plugins/cache/` 里的插件缓存含平台编译产物(darwin-x64 二进制)、git 工作树状态、绝对路径,且全部信息可由 `installed_plugins.json` 的 `name@marketplace` + git sha 重建。所以 aics 只导出安装清单,`install` 时跑 `claude plugin install <name>@<marketplace>` 按 sha 精确重装——迁的是「安装意图」,不是「缓存尸体」。
+
+skills/commands/agents/rules 是纯文本,直接拷贝,无需重装。
+
+## 安全模型
+
+- **默认脱敏**:所有 JSON 值中匹配 `token|key|secret|password|auth|credential` 的字段在 export/status 时置空,记入 `manifest.redacted`
+- `--include-secrets` 显式 opt-in 才保留明文
+- `install` 时不猜密钥值,提示用户手动回填
+- `install` 前自动备份原配置
+
+
+
+## 客户端适配
+
+目前支持 Claude Code + Cursor。新增客户端只需写一个 scan 函数 + apply 函数。
+
+## License
+
+MIT

aicsync-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+aics/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+aics/__main__.py,sha256=MSmt_5Xg84uHqzTN38JwgseJK8rsJn_11A8WD99VtEo,61
+aics/bundle.py,sha256=h-oMZZh5-0bufB0xgaXVyhDsmYEQ83k04eeIKnH-bGI,5887
+aics/cli.py,sha256=oTPZgLcLgUFku0RlwHBlRffOEuT0IdkDgWq38XRzLBI,6351
+aics/config.py,sha256=GaaBktzcr6XCnumYGIWmLDC0_l6Iz2_LhOI5GQZo9f8,600
+aics/convert.py,sha256=qL68Hot_qyrbz4FnpEduK_8qNaB8l19z0wXDGcuaSwU,1056
+aics/errors.py,sha256=y0FxPT1tJ96daEhEyhabT7jjrH3-YnJvQfeOs1TEV9g,150
+aics/installer.py,sha256=HiOUVVHO8PBkRVq3aZRY_etanWALNp9cmPHNb1uV06E,5860
+aics/log.py,sha256=jqwVsivIJ0Crg34Wx45QL2hMoSux0HH2MVN_3SeL5Ls,336
+aics/render.py,sha256=QWFbCL1gPsIpV6hpUa3YJ3gMe-bnbNPAGxjVY1Empyo,4316
+aics/sanitize.py,sha256=qL4WDGko9iXD3Znp6eFqDxcD6k7Y4TGEG1fXLo87hJ8,798
+aics/scan.py,sha256=mLleBnoi3X1rSNmrU7Q71NWQgaFXBq1ppoLamaB3AS8,2354
+aics/tui.py,sha256=13koTBCtMRaB6BiI6WeEQuSsOjNFV9GgJ0Qk-ZZ3Qeo,1839
+aicsync-0.1.0.dist-info/METADATA,sha256=uuclM1y3nVzJ6q2tUNEymaU1NmoYtLPpeN1RSwYFH6s,7207
+aicsync-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+aicsync-0.1.0.dist-info/entry_points.txt,sha256=gsKiyQE6L_bGlVyWI3VlU5ZV-PPyqS75jgc2uEU7sCY,39
+aicsync-0.1.0.dist-info/licenses/LICENSE,sha256=kW0a_kmab_OnSUttlChECLFfA1pWdLCbGHDR65PSKvg,1066
+aicsync-0.1.0.dist-info/RECORD,,

aicsync-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

aicsync-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+aics = aics.cli:main

aicsync-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hanjinxin
+
+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.