u1s1-cli 0.2.0 → 0.4.0

package/README.md

@@ -1,6 +1,6 @@
 # u1s1 — 有一说一,最省心的 AI 编程搭子
 
-在终端里用中文说需求,AI 帮你读文件、改代码、跑命令。不用买模型、不用配 API、不用懂那些名词,注册就送**每月 $2 免费额度**(普通人根本用不完)。
+在终端里用中文说需求,AI 帮你读文件、改代码、跑命令。不用买模型、不用配 API、不用懂那些名词,注册就送**$10 免费额度**(一次性,用完不补)。
 
 ## 三步开始
 
@@ -22,14 +22,16 @@ u1s1
 |---|---|
 | `u1s1` | 进入交互模式,直接开聊 |
 | `u1s1 -p "把 README 里的错别字修一下"` | 一句话模式,干完就退出 |
-| `u1s1 usage` | 看本月额度用了多少 |
-| `u1s1 model` | 看/切模型:`u1s1 model grok` 切 Grok 4.6,`u1s1 model deepseek` 切回 |
+| `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` | 登录 / 退出 |
 
 ## 有一说一
 
-- **背后模型**:默认 DeepSeek V4 Flash(1M 上下文,便宜大碗);难题可随时 `u1s1 model grok` 切 Grok 4.6(更强,但烧额度快约 20 倍)。对话中用 `/model` 可临时切换。
-- **怎么收费**:额度按 API 实际成本扣,不加价;每月 1 号自动重置。
+- **背后模型**:默认 DeepSeek V4 Flash(1M 上下文,便宜大碗);难题可随时 `u1s1 model grok` 切 Grok 4.6(更强,但烧额度快约 20 倍)。对话里 `/model` 也会记住,下次启动还是这个。
+- **怎么收费**:额度按 API 实际成本扣,不加价;新用户一次性送 $10,用完不补。
 - **额度不够**:邀请朋友,你俩各得 $1 加量,永不过期 → [u1s1.io/dashboard](https://u1s1.io/dashboard)
 - **内核**:基于开源的 [pi](https://pi.dev) coding agent,会话管理、斜杠命令、皮肤等能力全都有。
 

package/dist/brand.js

@@ -0,0 +1,77 @@
+import { homedir } from "node:os";
+import { resolve } from "node:path";
+export const BRAND_NAME = "u1s1";
+export const BRAND_CN = "有一说一";
+export const BRAND_TAGLINE = "说人话的 AI 编程搭子";
+export const DASHBOARD_URL = "https://u1s1.io/dashboard";
+export function formatHomePath(path) {
+    const home = homedir();
+    const resolved = resolve(path);
+    if (resolved === home)
+        return "~";
+    if (resolved.startsWith(`${home}/`) || resolved.startsWith(`${home}\\`)) {
+        return `~${resolved.slice(home.length)}`;
+    }
+    return path;
+}
+// "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("");
+    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/config.js

@@ -34,16 +34,47 @@ export const u1s1Dir = join(homedir(), ".u1s1");
 const configFile = join(u1s1Dir, "config.json");
 /** pi keeps auth/models/settings/sessions under this dir — isolated from any real pi install. */
 export const agentDir = join(u1s1Dir, "agent");
-export function loadConfig() {
-    let file = {};
-    if (existsSync(configFile)) {
-        try {
-            file = JSON.parse(readFileSync(configFile, "utf8"));
-        }
-        catch {
-            // corrupted config falls back to defaults; login rewrites it
-        }
+const agentSettingsFile = join(agentDir, "settings.json");
+function readJsonFile(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return JSON.parse(readFileSync(path, "utf8"));
+    }
+    catch {
+        return undefined;
     }
+}
+/** Model last chosen in-session via /model (pi writes this). */
+export function readAgentDefaultModel() {
+    const settings = readJsonFile(agentSettingsFile);
+    if (!settings)
+        return undefined;
+    if (settings["defaultProvider"] !== PROVIDER_ID)
+        return undefined;
+    const id = settings["defaultModel"];
+    return typeof id === "string" && resolveModel(id) ? id : undefined;
+}
+/** Keep pi's settings.json in sync so /model and `u1s1 model` share one default. */
+export function writeAgentDefaultModel(modelId) {
+    mkdirSync(agentDir, { recursive: true });
+    const settings = readJsonFile(agentSettingsFile) ?? {};
+    if (settings["defaultProvider"] === PROVIDER_ID && settings["defaultModel"] === modelId)
+        return;
+    settings["defaultProvider"] = PROVIDER_ID;
+    settings["defaultModel"] = modelId;
+    writeFileSync(agentSettingsFile, JSON.stringify(settings, null, 2) + "\n");
+}
+/**
+ * After this fix both stores stay in sync. If they still disagree (old installs),
+ * prefer the in-session /model value — that's the one users thought they had set.
+ */
+export function resolvePreferredModel(configModel) {
+    const agentModel = readAgentDefaultModel();
+    return agentModel ?? configModel ?? DEFAULT_MODEL_ID;
+}
+export function loadConfig() {
+    const file = (readJsonFile(configFile) ?? {});
     return {
         apiKey: process.env["U1S1_API_KEY"] || file.apiKey,
         baseUrl: process.env["U1S1_BASE_URL"] || file.baseUrl || DEFAULT_BASE_URL,
@@ -55,3 +86,10 @@ export function saveConfig(cfg) {
     writeFileSync(configFile, JSON.stringify(cfg, null, 2) + "\n");
     chmodSync(configFile, 0o600);
 }
+/** Persist the user's preferred model to both stores. */
+export function persistPreferredModel(cfg, modelId) {
+    const next = { ...cfg, model: modelId };
+    saveConfig(next);
+    writeAgentDefaultModel(modelId);
+    return next;
+}

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 };
+    },
+};