u1s1-cli 1.6.0 → 1.7.0

package/dist/import/index.js

@@ -126,7 +126,7 @@ function parseFlags(args) {
 }
 function printHelp() {
     console.log("");
-    console.log("  把 Claude Code / Codex 的历史对话导入 u1s1");
+    console.log("  把 Claude Code / Codex 的历史对话和技能导入 u1s1");
     console.log("");
     console.log("  用法:");
     console.log("    u1s1 import              导入当前目录的对话");
@@ -136,6 +136,7 @@ function printHelp() {
     console.log("    u1s1 import --cwd 目录     指定项目目录(默认当前目录)");
     console.log("    u1s1 import --dry-run    只看会导哪些,不写盘");
     console.log("    u1s1 import --force      已经导过的也再导一遍");
+    console.log("    u1s1 import skills       导入 Claude Code / Codex 等工具的技能(SKILL.md),详见 u1s1 import skills -h");
     console.log("");
     console.log("  导入后在对应项目里跑 u1s1,输入 /resume 就能看到。");
     console.log("");
@@ -255,6 +256,11 @@ function printImportSummary(summary) {
     console.log("");
 }
 export async function importCommand(args) {
+    if (args[0] === "skills" || args[0] === "skill") {
+        const { importSkillsCommand } = await import("./skills.js");
+        await importSkillsCommand(args.slice(1));
+        return;
+    }
     if (args.includes("-h") || args.includes("--help")) {
         printHelp();
         return;

package/dist/import/skills.d.ts

@@ -0,0 +1,89 @@
+/**
+ * `u1s1 import skills`: 把 Claude Code / Codex(以及任意 --from 目录)里的
+ * Agent Skills(SKILL.md)复制进 ~/.u1s1/agent/skills。pi 用同一套 SKILL.md
+ * 规范,所以只需要按 pi 自己的加载器校验一遍,合规的原样复制,不合规的列出来跳过。
+ */
+export type SkillTool = "claude" | "codex" | "custom";
+export interface SkillSource {
+    tool: SkillTool;
+    label: string;
+    dir: string;
+    scope: "user" | "project" | "custom";
+}
+export interface DiscoveredSkill {
+    name: string;
+    description: string;
+    tool: SkillTool;
+    label: string;
+    /** SKILL.md 所在目录;单文件技能时为该 .md 文件所在目录。 */
+    baseDir: string;
+    skillFile: string;
+    /** 单文件技能(skills 根目录直接放 foo.md)只复制那一个文件。 */
+    singleFile: boolean;
+    files: number;
+    bytes: number;
+    hints: string[];
+}
+export interface SkillProblem {
+    path: string;
+    reason: string;
+}
+export interface SkillImportRecord {
+    name: string;
+    tool: SkillTool;
+    sourcePath: string;
+    destPath: string;
+    importedAt: string;
+}
+export interface SkillImportIndex {
+    version: 1;
+    items: Record<string, SkillImportRecord>;
+}
+export interface SkillImportPlan {
+    pending: DiscoveredSkill[];
+    /** 已由本命令导过、这次不重复导(--force 可重导)。 */
+    alreadyImported: DiscoveredSkill[];
+    /** 目标目录已有同名技能但不是本命令导入的,不覆盖。 */
+    conflicts: DiscoveredSkill[];
+    /** 多个来源同名,只保留先发现的那个。 */
+    duplicates: DiscoveredSkill[];
+}
+export interface SkillImportResultItem {
+    name: string;
+    status: "imported" | "error";
+    destPath?: string;
+    detail?: string;
+}
+/** 超过这个体积的技能目录多半塞了数据集或依赖,先不动。 */
+export declare const MAX_SKILL_BYTES: number;
+export declare function skillsDestDir(): string;
+export declare function skillIndexPath(): string;
+/** Claude Code / Codex 各自约定的技能目录;项目级排在用户级前面,先发现的同名技能优先。 */
+export declare function defaultSkillSources(cwd: string, home?: string): SkillSource[];
+export declare function customSkillSource(dir: string): SkillSource;
+/**
+ * 用 pi 自己的加载器扫一遍来源目录:能被 pi 认出来、且没有任何告警(名称/说明不合规)
+ * 的才算兼容,其他的进 problems 并带上 pi 给的原因。
+ */
+export declare function discoverSkills(sources: SkillSource[]): {
+    skills: DiscoveredSkill[];
+    problems: SkillProblem[];
+};
+export declare function loadSkillIndex(path?: string): SkillImportIndex;
+export declare function planSkillImport(skills: DiscoveredSkill[], opts: {
+    destDir: string;
+    index: SkillImportIndex;
+    force: boolean;
+}): SkillImportPlan;
+/** 复制到 <destDir>/<name>;单文件技能落成 <name>/SKILL.md,这样 --remove 只需删一个目录。 */
+export declare function copySkill(skill: DiscoveredSkill, destDir: string): string;
+export declare function runSkillImport(pending: DiscoveredSkill[], index: SkillImportIndex, destDir: string): SkillImportResultItem[];
+/** 只删本命令导入过的技能,别人手放进去的同名目录不碰。 */
+export declare function removeImportedSkill(name: string, index: SkillImportIndex, destDir: string): {
+    ok: true;
+} | {
+    ok: false;
+    reason: string;
+};
+export declare function printSkillsHelp(): void;
+export declare function importSkillsCommand(args: string[]): Promise<void>;

package/dist/import/skills.js

@@ -0,0 +1,492 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join, resolve } from "node:path";
+import { loadSkillsFromDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
+import { formatHomePath } from "../brand.js";
+import { agentDir } from "../config.js";
+import { asRecord, asString, formatBytes, listHomeClaudeDirs, oneLine, uniqueExistingDirs } from "./util.js";
+import { readJsonIfExists, writeJson } from "./write.js";
+const TOOL_LABEL = {
+    claude: "Claude Code",
+    codex: "Codex",
+    custom: "自定义目录",
+};
+const SCRIPT_EXTENSIONS = new Set([".sh", ".bash", ".zsh", ".ps1", ".bat", ".cmd", ".py", ".js", ".mjs", ".cjs", ".ts", ".rb", ".pl"]);
+/** 超过这个体积的技能目录多半塞了数据集或依赖,先不动。 */
+export const MAX_SKILL_BYTES = 20 * 1024 * 1024;
+const MAX_SKILL_FILES = 2000;
+const LARGE_SKILL_BYTES = 1024 * 1024;
+export function skillsDestDir() {
+    return join(agentDir, "skills");
+}
+export function skillIndexPath() {
+    return join(agentDir, "imported-skills.json");
+}
+/** Claude Code / Codex 各自约定的技能目录;项目级排在用户级前面,先发现的同名技能优先。 */
+export function defaultSkillSources(cwd, home = homedir()) {
+    const candidates = [
+        { tool: "claude", scope: "project", dir: join(cwd, ".claude", "skills") },
+        { tool: "codex", scope: "project", dir: join(cwd, ".agents", "skills") },
+        ...listHomeClaudeDirs(home).map((dir) => ({ tool: "claude", scope: "user", dir: join(dir, "skills") })),
+        { tool: "codex", scope: "user", dir: join(home, ".codex", "skills") },
+        { tool: "codex", scope: "user", dir: join(home, ".agents", "skills") },
+    ];
+    const seen = new Set();
+    const out = [];
+    for (const c of candidates) {
+        const [dir] = uniqueExistingDirs([c.dir]);
+        if (!dir || seen.has(dir))
+            continue;
+        seen.add(dir);
+        out.push({ tool: c.tool, label: TOOL_LABEL[c.tool], dir, scope: c.scope });
+    }
+    return out;
+}
+export function customSkillSource(dir) {
+    return { tool: "custom", label: TOOL_LABEL.custom, dir: resolve(dir), scope: "custom" };
+}
+function walkStats(dir, stats, depth = 0) {
+    if (stats.truncated || depth > 16)
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name === "node_modules" || entry.name === ".git")
+            continue;
+        const full = join(dir, entry.name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory()) {
+            walkStats(full, stats, depth + 1);
+        }
+        else if (st.isFile()) {
+            stats.files += 1;
+            stats.bytes += st.size;
+            const dot = entry.name.lastIndexOf(".");
+            const ext = dot >= 0 ? entry.name.slice(dot).toLowerCase() : "";
+            const executable = process.platform !== "win32" && (st.mode & 0o111) !== 0;
+            if (SCRIPT_EXTENSIONS.has(ext) || executable)
+                stats.scripts += 1;
+        }
+        if (stats.files > MAX_SKILL_FILES || stats.bytes > MAX_SKILL_BYTES) {
+            stats.truncated = true;
+            return;
+        }
+    }
+}
+function skillHints(stats) {
+    const hints = [];
+    if (stats.scripts > 0)
+        hints.push(`含 ${stats.scripts} 个脚本,只导可信来源`);
+    if (stats.bytes > LARGE_SKILL_BYTES)
+        hints.push(`体积 ${formatBytes(stats.bytes)}`);
+    return hints;
+}
+const SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+/** 单文件技能(skills 根目录直接放 foo.md)没写 name 时 pi 会拿父目录名,导入后按文件名落目录更合理。 */
+function singleFileSkillName(filePath, fallback) {
+    try {
+        const { frontmatter } = parseFrontmatter(readFileSync(filePath, "utf8"));
+        const declared = frontmatter["name"];
+        if (typeof declared === "string" && declared.trim())
+            return declared.trim();
+    }
+    catch {
+        return fallback;
+    }
+    return basename(filePath).replace(/\.md$/i, "");
+}
+/**
+ * 用 pi 自己的加载器扫一遍来源目录:能被 pi 认出来、且没有任何告警(名称/说明不合规)
+ * 的才算兼容,其他的进 problems 并带上 pi 给的原因。
+ */
+export function discoverSkills(sources) {
+    const skills = [];
+    const problems = [];
+    for (const source of sources) {
+        let result;
+        try {
+            result = loadSkillsFromDir({ dir: source.dir, source: source.label });
+        }
+        catch (e) {
+            problems.push({ path: source.dir, reason: e instanceof Error ? e.message : String(e) });
+            continue;
+        }
+        const reasons = new Map();
+        for (const diag of result.diagnostics) {
+            if (diag.type === "collision")
+                continue;
+            const key = diag.path ?? source.dir;
+            reasons.set(key, [...(reasons.get(key) ?? []), diag.message]);
+        }
+        for (const [path, list] of reasons)
+            problems.push({ path, reason: list.join("; ") });
+        for (const skill of result.skills) {
+            if (reasons.has(skill.filePath))
+                continue;
+            const singleFile = basename(skill.filePath) !== "SKILL.md";
+            const name = singleFile ? singleFileSkillName(skill.filePath, skill.name) : skill.name;
+            if (!SKILL_NAME_RE.test(name) || name.length > 64) {
+                problems.push({ path: skill.filePath, reason: `技能名「${name}」不合规:只能用小写字母、数字和连字符` });
+                continue;
+            }
+            const stats = { files: 0, bytes: 0, scripts: 0, truncated: false };
+            if (singleFile) {
+                try {
+                    stats.files = 1;
+                    stats.bytes = statSync(skill.filePath).size;
+                }
+                catch {
+                    stats.files = 0;
+                }
+            }
+            else {
+                walkStats(skill.baseDir, stats);
+            }
+            if (stats.truncated) {
+                problems.push({
+                    path: singleFile ? skill.filePath : skill.baseDir,
+                    reason: `技能目录太大(超过 ${formatBytes(MAX_SKILL_BYTES)} 或 ${MAX_SKILL_FILES} 个文件),先跳过`,
+                });
+                continue;
+            }
+            skills.push({
+                name,
+                description: skill.description,
+                tool: source.tool,
+                label: source.label,
+                baseDir: skill.baseDir,
+                skillFile: skill.filePath,
+                singleFile,
+                files: stats.files,
+                bytes: stats.bytes,
+                hints: skillHints(stats),
+            });
+        }
+    }
+    return { skills, problems };
+}
+export function loadSkillIndex(path = skillIndexPath()) {
+    const rec = asRecord(readJsonIfExists(path));
+    const items = asRecord(rec?.["items"]);
+    const out = { version: 1, items: {} };
+    if (!items)
+        return out;
+    for (const [key, value] of Object.entries(items)) {
+        const item = asRecord(value);
+        if (!item)
+            continue;
+        const name = asString(item["name"]);
+        const tool = asString(item["tool"]);
+        const sourcePath = asString(item["sourcePath"]);
+        const destPath = asString(item["destPath"]);
+        const importedAt = asString(item["importedAt"]);
+        if (!name || !sourcePath || !destPath || !importedAt)
+            continue;
+        if (tool !== "claude" && tool !== "codex" && tool !== "custom")
+            continue;
+        out.items[key] = { name, tool, sourcePath, destPath, importedAt };
+    }
+    return out;
+}
+export function planSkillImport(skills, opts) {
+    const plan = { pending: [], alreadyImported: [], conflicts: [], duplicates: [] };
+    const seen = new Set();
+    for (const skill of skills) {
+        if (seen.has(skill.name)) {
+            plan.duplicates.push(skill);
+            continue;
+        }
+        seen.add(skill.name);
+        const dest = join(opts.destDir, skill.name);
+        const record = opts.index.items[skill.name];
+        const destExists = existsSync(dest);
+        if (record && destExists && !opts.force) {
+            plan.alreadyImported.push(skill);
+            continue;
+        }
+        if (!record && destExists) {
+            plan.conflicts.push(skill);
+            continue;
+        }
+        plan.pending.push(skill);
+    }
+    return plan;
+}
+/** 复制到 <destDir>/<name>;单文件技能落成 <name>/SKILL.md,这样 --remove 只需删一个目录。 */
+export function copySkill(skill, destDir) {
+    const dest = join(destDir, skill.name);
+    if (resolve(skill.baseDir) === resolve(dest))
+        throw new Error("来源就是目标目录");
+    mkdirSync(destDir, { recursive: true });
+    rmSync(dest, { recursive: true, force: true });
+    if (skill.singleFile) {
+        mkdirSync(dest, { recursive: true });
+        cpSync(skill.skillFile, join(dest, "SKILL.md"));
+    }
+    else {
+        cpSync(skill.baseDir, dest, {
+            recursive: true,
+            dereference: true,
+            filter: (src) => {
+                const name = basename(src);
+                return name !== "node_modules" && name !== ".git";
+            },
+        });
+    }
+    return dest;
+}
+export function runSkillImport(pending, index, destDir) {
+    const items = [];
+    for (const skill of pending) {
+        try {
+            const destPath = copySkill(skill, destDir);
+            index.items[skill.name] = {
+                name: skill.name,
+                tool: skill.tool,
+                sourcePath: skill.singleFile ? skill.skillFile : skill.baseDir,
+                destPath,
+                importedAt: new Date().toISOString(),
+            };
+            items.push({ name: skill.name, status: "imported", destPath });
+        }
+        catch (e) {
+            items.push({ name: skill.name, status: "error", detail: e instanceof Error ? e.message : String(e) });
+        }
+    }
+    return items;
+}
+/** 只删本命令导入过的技能,别人手放进去的同名目录不碰。 */
+export function removeImportedSkill(name, index, destDir) {
+    const record = index.items[name];
+    if (!record)
+        return { ok: false, reason: "不是 u1s1 import skills 导入的技能,请手动处理" };
+    const expected = join(destDir, name);
+    if (resolve(record.destPath) !== resolve(expected)) {
+        return { ok: false, reason: `记录的位置 ${record.destPath} 与技能目录不一致,请手动处理` };
+    }
+    try {
+        if (existsSync(expected) && lstatSync(expected).isDirectory())
+            rmSync(expected, { recursive: true, force: true });
+    }
+    catch (e) {
+        return { ok: false, reason: e instanceof Error ? e.message : String(e) };
+    }
+    delete index.items[name];
+    return { ok: true };
+}
+function parseSkillsArgs(args) {
+    const opts = {
+        cwd: process.cwd(),
+        from: [],
+        tools: undefined,
+        dryRun: false,
+        force: false,
+        yes: false,
+        list: false,
+        remove: [],
+    };
+    const needValue = (flag, i) => {
+        const next = args[i + 1];
+        if (!next || next.startsWith("-")) {
+            console.error(`  ${flag} 后面要跟一个值`);
+            process.exit(1);
+        }
+        return next;
+    };
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--dry-run")
+            opts.dryRun = true;
+        else if (a === "--force" || a === "--update")
+            opts.force = true;
+        else if (a === "-y" || a === "--yes")
+            opts.yes = true;
+        else if (a === "--list")
+            opts.list = true;
+        else if (a === "--from")
+            opts.from.push(needValue(a, i++));
+        else if (a === "--cwd")
+            opts.cwd = needValue(a, i++);
+        else if (a === "--remove")
+            opts.remove.push(needValue(a, i++));
+        else if (a.startsWith("-")) {
+            console.error(`  不认识参数 ${a}`);
+            process.exit(1);
+        }
+        else {
+            const tool = parseToolArg(a);
+            opts.tools = opts.tools ? [...opts.tools, tool] : [tool];
+        }
+    }
+    return opts;
+}
+function parseToolArg(raw) {
+    const aliases = {
+        claude: "claude",
+        "claude-code": "claude",
+        cc: "claude",
+        anthropic: "claude",
+        codex: "codex",
+        openai: "codex",
+    };
+    const tool = aliases[raw.toLowerCase()];
+    if (!tool) {
+        console.error(`  不认识来源「${raw}」,可选: claude / codex;其他工具用 --from 目录`);
+        process.exit(1);
+    }
+    return tool;
+}
+export function printSkillsHelp() {
+    console.log("");
+    console.log("  把 Claude Code / Codex 等工具的技能(SKILL.md)导入 u1s1");
+    console.log("");
+    console.log("  用法:");
+    console.log("    u1s1 import skills                自动找本机 Claude Code / Codex 的技能");
+    console.log("    u1s1 import skills claude         只导 Claude Code 的");
+    console.log("    u1s1 import skills codex          只导 Codex 的");
+    console.log("    u1s1 import skills --from 目录     其他工具:指定放 SKILL.md 的目录(可重复)");
+    console.log("    u1s1 import skills --cwd 目录      项目级技能按这个目录找(默认当前目录)");
+    console.log("    u1s1 import skills --dry-run      只看会导哪些,不写盘");
+    console.log("    u1s1 import skills --update       已导过的重新复制一遍(同 --force)");
+    console.log("    u1s1 import skills --list         看已导入的技能");
+    console.log("    u1s1 import skills --remove 名称   删掉某个导入的技能");
+    console.log("");
+    console.log(`  技能会复制到 ${formatHomePath(skillsDestDir())},下次进对话就能用:`);
+    console.log("  模型会按说明自动调用,也可以在会话里输入 /skill:名称 手动调用。");
+    console.log("");
+}
+async function confirm(question) {
+    if (!input.isTTY || !output.isTTY)
+        return true;
+    const rl = createInterface({ input, output });
+    try {
+        const ans = (await rl.question(question)).trim().toLowerCase();
+        return ans === "" || ans === "y" || ans === "yes" || ans === "是";
+    }
+    finally {
+        rl.close();
+    }
+}
+function describeSource(skill) {
+    return formatHomePath(skill.singleFile ? skill.skillFile : skill.baseDir);
+}
+function printList(index) {
+    const items = Object.values(index.items).sort((a, b) => a.name.localeCompare(b.name));
+    console.log("");
+    if (items.length === 0) {
+        console.log("  还没导入过技能。跑 u1s1 import skills 试试。");
+        console.log("");
+        return;
+    }
+    console.log(`  已导入 ${items.length} 个技能(${formatHomePath(skillsDestDir())}):`);
+    for (const item of items) {
+        const missing = existsSync(item.destPath) ? "" : "(目录已不在)";
+        console.log(`    · ${item.name}  [${TOOL_LABEL[item.tool]}] ${missing}`);
+        console.log(`      来自 ${formatHomePath(item.sourcePath)}`);
+    }
+    console.log("");
+}
+function printPreview(skills, plan, problems, sources) {
+    console.log("");
+    console.log(`  在 ${sources.length} 个目录里找到 ${skills.length} 个技能:`);
+    for (const source of sources)
+        console.log(`    ${formatHomePath(source.dir)}  [${source.label}]`);
+    console.log("");
+    for (const skill of plan.pending) {
+        console.log(`    + ${skill.name}  [${skill.label}]  ${oneLine(skill.description, 60)}`);
+        console.log(`      ${describeSource(skill)}${skill.hints.length ? `  ⚠ ${skill.hints.join(";")}` : ""}`);
+    }
+    for (const skill of plan.alreadyImported)
+        console.log(`    · ${skill.name}  已导过(加 --update 重导)`);
+    for (const skill of plan.conflicts) {
+        console.log(`    · ${skill.name}  目标目录已有同名技能(不是本命令导的),不覆盖`);
+    }
+    for (const skill of plan.duplicates)
+        console.log(`    · ${skill.name}  与前面同名,只保留先发现的(${describeSource(skill)})`);
+    for (const problem of problems) {
+        console.log(`    × ${formatHomePath(problem.path)}  不兼容,跳过: ${oneLine(problem.reason, 80)}`);
+    }
+}
+export async function importSkillsCommand(args) {
+    if (args.includes("-h") || args.includes("--help")) {
+        printSkillsHelp();
+        return;
+    }
+    const opts = parseSkillsArgs(args);
+    const destDir = skillsDestDir();
+    const index = loadSkillIndex();
+    if (opts.remove.length > 0) {
+        for (const name of opts.remove) {
+            const result = removeImportedSkill(name, index, destDir);
+            if (result.ok)
+                console.log(`  ✓ 已删除技能 ${name}`);
+            else
+                console.log(`  × ${name}: ${result.reason}`);
+        }
+        writeJson(skillIndexPath(), index);
+        return;
+    }
+    if (opts.list) {
+        printList(index);
+        return;
+    }
+    const sources = [
+        ...opts.from.map(customSkillSource),
+        ...defaultSkillSources(opts.cwd).filter((s) => !opts.tools || opts.tools.includes(s.tool)),
+    ];
+    const missingFrom = opts.from.filter((dir) => !existsSync(dir));
+    for (const dir of missingFrom)
+        console.log(`  --from 目录不存在: ${dir}`);
+    if (sources.length === 0) {
+        console.log("");
+        console.log("  没找到 Claude Code / Codex 的技能目录(~/.claude/skills、~/.codex/skills、项目里的 .claude/skills 或 .agents/skills)。");
+        console.log("  其他工具的技能可以用 --from 指定目录,只要里面有 SKILL.md。");
+        console.log("");
+        return;
+    }
+    const { skills, problems } = discoverSkills(sources);
+    const plan = planSkillImport(skills, { destDir, index, force: opts.force });
+    printPreview(skills, plan, problems, sources);
+    if (plan.pending.length === 0) {
+        console.log("");
+        console.log(skills.length === 0 ? "  这些目录里没有能用的技能。" : "  没有新的可导。想重导一遍就加 --update。");
+        console.log("");
+        return;
+    }
+    if (opts.dryRun) {
+        console.log("");
+        console.log(`  预演结束,以上 ${plan.pending.length} 个还没真正导入。`);
+        console.log("");
+        return;
+    }
+    if (!opts.yes && !(await confirm(`  导入这 ${plan.pending.length} 个技能?(回车=好 / n=取消) `))) {
+        console.log("  已取消。");
+        return;
+    }
+    const results = runSkillImport(plan.pending, index, destDir);
+    writeJson(skillIndexPath(), index);
+    const imported = results.filter((r) => r.status === "imported").length;
+    const errors = results.filter((r) => r.status === "error");
+    console.log("");
+    console.log(`  ✓ 导入 ${imported} 个技能到 ${formatHomePath(destDir)}${errors.length ? `,失败 ${errors.length}` : ""}。`);
+    for (const item of errors)
+        console.log(`    × ${item.name}: ${item.detail ?? "失败"}`);
+    if (imported > 0) {
+        console.log("  下次进 u1s1 对话就能用:模型会按说明自动调用,或输入 /skill:名称 手动调用。");
+        console.log(`  管理: u1s1 import skills --list / --update / --remove 名称`);
+    }
+    console.log("");
+}

package/dist/import/util.d.ts

@@ -2,7 +2,7 @@ export declare const MAX_TOOL_RESULT_CHARS = 80000;
 export declare const MAX_TEXT_CHARS = 200000;
 export declare const PREVIEW_TITLE_CHARS = 48;
 export declare function resolveExistingDir(path: string): string | undefined;
-export declare function listHomeClaudeDirs(): string[];
+export declare function listHomeClaudeDirs(home?: string): string[];
 export declare function uniqueExistingDirs(paths: Array<string | undefined>): string[];
 export declare function encodeClaudeProjectDir(cwd: string): string;
 export declare function samePath(a: string, b: string): boolean;

package/dist/import/util.js

@@ -15,8 +15,7 @@ export function resolveExistingDir(path) {
         return undefined;
     }
 }
-export function listHomeClaudeDirs() {
-    const home = homedir();
+export function listHomeClaudeDirs(home = homedir()) {
     const out = [];
     try {
         for (const name of readdirSync(home)) {

package/dist/index.js

@@ -529,7 +529,7 @@ async function run() {
         console.log("   u1s1 deploy list       查看已发布的站点");
         console.log("   u1s1 deploy remove     删除已发布的站点");
         console.log("   u1s1 feedback \"一句话\"  反馈问题或建议(自动建工单,--bug/--question…)");
-        console.log("   u1s1 import            导入历史会话");
+        console.log("   u1s1 import            导入历史会话(import skills 导入技能)");
         console.log("   u1s1 bench             模型编码能力评测");
         console.log("   u1s1 --version         查看版本");
         console.log("");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u1s1-cli",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "description": "u1s1 — 有一说一,最省心的 AI 编程搭子。终端里用中文说需求,AI 帮你读文件、改代码、跑命令。",
   "type": "module",
   "bin": {