u1s1-cli 0.2.0 → 0.4.0

package/dist/import/index.js

@@ -0,0 +1,354 @@
+import { createInterface } from "node:readline/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { join } from "node:path";
+import { formatHomePath } from "../brand.js";
+import { agentDir } from "../config.js";
+import { claudeAdapter, hydrateClaudeSession } from "./claude.js";
+import { codexAdapter, hydrateCodexSession } from "./codex.js";
+import { statSync } from "node:fs";
+import { asRecord, asString, formatBytes, oneLine, sessionBelongsToCwd } from "./util.js";
+import { readJsonIfExists, writeConvertedSession, writeJson } from "./write.js";
+const ADAPTERS = {
+    claude: claudeAdapter,
+    codex: codexAdapter,
+};
+const ALL_SOURCES = ["claude", "codex"];
+/** Skip giant rollouts that would blow memory on a one-shot import. */
+const MAX_SOURCE_BYTES = 25 * 1024 * 1024;
+function importIndexPath() {
+    return join(agentDir, "imported-sessions.json");
+}
+function loadIndex() {
+    const raw = readJsonIfExists(importIndexPath());
+    const rec = asRecord(raw);
+    const items = asRecord(rec?.["items"]);
+    if (!items)
+        return { version: 1, items: {} };
+    const out = { version: 1, items: {} };
+    for (const [key, value] of Object.entries(items)) {
+        const item = asRecord(value);
+        if (!item)
+            continue;
+        const source = asString(item["source"]);
+        const sourceId = asString(item["sourceId"]);
+        const sourcePath = asString(item["sourcePath"]);
+        const destPath = asString(item["destPath"]);
+        const cwd = asString(item["cwd"]);
+        const importedAt = asString(item["importedAt"]);
+        if (!source || !sourceId || !sourcePath || !destPath || !cwd || !importedAt)
+            continue;
+        if (source !== "claude" && source !== "codex")
+            continue;
+        out.items[key] = {
+            source,
+            sourceId,
+            sourcePath,
+            destPath,
+            cwd,
+            title: asString(item["title"]),
+            importedAt,
+        };
+    }
+    return out;
+}
+function recordKey(session) {
+    return `${session.source}:${session.sourceId}`;
+}
+function parseSourceArg(raw) {
+    if (!raw || raw === "all")
+        return [...ALL_SOURCES];
+    const aliases = {
+        claude: "claude",
+        "claude-code": "claude",
+        cc: "claude",
+        anthropic: "claude",
+        codex: "codex",
+        openai: "codex",
+    };
+    const id = aliases[raw.toLowerCase()];
+    if (!id) {
+        console.error(`  不认识来源「${raw}」,可选: claude / codex / all`);
+        process.exit(1);
+    }
+    return [id];
+}
+function parseFlags(args) {
+    let cwd = process.cwd();
+    let all = false;
+    let dryRun = false;
+    let force = false;
+    let sourceRaw;
+    let limit;
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === "--all")
+            all = true;
+        else if (a === "--dry-run")
+            dryRun = true;
+        else if (a === "--force")
+            force = true;
+        else if (a === "--cwd") {
+            const next = args[++i];
+            if (!next) {
+                console.error("  --cwd 后面要跟一个目录");
+                process.exit(1);
+            }
+            cwd = next;
+        }
+        else if (a === "--limit") {
+            const next = args[++i];
+            const n = Number(next);
+            if (!Number.isFinite(n) || n <= 0) {
+                console.error("  --limit 要是正整数");
+                process.exit(1);
+            }
+            limit = Math.floor(n);
+        }
+        else if (a.startsWith("-")) {
+            console.error(`  不认识参数 ${a}`);
+            process.exit(1);
+        }
+        else if (!sourceRaw) {
+            sourceRaw = a;
+        }
+        else {
+            console.error(`  多余参数 ${a}`);
+            process.exit(1);
+        }
+    }
+    return {
+        sources: parseSourceArg(sourceRaw),
+        cwd: all ? undefined : cwd,
+        dryRun,
+        force,
+        limit,
+    };
+}
+function printHelp() {
+    console.log("");
+    console.log("  把 Claude Code / Codex 的历史对话导入 u1s1");
+    console.log("");
+    console.log("  用法:");
+    console.log("    u1s1 import              导入当前目录的对话");
+    console.log("    u1s1 import claude       只导 Claude Code");
+    console.log("    u1s1 import codex        只导 Codex");
+    console.log("    u1s1 import --all        导入本机找到的全部对话");
+    console.log("    u1s1 import --cwd 目录     指定项目目录(默认当前目录)");
+    console.log("    u1s1 import --dry-run    只看会导哪些,不写盘");
+    console.log("    u1s1 import --force      已经导过的也再导一遍");
+    console.log("");
+    console.log("  导入后在对应项目里跑 u1s1,输入 /resume 就能看到。");
+    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();
+    }
+}
+async function hydrateSession(session) {
+    try {
+        if (session.source === "claude")
+            return await hydrateClaudeSession(session);
+        return await hydrateCodexSession(session);
+    }
+    catch {
+        return session;
+    }
+}
+async function discoverAll(opts) {
+    const found = [];
+    for (const id of opts.sources) {
+        found.push(...ADAPTERS[id].discover({ cwd: opts.cwd }));
+    }
+    if (opts.cwd) {
+        return found.filter((s) => !s.cwd || sessionBelongsToCwd(s.cwd, opts.cwd));
+    }
+    return found;
+}
+function sortSessions(sessions) {
+    return [...sessions].sort((a, b) => b.mtimeMs - a.mtimeMs);
+}
+function sourceLabel(id) {
+    return ADAPTERS[id].label;
+}
+export async function importCommand(args) {
+    if (args.includes("-h") || args.includes("--help")) {
+        printHelp();
+        return;
+    }
+    const yes = args.includes("-y") || args.includes("--yes");
+    const opts = parseFlags(args.filter((a) => a !== "-y" && a !== "--yes"));
+    const index = loadIndex();
+    const discovered = sortSessions(await discoverAll(opts));
+    const limited = opts.limit ? discovered.slice(0, opts.limit) : discovered;
+    if (limited.length === 0) {
+        const where = opts.cwd ? `当前目录 ${formatHomePath(opts.cwd)}` : "这台电脑";
+        const who = opts.sources.map(sourceLabel).join(" / ");
+        console.log("");
+        console.log(`  在${where}没找到 ${who} 的历史对话。`);
+        if (opts.cwd)
+            console.log("  想全盘扫一遍可以: u1s1 import --all");
+        console.log("");
+        return;
+    }
+    const pending = [];
+    let already = 0;
+    for (const session of limited) {
+        const prev = index.items[recordKey(session)];
+        if (prev && !opts.force) {
+            already += 1;
+            continue;
+        }
+        pending.push(session);
+    }
+    console.log("");
+    console.log(`  找到 ${limited.length} 段对话` +
+        (opts.cwd ? `（${formatHomePath(opts.cwd)}）` : "") +
+        (already ? `，其中 ${already} 段以前导过` : "") +
+        "。");
+    const preview = await Promise.all(pending.slice(0, 12).map(hydrateSession));
+    for (const session of preview) {
+        const title = session.title ? oneLine(session.title, 56) : "(无标题)";
+        console.log(`    · [${sourceLabel(session.source)}] ${title}`);
+        if (!opts.cwd && session.cwd)
+            console.log(`      ${formatHomePath(session.cwd)}`);
+    }
+    if (pending.length > preview.length) {
+        console.log(`    …还有 ${pending.length - preview.length} 段`);
+    }
+    if (pending.length === 0) {
+        console.log("");
+        console.log("  没有新的可导。想重导一遍就加 --force。");
+        console.log("");
+        return;
+    }
+    if (opts.dryRun) {
+        console.log("");
+        console.log(`  预演结束,以上 ${pending.length} 段还没真正导入。`);
+        console.log("");
+        return;
+    }
+    if (!yes) {
+        const ok = await confirm(`  导入这 ${pending.length} 段?(回车=好 / n=取消) `);
+        if (!ok) {
+            console.log("  已取消。");
+            return;
+        }
+    }
+    const summary = runImport(pending, index, opts);
+    writeJson(importIndexPath(), index);
+    console.log("");
+    console.log(`  ✓ 导入 ${summary.imported} 段` +
+        (summary.skipped ? `，跳过 ${summary.skipped}` : "") +
+        (summary.empty ? `，空对话 ${summary.empty}` : "") +
+        (summary.errors ? `，失败 ${summary.errors}` : "") +
+        "。");
+    if (summary.imported > 0) {
+        console.log("  进对应项目跑 u1s1,输入 /resume 就能接着聊。");
+    }
+    for (const item of summary.items) {
+        if (item.status === "error")
+            console.log(`    × ${item.title}: ${item.detail ?? "失败"}`);
+        else if (item.status === "skipped" && item.detail)
+            console.log(`    · 跳过 ${item.title}: ${item.detail}`);
+    }
+    console.log("");
+}
+function runImport(sessions, index, opts) {
+    const items = [];
+    let imported = 0;
+    let skipped = 0;
+    let empty = 0;
+    let errors = 0;
+    for (const session of sessions) {
+        const adapter = ADAPTERS[session.source];
+        const title = session.title ? oneLine(session.title, 56) : session.sourceId;
+        try {
+            let size = 0;
+            try {
+                size = statSync(session.sourcePath).size;
+            }
+            catch {
+                size = 0;
+            }
+            if (size > MAX_SOURCE_BYTES) {
+                items.push({
+                    source: session.source,
+                    sourceId: session.sourceId,
+                    title,
+                    cwd: session.cwd,
+                    status: "skipped",
+                    detail: `原始记录太大(${formatBytes(size)}),先跳过`,
+                });
+                skipped += 1;
+                continue;
+            }
+            const converted = adapter.convert(session);
+            if (opts.cwd && converted.cwd && !sessionBelongsToCwd(converted.cwd, opts.cwd)) {
+                items.push({
+                    source: session.source,
+                    sourceId: session.sourceId,
+                    title,
+                    cwd: converted.cwd,
+                    status: "skipped",
+                    detail: "不属于当前目录",
+                });
+                skipped += 1;
+                continue;
+            }
+            if (converted.messages.length === 0) {
+                items.push({
+                    source: session.source,
+                    sourceId: session.sourceId,
+                    title,
+                    cwd: converted.cwd,
+                    status: "empty",
+                });
+                empty += 1;
+                continue;
+            }
+            const named = converted.title?.trim() || title;
+            converted.title = `[${sourceLabel(session.source)}] ${named}`;
+            const destCwd = opts.cwd || converted.cwd;
+            const destPath = writeConvertedSession(converted, destCwd);
+            const rec = {
+                source: session.source,
+                sourceId: session.sourceId,
+                sourcePath: session.sourcePath,
+                destPath,
+                cwd: destCwd,
+                title: converted.title,
+                importedAt: new Date().toISOString(),
+            };
+            index.items[recordKey(session)] = rec;
+            items.push({
+                source: session.source,
+                sourceId: session.sourceId,
+                title: converted.title ?? title,
+                cwd: destCwd,
+                destPath,
+                status: "imported",
+            });
+            imported += 1;
+        }
+        catch (e) {
+            items.push({
+                source: session.source,
+                sourceId: session.sourceId,
+                title,
+                cwd: session.cwd,
+                status: "error",
+                detail: e instanceof Error ? e.message : String(e),
+            });
+            errors += 1;
+        }
+    }
+    return { items, imported, skipped, empty, errors };
+}

package/dist/import/types.js

@@ -0,0 +1 @@
+export {};

package/dist/import/util.js

@@ -0,0 +1,231 @@
+import { closeSync, existsSync, openSync, readSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const MAX_TOOL_RESULT_CHARS = 80_000;
+export const MAX_TEXT_CHARS = 200_000;
+export const PREVIEW_TITLE_CHARS = 48;
+export function resolveExistingDir(path) {
+    try {
+        if (!existsSync(path))
+            return undefined;
+        const real = realpathSync(path);
+        return statSync(real).isDirectory() ? real : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function listHomeClaudeDirs() {
+    const home = homedir();
+    const out = [];
+    try {
+        for (const name of readdirSync(home)) {
+            if (name === ".claude" || name.startsWith(".claude-"))
+                out.push(join(home, name));
+        }
+    }
+    catch {
+        return [];
+    }
+    return out;
+}
+export function uniqueExistingDirs(paths) {
+    const seen = new Set();
+    const out = [];
+    for (const path of paths) {
+        if (!path)
+            continue;
+        const real = resolveExistingDir(path);
+        if (!real || seen.has(real))
+            continue;
+        seen.add(real);
+        out.push(real);
+    }
+    return out;
+}
+export function encodeClaudeProjectDir(cwd) {
+    const normalized = cwd.replace(/\\/g, "/");
+    return normalized.replace(/[/:]/g, "-");
+}
+export function samePath(a, b) {
+    const na = a.replace(/\\/g, "/").replace(/\/+$/, "");
+    const nb = b.replace(/\\/g, "/").replace(/\/+$/, "");
+    return na === nb;
+}
+function normPath(p) {
+    return p.replace(/\\/g, "/").replace(/\/+$/, "") || "/";
+}
+/** Nearest git root at or above cwd. Stops at home so `~/` is never treated as a mega-project. */
+export function projectRoot(cwd) {
+    const home = normPath(homedir());
+    let cur = normPath(cwd);
+    while (true) {
+        if (existsSync(join(cur, ".git")))
+            return cur;
+        if (cur === "/" || cur === home)
+            return undefined;
+        const slash = cur.lastIndexOf("/");
+        const next = slash <= 0 ? "/" : cur.slice(0, slash);
+        if (next === cur)
+            return undefined;
+        cur = next;
+    }
+}
+/** cwd + ancestors up to the git root (or just cwd when there is no repo). */
+export function projectAncestors(cwd) {
+    const root = projectRoot(cwd);
+    const out = [];
+    let cur = normPath(cwd);
+    while (true) {
+        out.push(cur);
+        if (!root || cur === root)
+            break;
+        const slash = cur.lastIndexOf("/");
+        const next = slash <= 0 ? "/" : cur.slice(0, slash);
+        if (next === cur)
+            break;
+        cur = next;
+    }
+    return out;
+}
+/** Same folder, anywhere inside this git repo, or the repo root when you're in a subfolder. */
+export function sessionBelongsToCwd(sessionCwd, wanted) {
+    if (!sessionCwd || !wanted)
+        return false;
+    const s = normPath(sessionCwd);
+    const w = normPath(wanted);
+    if (s === w)
+        return true;
+    const root = projectRoot(w);
+    if (!root)
+        return false;
+    return s === root || s.startsWith(`${root}/`);
+}
+export function parseJsonLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return undefined;
+    try {
+        const value = JSON.parse(trimmed);
+        return value && typeof value === "object" && !Array.isArray(value)
+            ? value
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function asRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function asString(value) {
+    return typeof value === "string" ? value : undefined;
+}
+export function parseTime(value) {
+    if (typeof value === "number" && Number.isFinite(value)) {
+        return value < 1e12 ? value * 1000 : value;
+    }
+    if (typeof value === "string") {
+        const ms = Date.parse(value);
+        return Number.isNaN(ms) ? undefined : ms;
+    }
+    return undefined;
+}
+export function truncateText(text, max) {
+    if (text.length <= max)
+        return text;
+    const omitted = text.length - max;
+    return `${text.slice(0, max)}\n\n[已截断,原文还有约 ${formatBytes(omitted)} ]`;
+}
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n} 字`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function oneLine(text, max = PREVIEW_TITLE_CHARS) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    if (compact.length <= max)
+        return compact;
+    return `${compact.slice(0, Math.max(0, max - 1))}…`;
+}
+export function firstMeaningfulLine(text) {
+    for (const line of text.split(/\r?\n/)) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        if (/^<\/?[a-zA-Z][\w:-]*>$/.test(t))
+            continue;
+        return t.replace(/^<\/?[a-zA-Z][\w:-]*>\s*/, "").trim() || t;
+    }
+    return "";
+}
+export function parseArgsJson(raw) {
+    try {
+        const value = JSON.parse(raw);
+        if (value && typeof value === "object" && !Array.isArray(value)) {
+            return value;
+        }
+    }
+    catch {
+        // keep raw
+    }
+    return { raw };
+}
+export function fileMtimeMs(path) {
+    try {
+        return statSync(path).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+export function isProbablyInjection(text) {
+    const start = text.trimStart();
+    return (start.startsWith("<environment_context>") ||
+        start.startsWith("<permissions instructions>") ||
+        start.startsWith("<skills_instructions>") ||
+        start.startsWith("<INSTRUCTIONS>") ||
+        start.startsWith("<turn_aborted>") ||
+        start.startsWith("<recommended_plugins>") ||
+        start.startsWith("# AGENTS.md"));
+}
+export function readFirstJsonObject(path) {
+    let fd;
+    try {
+        fd = openSync(path, "r");
+        const chunks = [];
+        let total = 0;
+        const max = 1024 * 1024;
+        while (total < max) {
+            const buf = Buffer.alloc(64 * 1024);
+            const n = readSync(fd, buf, 0, buf.length, null);
+            if (n <= 0)
+                break;
+            chunks.push(buf.subarray(0, n));
+            total += n;
+            if (buf.subarray(0, n).includes(0x0a))
+                break;
+        }
+        const chunk = Buffer.concat(chunks).toString("utf8");
+        const nl = chunk.indexOf("\n");
+        const line = nl === -1 ? chunk : chunk.slice(0, nl);
+        return parseJsonLine(line);
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                closeSync(fd);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+}

package/dist/import/write.js

@@ -0,0 +1,95 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { SessionManager } from "@earendil-works/pi-coding-agent";
+import { agentDir, loadConfig, PROVIDER_ID, resolvePreferredModel } from "../config.js";
+const EMPTY_USAGE = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+function toUsage(raw) {
+    if (!raw)
+        return EMPTY_USAGE;
+    const totalTokens = raw.input + raw.output + raw.cacheRead + raw.cacheWrite;
+    return {
+        input: raw.input,
+        output: raw.output,
+        cacheRead: raw.cacheRead,
+        cacheWrite: raw.cacheWrite,
+        totalTokens,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+    };
+}
+export function writeConvertedSession(converted, destCwd) {
+    process.env["PI_CODING_AGENT_DIR"] = agentDir;
+    const cwd = destCwd || converted.cwd || process.cwd();
+    const sm = SessionManager.create(cwd);
+    for (const msg of converted.messages) {
+        if (msg.role === "user") {
+            sm.appendMessage({
+                role: "user",
+                content: [{ type: "text", text: msg.text }],
+                timestamp: msg.timestamp,
+            });
+            continue;
+        }
+        if (msg.role === "assistant") {
+            sm.appendMessage({
+                role: "assistant",
+                content: msg.content.map((block) => {
+                    if (block.type === "text")
+                        return { type: "text", text: block.text };
+                    if (block.type === "thinking")
+                        return { type: "thinking", thinking: block.thinking };
+                    return {
+                        type: "toolCall",
+                        id: block.id,
+                        name: block.name,
+                        arguments: block.arguments,
+                    };
+                }),
+                api: msg.api,
+                provider: msg.provider,
+                model: msg.model,
+                usage: toUsage(msg.usage),
+                stopReason: msg.stopReason,
+                timestamp: msg.timestamp,
+            });
+            continue;
+        }
+        sm.appendMessage({
+            role: "toolResult",
+            toolCallId: msg.toolCallId,
+            toolName: msg.toolName,
+            content: [{ type: "text", text: msg.text }],
+            isError: msg.isError,
+            timestamp: msg.timestamp,
+        });
+    }
+    const title = converted.title?.trim();
+    if (title)
+        sm.appendSessionInfo(title);
+    // Resume should keep using u1s1 models, not the original Claude/Codex id.
+    sm.appendModelChange(PROVIDER_ID, resolvePreferredModel(loadConfig().model));
+    const dest = sm.getSessionFile();
+    if (!dest)
+        throw new Error("会话写盘失败");
+    return dest;
+}
+export function readJsonIfExists(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`);
+}