u1s1-cli 0.3.0 → 0.4.0

package/README.md

@@ -25,6 +25,7 @@ u1s1
 | `u1s1 usage` | 看额度用了多少 |
 | `u1s1 model` | 看/切默认模型:`u1s1 model grok` 切 Grok 4.6,`u1s1 model deepseek` 切回(对话里 `/model` 同样会记住) |
 | `u1s1 update` | 升级 u1s1 到最新版 |
+| `u1s1 import` | 从 Claude Code / Codex 导入历史对话,之后 `/resume` 就能接着聊 |
 | `u1s1 login` / `u1s1 logout` | 登录 / 退出 |
 
 ## 有一说一

package/dist/brand.js

@@ -14,28 +14,64 @@ export function formatHomePath(path) {
     }
     return path;
 }
-/** Compact Claude-like startup header. */
-export function renderBrandHeader(theme, version, cwd) {
-    const diamond = theme.fg("accent", "◆");
-    const name = theme.bold(theme.fg("text", BRAND_NAME));
-    const cn = theme.fg("muted", BRAND_CN);
-    const meta = theme.fg("dim", `${BRAND_TAGLINE}  ·  v${version}`);
-    const dir = theme.fg("muted", formatHomePath(cwd));
-    const hints = [
-        theme.fg("accent", "/help"),
-        theme.fg("dim", "命令"),
-        theme.fg("dim", "·"),
-        theme.fg("accent", "Shift+Enter"),
-        theme.fg("dim", "换行"),
-        theme.fg("dim", "·"),
-        theme.fg("accent", "Esc"),
-        theme.fg("dim", "中断"),
-    ].join(" ");
-    return ["", `  ${diamond}  ${name}  ${cn}`, `     ${meta}`, "", `     ${dir}`, `     ${hints}`, ""];
+// "u1s1" in FIGlet ANSI Shadow. Rows are joined per glyph so widths stay aligned.
+const GLYPH_U = ["██╗   ██╗", "██║   ██║", "██║   ██║", "██║   ██║", "╚██████╔╝", " ╚═════╝ "];
+const GLYPH_1 = [" ██╗", "███║", "╚██║", " ██║", " ██║", " ╚═╝"];
+const GLYPH_S = ["███████╗", "██╔════╝", "███████╗", "╚════██║", "███████║", "╚══════╝"];
+export const HERO_ART = GLYPH_U.map((_, r) => [GLYPH_U[r], GLYPH_1[r], GLYPH_S[r], GLYPH_1[r]].join(" "));
+const ART_WIDTH = HERO_ART[0].length;
+/** Two-tone wordmark: solid blocks in accent, box-drawing "shadow" in dim. */
+function paintArt(theme, line) {
+    let out = "";
+    let run = "";
+    let runIsBlock = null;
+    const flush = () => {
+        if (!run)
+            return;
+        out += runIsBlock === null ? run : theme.fg(runIsBlock ? "accent" : "dim", run);
+        run = "";
+    };
+    for (const ch of line) {
+        const kind = ch === " " ? null : ch === "█" ? true : false;
+        if (kind !== runIsBlock) {
+            flush();
+            runIsBlock = kind;
+        }
+        run += ch;
+    }
+    flush();
+    return out;
+}
+/**
+ * Startup hero, responsive to terminal width:
+ * wide → wordmark with info column beside it; medium → stacked; narrow → one-liner.
+ */
+export function renderBrandHeader(theme, version, cwd, width) {
+    const name = theme.bold(theme.fg("text", `${BRAND_NAME} v${version}`));
+    const brand = theme.fg("muted", `${BRAND_CN} · ${BRAND_TAGLINE}`);
+    const dir = theme.fg("dim", `cwd: ${formatHomePath(cwd)}`);
+    const hints = theme.fg("dim", "/help 看命令 · Shift+Enter 换行 · Esc 中断");
+    if (width < ART_WIDTH + 4) {
+        return ["", ` ${theme.fg("accent", "✻")} ${name}  ${theme.fg("muted", BRAND_CN)}`, `   ${dir}`, ""];
+    }
+    const art = HERO_ART.map((line) => ` ${paintArt(theme, line)}`);
+    // widest info row (hints) needs 46 cols beside the 28-col wordmark
+    if (width < ART_WIDTH + 46) {
+        return ["", ...art, "", ` ${name}  ${brand}`, ` ${dir}`, ""];
+    }
+    const rows = [...art];
+    const gap = "   ";
+    rows[1] += `${gap}${name}`;
+    rows[2] += `${gap}${brand}`;
+    rows[3] += `${gap}${dir}`;
+    rows[4] += `${gap}${hints}`;
+    return ["", ...rows, ""];
 }
 export function printConsoleBanner(version) {
     console.log("");
-    console.log(`  ◆  ${BRAND_NAME}  ${BRAND_CN}`);
-    console.log(`     ${BRAND_TAGLINE}  ·  v${version}`);
+    for (const line of HERO_ART)
+        console.log(` ${line}`);
+    console.log("");
+    console.log(` ${BRAND_NAME} v${version} — ${BRAND_CN}，${BRAND_TAGLINE}`);
     console.log("");
 }

package/dist/import/claude.js

@@ -0,0 +1,372 @@
+import { createReadStream, existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, join } from "node:path";
+import { createInterface } from "node:readline";
+import { asRecord, asString, encodeClaudeProjectDir, fileMtimeMs, firstMeaningfulLine, listHomeClaudeDirs, MAX_TEXT_CHARS, MAX_TOOL_RESULT_CHARS, oneLine, parseJsonLine, parseTime, projectAncestors, projectRoot, truncateText, uniqueExistingDirs, } from "./util.js";
+const CLAUDE_TOOL_MAP = {
+    bash: "bash",
+    read: "read",
+    edit: "edit",
+    write: "write",
+    glob: "find",
+    grep: "grep",
+    ls: "ls",
+};
+function claudeHomes() {
+    return uniqueExistingDirs([
+        process.env["CLAUDE_CONFIG_DIR"],
+        ...listHomeClaudeDirs(),
+        join(homedir(), ".claude"),
+    ]);
+}
+function decodeProjectDirName(name) {
+    if (!name.startsWith("-"))
+        return undefined;
+    return `/${name.slice(1).replace(/-/g, "/")}`;
+}
+function claudeDirMatchesCwd(dirName, cwd) {
+    const encoded = new Set(projectAncestors(cwd).map(encodeClaudeProjectDir));
+    if (encoded.has(dirName))
+        return true;
+    const root = projectRoot(cwd);
+    if (!root)
+        return false;
+    // sessions that happened in a subfolder of this repo
+    return dirName.startsWith(`${encodeClaudeProjectDir(root)}-`);
+}
+function extractCwd(obj) {
+    return asString(obj["cwd"]);
+}
+function extractTitle(obj) {
+    return asString(obj["aiTitle"]) ?? asString(obj["title"]);
+}
+function isToolResultContent(content) {
+    if (!Array.isArray(content))
+        return false;
+    return content.some((block) => asRecord(block)?.["type"] === "tool_result");
+}
+function flattenClaudeContent(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const raw of content) {
+        const block = asRecord(raw);
+        if (!block)
+            continue;
+        const type = asString(block["type"]);
+        if (type === "text" || type === "input_text" || type === "output_text") {
+            const text = asString(block["text"]);
+            if (text)
+                parts.push(text);
+        }
+    }
+    return parts.join("\n");
+}
+function flattenToolResult(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content)) {
+        if (content == null)
+            return "";
+        try {
+            return JSON.stringify(content);
+        }
+        catch {
+            return String(content);
+        }
+    }
+    const parts = [];
+    for (const raw of content) {
+        if (typeof raw === "string") {
+            parts.push(raw);
+            continue;
+        }
+        const block = asRecord(raw);
+        if (!block)
+            continue;
+        const text = asString(block["text"]) ?? asString(block["content"]);
+        if (text)
+            parts.push(text);
+    }
+    return parts.join("\n");
+}
+function mapToolName(name) {
+    return CLAUDE_TOOL_MAP[name.toLowerCase()] ?? name;
+}
+function omit(obj, keys) {
+    const skip = new Set(keys);
+    const out = {};
+    for (const [k, v] of Object.entries(obj)) {
+        if (!skip.has(k))
+            out[k] = v;
+    }
+    return out;
+}
+function remapToolArgs(name, input) {
+    const mapped = mapToolName(name);
+    if (mapped === "read") {
+        const path = asString(input["file_path"]) ?? asString(input["path"]);
+        return path ? { path, ...omit(input, ["file_path", "path"]) } : input;
+    }
+    if (mapped === "write") {
+        const path = asString(input["file_path"]) ?? asString(input["path"]);
+        const content = asString(input["content"]) ?? asString(input["contents"]);
+        return {
+            ...(path ? { path } : {}),
+            ...(content !== undefined ? { content } : {}),
+            ...omit(input, ["file_path", "path", "content", "contents"]),
+        };
+    }
+    if (mapped === "edit") {
+        const path = asString(input["file_path"]) ?? asString(input["path"]);
+        return path ? { path, ...omit(input, ["file_path", "path"]) } : input;
+    }
+    if (mapped === "find") {
+        const pattern = asString(input["pattern"]) ?? asString(input["glob"]);
+        return pattern ? { pattern, ...omit(input, ["pattern", "glob"]) } : input;
+    }
+    return input;
+}
+function usageFromClaude(raw) {
+    const usage = asRecord(raw);
+    if (!usage)
+        return undefined;
+    const input = Number(usage["input_tokens"] ?? 0);
+    const output = Number(usage["output_tokens"] ?? 0);
+    const cacheRead = Number(usage["cache_read_input_tokens"] ?? 0);
+    const cacheWrite = Number(usage["cache_creation_input_tokens"] ?? 0);
+    if (![input, output, cacheRead, cacheWrite].some((n) => n > 0))
+        return undefined;
+    return { input, output, cacheRead, cacheWrite };
+}
+function firstUserPreview(obj) {
+    if (obj["type"] !== "user" || obj["isSidechain"] === true)
+        return undefined;
+    const msg = asRecord(obj["message"]);
+    if (!msg || isToolResultContent(msg["content"]))
+        return undefined;
+    const text = flattenClaudeContent(msg["content"]).trim();
+    if (!text)
+        return undefined;
+    return oneLine(firstMeaningfulLine(text) || text);
+}
+export async function hydrateClaudeSession(session) {
+    const stream = createReadStream(session.sourcePath, { encoding: "utf8" });
+    const rl = createInterface({ input: stream, crlfDelay: Infinity });
+    let cwd = "";
+    let title = session.title;
+    let sourceId = session.sourceId;
+    let startedAt = session.startedAt;
+    let preview;
+    let lines = 0;
+    try {
+        for await (const line of rl) {
+            lines += 1;
+            const obj = parseJsonLine(line);
+            if (!obj)
+                continue;
+            if (!sourceId)
+                sourceId = asString(obj["sessionId"]) ?? sourceId;
+            if (!cwd)
+                cwd = extractCwd(obj) ?? "";
+            if (!title)
+                title = extractTitle(obj) ?? title;
+            if (!startedAt)
+                startedAt = parseTime(obj["timestamp"]);
+            if (!preview)
+                preview = firstUserPreview(obj);
+            if (cwd && (title || preview) && sourceId && lines > 80)
+                break;
+            if (lines > 400)
+                break;
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    return {
+        ...session,
+        sourceId: sourceId || session.sourceId,
+        cwd: cwd || session.cwd,
+        title: title || preview || session.title,
+        startedAt: startedAt ?? session.startedAt,
+    };
+}
+export const claudeAdapter = {
+    id: "claude",
+    label: "Claude Code",
+    discover(opts) {
+        const wanted = opts.cwd;
+        const seen = new Set();
+        const found = [];
+        for (const home of claudeHomes()) {
+            const projectsRoot = join(home, "projects");
+            if (!existsSync(projectsRoot))
+                continue;
+            let projectDirs = [];
+            try {
+                projectDirs = readdirSync(projectsRoot)
+                    .map((name) => join(projectsRoot, name))
+                    .filter((dir) => {
+                    try {
+                        return statSync(dir).isDirectory();
+                    }
+                    catch {
+                        return false;
+                    }
+                });
+            }
+            catch {
+                continue;
+            }
+            for (const projectDir of projectDirs) {
+                const dirName = basename(projectDir);
+                if (wanted && !claudeDirMatchesCwd(dirName, wanted))
+                    continue;
+                let files = [];
+                try {
+                    files = readdirSync(projectDir)
+                        .filter((name) => name.endsWith(".jsonl"))
+                        .map((name) => join(projectDir, name));
+                }
+                catch {
+                    continue;
+                }
+                for (const file of files) {
+                    let real = file;
+                    try {
+                        real = realpathSync(file);
+                    }
+                    catch {
+                        // keep original
+                    }
+                    if (seen.has(real))
+                        continue;
+                    seen.add(real);
+                    found.push({
+                        source: "claude",
+                        sourceId: basename(file, ".jsonl"),
+                        sourcePath: real,
+                        cwd: wanted ?? decodeProjectDirName(dirName) ?? "",
+                        mtimeMs: fileMtimeMs(real),
+                    });
+                }
+            }
+        }
+        return found;
+    },
+    convert(session) {
+        let text = "";
+        try {
+            // Large Claude transcripts can be tens of MB; still fine as a one-shot import.
+            text = readFileSync(session.sourcePath, "utf8");
+        }
+        catch {
+            return { cwd: session.cwd || process.cwd(), title: session.title, messages: [] };
+        }
+        const messages = [];
+        let cwd = "";
+        let title = session.title;
+        const pendingTools = new Map();
+        for (const line of text.split(/\r?\n/)) {
+            if (line.length > 8_000_000)
+                continue;
+            const obj = parseJsonLine(line);
+            if (!obj)
+                continue;
+            const type = asString(obj["type"]);
+            if (!cwd)
+                cwd = extractCwd(obj) ?? cwd;
+            if (!title && type === "ai-title")
+                title = extractTitle(obj) ?? title;
+            if (obj["isSidechain"] === true)
+                continue;
+            if (type === "user") {
+                const msg = asRecord(obj["message"]);
+                if (!msg)
+                    continue;
+                const content = msg["content"];
+                const ts = parseTime(obj["timestamp"]) ?? Date.now();
+                if (isToolResultContent(content) && Array.isArray(content)) {
+                    for (const raw of content) {
+                        const block = asRecord(raw);
+                        if (!block || block["type"] !== "tool_result")
+                            continue;
+                        const callId = asString(block["tool_use_id"]) ?? "";
+                        if (!callId)
+                            continue;
+                        messages.push({
+                            role: "toolResult",
+                            toolCallId: callId,
+                            toolName: pendingTools.get(callId) ?? "unknown",
+                            text: truncateText(flattenToolResult(block["content"]), MAX_TOOL_RESULT_CHARS),
+                            isError: block["is_error"] === true,
+                            timestamp: ts,
+                        });
+                    }
+                    continue;
+                }
+                const userText = truncateText(flattenClaudeContent(content), MAX_TEXT_CHARS).trim();
+                if (!userText)
+                    continue;
+                if (!title)
+                    title = oneLine(firstMeaningfulLine(userText) || userText);
+                messages.push({ role: "user", text: userText, timestamp: ts });
+                continue;
+            }
+            if (type !== "assistant")
+                continue;
+            const msg = asRecord(obj["message"]);
+            if (!msg)
+                continue;
+            const ts = parseTime(obj["timestamp"]) ?? Date.now();
+            const blocks = Array.isArray(msg["content"]) ? msg["content"] : [];
+            const content = [];
+            let sawTool = false;
+            for (const raw of blocks) {
+                const block = asRecord(raw);
+                if (!block)
+                    continue;
+                const btype = asString(block["type"]);
+                if (btype === "thinking") {
+                    const thinking = asString(block["thinking"]) ?? "";
+                    if (thinking.trim())
+                        content.push({ type: "thinking", thinking: truncateText(thinking, MAX_TEXT_CHARS) });
+                }
+                else if (btype === "text") {
+                    const textBlock = asString(block["text"]) ?? "";
+                    if (textBlock.trim())
+                        content.push({ type: "text", text: truncateText(textBlock, MAX_TEXT_CHARS) });
+                }
+                else if (btype === "tool_use") {
+                    const id = asString(block["id"]) ?? "";
+                    const name = asString(block["name"]) ?? "unknown";
+                    if (!id)
+                        continue;
+                    const input = asRecord(block["input"]) ?? {};
+                    const mapped = mapToolName(name);
+                    pendingTools.set(id, mapped);
+                    content.push({ type: "toolCall", id, name: mapped, arguments: remapToolArgs(name, input) });
+                    sawTool = true;
+                }
+            }
+            if (content.length === 0)
+                continue;
+            const stop = asString(msg["stop_reason"]);
+            messages.push({
+                role: "assistant",
+                content,
+                provider: "anthropic",
+                model: asString(msg["model"]) ?? "claude",
+                api: "anthropic-messages",
+                stopReason: sawTool || stop === "tool_use" ? "toolUse" : stop === "max_tokens" ? "length" : "stop",
+                usage: usageFromClaude(msg["usage"]),
+                timestamp: ts,
+            });
+        }
+        return { cwd: cwd || session.cwd || process.cwd(), title, messages };
+    },
+};