thincoder 0.1.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,162 @@
+# ThinCoder
+
+**Sharp Code, Zero Bloat.**
+
+**一个"薄"的 AI 编程 agent：纯 `.mjs`、无构建、零 npm 依赖、Node.js 原生。**
+
+ThinCoder 的 "Thin" 不是"功能单薄"，而是**思维锐利、直击要害**——像刀刃。
+在 AI agent 都在卷"全能"的今天，ThinCoder 打的是反面那张牌：**克制、精准、不废话**。
+它的人设是一个"话不多、一刀见血"的极客工程师：你给它复杂需求，它还你干净实现。
+
+设计哲学（也是这个名字的全部含义）：只用 Node 标准库能实现的功能，就绝不引入依赖。整个项目的 `node_modules` 是空的。
+
+## 特性
+
+- **Agent 主循环**：LLM ↔ 工具调用循环，直到任务完成（上限 50 轮防失控）
+- **工具集**：`read` / `write` / `edit` / `bash` / `glob` / `grep` / `websearch` / `ls` / `fetch`，全部零依赖实现
+- **两段式工具调度**：权限确认串行（一个一个问），只读工具并行执行，有副作用工具串行
+- **会话持久化**：退出自动保存，启动自动恢复（按项目目录隔离），`/new` 开始新会话
+- **子 agent 并发**：`subagent` 工具派发独立子任务（隔离上下文，只带回报告），一批多个走并行通道；普通模式子 agent 只读，AUTO 模式全放行
+- **AUTO 模式**：`/auto` 或 `chat --auto` 完全授权，长任务免确认，状态栏黄色 AUTO 标识
+- **任务跟踪**：`task` 工具让 agent 拆解多步任务并跟踪进度（pending/in_progress/done），TUI 状态栏实时显示 ▶n/m
+- **流式 TUI**：裸 ANSI 实现（无 UI 库），对话流 / 流式输出 / 权限确认 / 翻页 / 输入历史 / 斜杠命令
+- **上下文压缩**：对话超阈值时自动摘要（保留最早 2 条 + 最近 10 条，中间 LLM 摘要）
+- **三层记忆 + 团队共享**（见下）
+- **LLM 调用**：原生 `fetch` 直连 OpenAI 兼容协议（OpenAI / DeepSeek / Moonshot / Ollama），流式 SSE，指数退避重试，支持 `reasoning_content` 思考流
+
+## 记忆系统：一人学到，全队皆知
+
+三层记忆，全部"有就查、没有就跳过"，统一混合检索：
+
+| 层 | 位置 | 同步方式 |
+|---|---|---|
+| **Personal** | `~/.thincoder/memory.db`（sqlite） | 不同步，私有 |
+| **Project** | 项目仓库 `.thincoder/memory/*.md` | 随项目 git（ThinCoder **只写文件，绝不替你 commit**） |
+| **Team**（可选） | 独立记忆仓库，clone 到 `~/.thincoder/teams/<name>/` | `thincoder sync`（pull --rebase）；写入时自动 commit + push（专用设施，可选启用） |
+
+- **混合检索**：FTS5（BM25，中文逐字索引，双字词可命中）+ embedding 向量（暴力余弦）+ RRF(k=60) 融合排序
+- **embedding**：OpenAI 兼容 `/v1/embeddings`，默认 SiliconFlow `BAAI/bge-m3`（免费额度，中文好）；Ollama 本地可作离线选项。向量惰性生成——写入不算，首次搜索时补算落库
+- **条目格式**：Markdown + frontmatter（type/title/tags/author/created），GitHub 上直接可读可 review；每条目一个文件，天然规避合并冲突；真冲突时诚实报错，绝不自动合并
+- **双轨沉淀**：规范靠手动写（`memory_put`），经验靠 `/distill` 从会话提取——**LLM 出候选、逐条人工 y/n 确认**才入库，绝不做全自动沉淀
+- **检索隔离**：Project 层按项目路径隔离，A 项目的记忆不会漏进 B 项目
+
+## 要求
+
+- Node.js >= 22（记忆功能用到 `node:sqlite`；推荐 24）
+- 一个 OpenAI 兼容端点的 API key
+- 可选：embedding 服务的 key（不配置则退化为纯 FTS 检索）
+
+## 快速开始
+
+```bash
+# 配置（首次）
+mkdir -p ~/.thincoder
+cat > ~/.thincoder/config.json <<'EOF'
+{
+  "provider": {
+    "baseURL": "https://api.deepseek.com/v1",
+    "apiKey": "sk-...",
+    "model": "deepseek-chat"
+  }
+}
+EOF
+
+# 启动 TUI（默认命令）
+node bin/thincoder.mjs
+
+# 一次性问答（管道友好）
+node bin/thincoder.mjs chat "读一下 package.json 并总结"
+
+# 记忆管理
+node bin/thincoder.mjs memory put --type=rule --title="代码规范" --content="不加分号"
+node bin/thincoder.mjs memory search "代码规范"
+node bin/thincoder.mjs memory list
+node bin/thincoder.mjs memory remove 1
+
+# 团队记忆（可选，配置 memory.team 后可用）
+node bin/thincoder.mjs sync                       # 拉取团队仓库并重建索引
+
+# 从会话记录提取知识（逐条确认后入库）
+node bin/thincoder.mjs distill session.txt
+```
+
+TUI 内斜杠命令：`/help`、`/model`（查看/切换模型）、`/config`（查看配置）、`/distill`（从当前会话提取知识）、`/clear`、`/exit`。输入 `/` 时状态栏实时提示匹配命令。
+
+环境变量：`THINCODER_API_KEY`（或 `DEEPSEEK_API_KEY` / `OPENAI_API_KEY`）、`THINCODER_BASE_URL`、`THINCODER_MODEL`、`SILICONFLOW_API_KEY`。
+
+## 配置
+
+`~/.thincoder/config.json`：
+
+```jsonc
+{
+  "provider": {
+    "baseURL": "https://api.deepseek.com/v1",  // 任意 OpenAI 兼容端点
+    "apiKey": "sk-...",                         // 或留空走环境变量
+    "model": "deepseek-chat"
+  },
+  "embedding": {                                // 可选：不配则纯 FTS 检索
+    "baseURL": "https://api.siliconflow.cn/v1",
+    "apiKey": "sk-...",                         // 或 SILICONFLOW_API_KEY
+    "model": "BAAI/bge-m3"
+  },
+  "agent": {
+    "maxTurns": 50,                             // 工具循环上限
+    "compactThreshold": 100000                  // 上下文压缩阈值（约 token 数）
+  },
+  "memory": {
+    "dbPath": "~/.thincoder/memory.db",         // sqlite 索引库路径
+    "projectDir": ".thincoder/memory",          // Project 层目录（相对项目根）
+    "team": {                                   // 可选：不配则 Team 层禁用
+      "name": "myteam",
+      "repo": "git@github.com:org/team-memory.git"
+    }
+  }
+}
+```
+
+## 架构
+
+```
+bin/thincoder.mjs   命令入口（tui / chat / memory / sync / distill）
+src/
+  provider.mjs      LLM 调用（fetch, SSE 流式, 重试）
+  embedding.mjs     向量嵌入（OpenAI 兼容 /v1/embeddings）
+  tools.mjs         9 个内置工具 + readonly 调度标记
+  agent.mjs         主循环 + 两段式工具执行 + 记忆注入
+  context.mjs       token 粗估 + 历史压缩
+  memory.mjs        记忆核心：三层合并检索（FTS5 + 向量 + RRF）
+  markdown.mjs      条目格式（frontmatter 解析/序列化）
+  gitmem.mjs        Team 层 git 同步（clone/pull --rebase/push，系统 git）
+  distill.mjs       会话知识提取（候选 + 人工确认）
+  config.mjs        配置加载
+  tui.mjs           裸 ANSI 终端 UI（宽字符折行、滚动、权限确认、斜杠命令）
+test/               node:test 离线单测（npm test）
+scripts/            真实环境验证脚本（压缩、团队同步）
+```
+
+关键设计：
+
+- **工具执行两段式**：阶段一串行做权限确认（有副作用工具逐个问用户）；阶段二只读工具 `Promise.all` 并行、有副作用工具串行。结果按 `toolCallId` 配对回喂
+- **权限在 UI 层**：工具只负责执行，"问不问用户"是 TUI/CLI 的事，headless 场景不用改工具
+- **索引是易失品**：sqlite 只是 markdown 真相源的本地索引，`reindex` 随时可重建；git 仓库才是团队记忆的真相源
+- **git 边界**：Project 层只写文件不碰用户的仓库；Team 层是 ThinCoder 自管仓库才可自动 commit+push
+- **中文检索**：FTS5 unicode61 + 写入/查询两侧 CJK 逐字加空格；语义匹配走向量通道
+
+## 开发
+
+```bash
+npm test                          # 离线单测（node:test，含本地 mock 服务）
+node scripts/verify-compress.mjs  # 上下文压缩的真实 API 验证（需要有效配置）
+node scripts/verify-team.mjs      # 团队记忆 A->git->B 全链路验证（本地 git，离线）
+```
+
+代码约定：纯 `.mjs`，不加分号，禁止引入 npm 依赖（包括开发依赖）。
+
+## 路线图
+
+- v3 候选：checkpoint 断点恢复、子 agent 并行、MCP 接入
+
+## License
+
+MIT

package/bin/thincoder.mjs

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+
+/**
+ * thincoder — 命令入口
+ *   thincoder                 启动 TUI
+ *   thincoder chat "..."      一次性 agent 问答（可调用工具，流式输出）
+ *   thincoder memory <sub>    记忆管理：list / search / put / remove
+ *   thincoder --help          显示帮助
+ */
+
+import { readFileSync } from "node:fs"
+import { createInterface } from "node:readline"
+import { execSync } from "node:child_process"
+import { join } from "node:path"
+import { createAgent, runAgent } from "../src/agent.mjs"
+import { loadConfig, configDir } from "../src/config.mjs"
+import { createMemory, memoryTools, put, remove, search, list, syncDir } from "../src/memory.mjs"
+import { createProvider } from "../src/provider.mjs"
+import { builtinTools } from "../src/tools.mjs"
+
+const [command, ...args] = process.argv.slice(2)
+
+const USAGE = `thincoder - thin coding agent
+
+Usage:
+  thincoder                 Launch the interactive TUI
+  thincoder chat <prompt>   One-shot agent run (tools enabled), streams reply to stdout
+  thincoder memory list [--type=<t>]           List memory entries
+  thincoder memory search <query>              Search memory
+  thincoder memory put --type=<t> --title=<t> --content=<c> [--tags=<t>]
+  thincoder memory remove <id>                 Remove an entry
+  thincoder sync              Sync team memory repo (pull --rebase + reindex)
+  thincoder reindex           Rebuild the local index from markdown sources
+  thincoder distill <file> [--yes] [--scope=<s>]
+                            Extract knowledge candidates from a session
+                            transcript file; confirm each before saving
+  thincoder upgrade         Update to the latest version from npm
+
+Config: ~/.thincoder/config.json (provider.baseURL / provider.apiKey / provider.model)
+Env:    THINCODER_API_KEY, THINCODER_BASE_URL, THINCODER_MODEL
+`
+
+/** 组装一个带记忆的 agent（同步各层索引后返回） */
+async function makeAgent() {
+  const config = loadConfig()
+  const provider = createProvider(config.provider)
+  const memory = createMemory({ dbPath: config.memory.dbPath })
+  // 向量检索：配了 embedding 就启用（惰性生成向量，首次搜索时补算）
+  if (config.embedding?.apiKey) {
+    const { createEmbedder } = await import("../src/embedding.mjs")
+    memory.embedder = createEmbedder(config.embedding)
+  }
+  const cwd = process.cwd()
+  // Project 层：启动时同步 .thincoder/memory/ 目录到索引（有就同步，没有就跳过）
+  if (config.memory.projectDir) {
+    memory.projectOrigin = join(cwd, config.memory.projectDir)
+    await syncDir(memory, { layer: "project", dir: memory.projectOrigin })
+  }
+  // Team 层（可选）：首次自动 clone；启动只索引本地目录，拉取远端走显式 thincoder sync
+  const team = teamConfig(config)
+  if (team) {
+    const { ensureClone } = await import("../src/gitmem.mjs")
+    await ensureClone(team)
+    await syncDir(memory, { layer: "team", dir: team.dir })
+  }
+  return createAgent({
+    provider,
+    tools: [...builtinTools, ...memoryTools(memory, { cwd, projectDir: config.memory.projectDir, author: gitAuthor(), team })],
+    config,
+    cwd,
+    memory,
+  })
+}
+
+/** 读取 team 配置并补全默认目录；未配置返回 null */
+function teamConfig(config) {
+  const team = config.memory?.team
+  if (!team?.repo) return null
+  const name = team.name ?? "default"
+  return { name, repo: team.repo, dir: team.dir ?? join(configDir, "teams", name) }
+}
+
+/** 条目作者：git config user.name 兜底 unknown */
+function gitAuthor() {
+  try {
+    return execSync("git config user.name", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || "unknown"
+  } catch {
+    return "unknown"
+  }
+}
+
+switch (command) {
+  case "chat": {
+    const auto = args.includes("--auto")
+    const prompt = args.filter((a) => a !== "--auto").join(" ").trim()
+    if (!prompt) {
+      console.error('Usage: thincoder chat [--auto] "<prompt>"')
+      process.exit(1)
+    }
+
+    const agent = await makeAgent()
+    if (auto) agent.autoApprove = true
+    try {
+      await runAgent(agent, prompt, {
+        onToken: (text) => process.stdout.write(text),
+        onToolCall: (name, toolArgs) => {
+          console.error(`\n[tool] ${name} ${summarize(toolArgs)}`)
+        },
+        onToolResult: (name, result) => {
+          const preview = result.length > 200 ? result.slice(0, 200) + "..." : result
+          console.error(`[done] ${name} -> ${preview.split("\n")[0]}`)
+        },
+        onToolOutput: (name, chunk) => process.stderr.write(chunk),
+        onPermissionRequest: (name, toolArgs) => (agent.autoApprove ? true : askPermission(name, toolArgs)),
+      })
+      process.stdout.write("\n")
+    } catch (error) {
+      console.error(`\n[error] ${error.message}`)
+      process.exit(1)
+    }
+    break
+  }
+
+  case "memory": {
+    const config = loadConfig()
+    const memory = createMemory({ dbPath: config.memory.dbPath })
+    if (config.embedding?.apiKey) {
+      const { createEmbedder } = await import("../src/embedding.mjs")
+      memory.embedder = createEmbedder(config.embedding)
+    }
+    if (config.memory.projectDir) {
+      memory.projectOrigin = join(process.cwd(), config.memory.projectDir)
+    }
+    await memoryCommand(memory, args)
+    break
+  }
+
+  case "sync": {
+    const config = loadConfig()
+    const team = teamConfig(config)
+    if (!team) {
+      console.error("Team memory not configured. Set memory.team in ~/.thincoder/config.json:")
+      console.error('  "team": { "name": "myteam", "repo": "git@github.com:org/team-memory.git" }')
+      process.exit(1)
+    }
+    const memory = createMemory({ dbPath: config.memory.dbPath })
+    const { ensureClone, pullTeam } = await import("../src/gitmem.mjs")
+    try {
+      const cloned = await ensureClone(team)
+      if (cloned) console.log(`Cloned team repo to ${team.dir}`)
+      await pullTeam(team.dir)
+      const stats = await syncDir(memory, { layer: "team", dir: team.dir })
+      console.log(`Synced. Index: +${stats.added} ~${stats.updated} -${stats.removed}`)
+    } catch (error) {
+      console.error(`[error] ${error.message}`)
+      process.exit(1)
+    }
+    break
+  }
+
+  case "distill": {
+    const flags = {}
+    const positional = []
+    for (const a of args) {
+      const m = a.match(/^--([\w-]+)(?:=(.*))?$/)
+      if (m) flags[m[1]] = m[2] ?? true
+      else positional.push(a)
+    }
+    const file = positional[0]
+    if (!file) {
+      console.error("Usage: thincoder distill <transcript-file> [--yes] [--scope=personal|project|team]")
+      process.exit(1)
+    }
+    const { readFile } = await import("node:fs/promises")
+    const transcript = await readFile(file, "utf8")
+
+    const config = loadConfig()
+    const provider = createProvider(config.provider)
+    const memory = createMemory({ dbPath: config.memory.dbPath })
+    const team = teamConfig(config)
+    const { extractCandidates, saveCandidate } = await import("../src/distill.mjs")
+
+    console.error("[distill] extracting candidates...")
+    const candidates = await extractCandidates(provider, transcript)
+    if (candidates.length === 0) {
+      console.log("No distillable knowledge found in this session.")
+      break
+    }
+
+    const opts = {
+      projectDir: config.memory.projectDir ? join(process.cwd(), config.memory.projectDir) : null,
+      team,
+      author: gitAuthor(),
+    }
+    let saved = 0
+    for (const c of candidates) {
+      if (flags.scope) c.scope = flags.scope
+      console.log(`\n--- candidate ---`)
+      console.log(`[${c.type}] ${c.title}  (scope: ${c.scope})`)
+      console.log(c.content)
+      if (c.type === "rule") {
+        console.log("(rule 类知识通常建议手动撰写；确认提取吗？)")
+      }
+      const accept = flags.yes ? true : await askPermission("distill-save", { title: c.title })
+      if (!accept) {
+        console.log("skipped")
+        continue
+      }
+      const where = await saveCandidate(memory, c, opts)
+      console.log(`saved -> ${where}`)
+      saved++
+    }
+    console.log(`\nDistilled ${saved}/${candidates.length} entries.`)
+    break
+  }
+
+  case "reindex": {
+    const config = loadConfig()
+    const memory = createMemory({ dbPath: config.memory.dbPath })
+    // files 层（project/team 的 markdown 索引）全量重建；索引是易失品，真相在 markdown
+    memory.db.prepare(`DELETE FROM files`).run()
+    const cwd = process.cwd()
+    let total = { added: 0, removed: 0 }
+    if (config.memory.projectDir) {
+      const s = await syncDir(memory, { layer: "project", dir: join(cwd, config.memory.projectDir) })
+      total.added += s.added
+    }
+    const team = teamConfig(config)
+    if (team) {
+      const { ensureClone } = await import("../src/gitmem.mjs")
+      await ensureClone(team)
+      const s = await syncDir(memory, { layer: "team", dir: team.dir })
+      total.added += s.added
+    }
+    console.log(`Reindexed ${total.added} markdown entries (project${team ? " + team" : ""}). Vectors will be lazily regenerated on next search.`)
+    break
+  }
+
+  case "tui":
+  case undefined: {
+    const agent = await makeAgent()
+    const config = loadConfig()
+    // 恢复上次的会话（同一项目目录）
+    const { loadSession } = await import("../src/session.mjs")
+    const restored = loadSession(process.cwd())
+    if (restored) {
+      agent.history = restored.history
+      agent.tasks = restored.tasks ?? []
+    }
+    const { startTUI } = await import("../src/tui.mjs")
+    try {
+      await startTUI(agent, {
+        projectDir: config.memory.projectDir ? join(process.cwd(), config.memory.projectDir) : null,
+        team: teamConfig(config),
+        author: gitAuthor(),
+        restored,
+      })
+    } catch (error) {
+      console.error(`[error] ${error.message}`)
+      process.exit(1)
+    }
+    break
+  }
+
+  case "upgrade": {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"))
+    const local = pkg.version
+    let remote
+    try {
+      remote = execSync("npm view thincoder version", { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim()
+    } catch {
+      console.error("[upgrade] 无法查询 npm registry，请确认网络和 npm 已安装")
+      process.exit(1)
+    }
+    if (remote === local) {
+      console.log(`ThinCoder ${local} 已是最新。`)
+    } else {
+      console.log(`升级: ${local} → ${remote}`)
+      execSync("npm install -g thincoder@latest", { stdio: "inherit" })
+      console.log(`已升级到 ${remote}`)
+    }
+    break
+  }
+
+  case "--help":
+  case "-h": {
+    process.stdout.write(USAGE)
+    break
+  }
+
+  default: {
+    console.error(`Unknown command: ${command}\n`)
+    process.stdout.write(USAGE)
+    process.exit(1)
+  }
+}
+
+// ---------------------------------------------------------------- memory 子命令
+
+async function memoryCommand(memory, args) {
+  const [sub, ...rest] = args
+
+  const flags = {}
+  const positional = []
+  for (const a of rest) {
+    const m = a.match(/^--([\w-]+)=(.*)$/)
+    if (m) flags[m[1]] = m[2]
+    else positional.push(a)
+  }
+
+  switch (sub) {
+    case "list": {
+      const entries = await list(memory, { type: flags.type })
+      printEntries(entries)
+      break
+    }
+    case "search": {
+      const query = positional.join(" ")
+      if (!query) {
+        console.error("Usage: thincoder memory search <query>")
+        process.exit(1)
+      }
+      printEntries(await search(memory, query, { limit: 10 }))
+      break
+    }
+    case "put": {
+      if (!flags.type || !flags.title || !flags.content) {
+        console.error("Usage: thincoder memory put --type=<rule|knowledge|decision|pattern> --title=<t> --content=<c> [--tags=<t>]")
+        process.exit(1)
+      }
+      const id = await put(memory, { type: flags.type, title: flags.title, content: flags.content, tags: flags.tags ?? "" })
+      console.log(`Saved (id=${id})`)
+      break
+    }
+    case "remove": {
+      const id = Number(positional[0])
+      if (!id) {
+        console.error("Usage: thincoder memory remove <id>")
+        process.exit(1)
+      }
+      console.log((await remove(memory, id)) ? `Removed #${id}` : `No entry #${id}`)
+      break
+    }
+    default:
+      console.error("Usage: thincoder memory <list|search|put|remove>")
+      process.exit(1)
+  }
+}
+
+function printEntries(entries) {
+  if (entries.length === 0) {
+    console.log("(no entries)")
+    return
+  }
+  for (const e of entries) {
+    console.log(`#${e.id} [${e.type}] ${e.title}${e.tags ? `  (${e.tags})` : ""}`)
+    console.log(`  ${e.content.split("\n")[0].slice(0, 100)}`)
+  }
+}
+
+// ---------------------------------------------------------------- 工具函数
+
+function summarize(toolArgs) {
+  const s = JSON.stringify(toolArgs)
+  return s.length > 120 ? s.slice(0, 120) + "..." : s
+}
+
+/** 权限确认：TTY 下交互询问 y/n；非交互环境默认拒绝（安全优先） */
+async function askPermission(name, toolArgs) {
+  if (!process.stdin.isTTY) {
+    console.error(`\n[deny] ${name} (non-interactive, side-effect tools require a TTY)`)
+    return false
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr })
+  try {
+    const answer = await new Promise((resolve) => {
+      rl.question(`\n[allow?] ${name} ${summarize(toolArgs)} (y/N) `, resolve)
+    })
+    return answer.trim().toLowerCase() === "y"
+  } finally {
+    rl.close()
+  }
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "thincoder",
+  "version": "0.1.0",
+  "description": "Thin coding agent - zero dependencies, no build step, Node.js native. Sharp code, zero bloat.",
+  "keywords": ["ai", "agent", "coding", "cli", "llm", "deepseek", "openai", "tui"],
+  "type": "module",
+  "bin": {
+    "thincoder": "./bin/thincoder.mjs"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "bin/",
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/shanghai-xinbo/thincoder.git"
+  },
+  "scripts": {
+    "test": "node --test",
+    "prepublishOnly": "node --test"
+  },
+  "author": "liwei <liwei@51marine.com> (上海新舶)",
+  "license": "MIT"
+}