Skip to content

dev-ing.md

Latest commit

 

History

History
2315 lines (1837 loc) · 180 KB

dev-ing.md

File metadata and controls

2315 lines (1837 loc) · 180 KB
Raw
title dev-ing
tags
dev
dev-log
dev-xp
created 2022-05-24 17:52:58 UTC
modified 2022-05-24 17:53:08 UTC

dev-ing

guide

  • 分析核心需求和问题，拆分需求，梳理任务、子任务，排期开发 金瑶 邀请您加入【金瑶的个人会议室】 点击链接直接加入腾讯会议： https://meeting.tencent.com/p/9606972663 #腾讯会议：960-697-2663

dev-summary

dev-review

# delete all node_modules folders recursively
find . -name 'node_modules' -type d -prune -exec rm -rf '{}' + && find . -name 'dist' -type d -prune -exec rm -rf '{}' + && find . -name '.vite' -type d -prune -exec rm -rf '{}' + && find . -name '.next' -type d -prune -exec rm -rf '{}' +
# maybe prefix sudo
find . -name 'node_modules' -type d -prune -exec rm -rf '{}' + 
rm package-lock.json node_modules/.package-lock.json

# 格式化当前包，注意在子文件夹执行命令也会从package.json目录开始格式化整个包
prettier --write ' **/* .{js,jsx,ts,tsx,json}' --ignore-unknown
eslint --ext .js,.ts,.tsx --quiet --fix . 
# 👀 npm i 有时很慢，原因可能是代理客户端的dns/缓存异常， 优先重启clash
  DEBUG=* npm i --no-audit --loglevel silly
DEBUG=* npm i --legacy-peer-deps --no-audit --loglevel=silly
DEBUG=* npm i --legacy-peer-deps --no-audit --loglevel=silly --registry=https://registry.npmmirror.com
npm --registry=https://registry.npmmirror.com install   axios
yarn add axios --registry=https://registry.npmjs.org/  
pnpm install --loglevel=debug --registry=https://registry.npmmirror.com  
export https_proxy=http://127.0.0.1:7890;export http_proxy=http://127.0.0.1:7890;export all_proxy=socks5://127.0.0.1:7890
$$('[contenteditable]')
# 先打开一次discord确保下载了更新
flatpak run com.discordapp.Discord --proxy-server="socks5://127.0.0.1:7897"
betterdiscordctl -i flatpak install
npx create-strapi@latest --ts --use-npm --git-init  --example --skip-cloud --skip-db    --quickstart ./emptyFolder
vite --host 0.0.0.0 --port 8080
serve -p 9000 --cors
HOST=0.0.0.0 PORT=8080 react-scripts start
next dev -H 0.0.0.0 -p 3000

npm i -g npm yarn pnpm corepack serve @dotenvx/dotenvx opencode-ai @openai/codex @kilocode/cli @kimuson/claude-code-viewer 
npm up -g  @openai/codex opencode-ai @kilocode/cli
  • dev-goals 不能在产品中检验的技术不玩，注意产品化
    • rich-editor: text/block, vanillajs
    • pivot-table: editable
    • collaboration, local-first database
    • flowchart/whiteboard/pdf/annotation/comment
    • 事项--截止日期(0730+休整)--重要性(h/m/l/s1-s3)
  • deep into lib/fwk 书籍原理与代码实践要分开, 寻找深入debug的状态, learn-by-debug
    • 学习巩固: 实践练习 > 源码/示例 > 文档/论坛 > 社交分享
    • 不要从一个想法开始，而是从一个真正的问题开始
    • src-code, issues, pr, forks, extensions/alternatives
    • storage, sync/partial, conflicts, consistency
    • 直接根据具体框架或产品搜索解决方案如 airtable-database，不必拘泥于通用方案如event-sourcing/eav, 在产品讨论中常有细节和ideas
    • 解决方案在npm/docker也可以搜到，且更准确; 多关注包管理器上的最新的包
    • github package.json 也能搜索示例
    • 拆分核心内容和周边功能
      • split git-src and issues/pr/wiki, split txt/docx/xlsx and api
      • 将更多精力投入 core content 的创作，以及格式兼容、平台兼容、产品集成
    • 不必执着于vanillajs，常用模式早晚会抽象出工具库或框架，如reactive/effect/ajax/undo

dev-2026-方向+方法+时间

  • 👉🏻 output: 代码产出、产品落地、生态积累
  • long-term-support
    • cms, airtable, pdf, lowcode/workflow/auto, drive
  • techstack-to
    • async/generator, stream, buffer, binary, scheduler, arrow
    • 样式片段也可在线尝试: codepen, w3schools.com
  • separate storage compute example
    • Lovefield uses a plug-in architecture for data stores. All data stores implement lf.BackStore interface so that query engine can be decoupled from actual storage technology.
  • cache/stream for web storage
    • 参考 tanstack-query, falcor, localforage
  • 🤔 支持切换内存和异步数据源的示例
    • tanstack-table external data; ag-grid server-side row model
    • abstract-level, localforage
    • tupledb, tinybase
    • tiddlywiki, react-admin
    • service worker, falcor
  • collab-sync, partial-sync
    • string-crdt: ? list-crdt
    • logux: sqlite-persistence, lww-with-hlc
    • verdant/lo-fi: hlc + websocket, no-merkle
    • harika: hlc + sqlite + absurd-sql, no-merkle
    • jaredly/local-first: hlc + rga
    • evolu: hlc + merkle + worker
    • automerge: hypermerge
    • remoteStorage: google-drive、网盘、七牛对象存储
    • 使用hlc: idbsidesync, verdant, harika
    • 结合hlc+crdt: idbsidesync, evolu, rga-crdt
    • 结合hlc+db: piratedb, tinybase, kappa-db-stream, linvodb
    • hypercore: partial-sync
  • undo/redo与branching可拆分实现
    • undo与versioning/history基于persistent data structure
    • branching与merge可在应用层实现
    • 多个branching可通过structural sharing共享数据结构
  • ui: headless-architecture
    • state + action: 参考autocomplete、search-ui
  • headless组件是否表明react将view与logic耦合在一起封装为component的思路是错误的?
    • 与view视图无关的component本身就是个简单的函数或eventemitter-pattern
  • 若slate-model层采用扁平化Node(扁平化的思路可参考event-sourcing/orm/tinybase)
    • 如何保持path和key同步，参考 getKeysToPathsTable, getByKey实现上基于getByPath
    • 优化方向可参考tree的crud及协作
    • 协作时还应该考虑 json patch + last-write-win
    • Node定义采用ast, 如 unist
    • lww的字符串改为针对crdt优化的类型
  • flat-data-model的示例
    • frontend/in-memory database，如rxdb/pouchdb/tupledb
    • 还可以参考indexeddb相关示例，如dexie
    • sqlite-react: vlcn-orm
    • ast如何扁平化
    • 参考案例: tree、react-admin
  • 内容的存储与更新如何与数据库集成
    • 编辑器内容自动保存一般通过在onChange方法中执行saveToDB
      • 也可以在onChange方法中创建内存db、更新索引，通过索引提高计算效率
      • 应该避免维护2份数据
    • 将编辑器的计算密集部分的数据模型不使用普通json对象，而直接用类似数据库模型的设计
    • 为了性能，尽量不要直接读写持久化数据源，要使用缓存object pool
  • why use es6 class
    • 运行时类型检查，instanceof
      • 业内主流方案是zod/valibot
    • 既包含类型定义，又包含逻辑工具方法
      • 注意class有时也采用先定义interface再实现，此时ts type也合理了
      • 但应用层业务代码一般不需要定义单独interface
    • 方便调试，可直接log到对象及方法，函数里面的闭包变量更新难以定位
      • 也可提前将需要调试的属性或方法添加到闭包暴露的对象或window上
      • 闭包实现的私有属性更安全
  • dev-xp-editor
    • 不仅要保持编辑器内容和视图同步，还要保持选区和内容同步
    • 编辑器外部相关面板的协同产品较少，如评论

ing

  • yaoo-proj
    • prosemirror/codemirror + comfyui
    • codemirror-devtools
  • not-yet
    • elmesque-editor , 基于immutable思想实现的编辑器大多采用redux/elm风格
    • branching/versioned-doc
    • pouchdb + kappa-crdt + eav => pouchdb-crdt-eav
    • 做完tailwind-table就面试
  • dev-to 提炼核心需求+产出工作流，不能在产品中检验的技术不玩

dev-05

console.log('; ; task ', taskState, runningTaskAction, task?.task_steps)
^((?!(42\["heartbeat|resourceMonit|refreshXtermCols)).)*$
^(?!42\["resourceMonit).* 
/syncUpdates|syncOTUpdates/


- introduce reactjs in less than 90 words
- introduce reactjs with hello world code example
- count from 1 to 80, every number on a separate line
- count from zz1 to zz40, every item on a separate line  /no_think
- when did deepseek v3.1 model release?
- when did qwen3-coder model release?
- what is the weather in guangzhou china? give me some food and outdoor-activities suggestions according to weather temperature

- what is the weather in Hainan? what clothes should i wear?

- what is the dom api compatibility in common browsers

- explain code at ./playground/quick-sort.js
- for file ./playground/quick-sort.js, add a simple test case

- image-lawn
  - a big park for resting and relaxing, there are little trees around a big lawn, some birds are resting in the lawn, The lawn and the trees around it both need pruning
- image-logo-excel-like
  - create a product logo for my excel-like webapp, 
  - the logo brand color should be like green/teal/indigo/..., or any good color that giving a cold and formal feeling, 
  - the logo should express rows or columns or grid, but logo should not be complicated,
add action to add datetime at top of readme.md
add action to create quickSort1.mjs and try to implement quick sort algorithm in less than 60 lines
<!-- 🛝 -->
use vanilla html/css/javascript to create a simplistic personal profile landing page: homepage shows a big welcoming greeting, then shows 2 example personal projects, then a simple get in touch example email below it
use vanilla html/css/javascript to create a personal profile landing page: homepage shows a cool welcoming animation, then shows 4 example personal projects, then a simple get in touch form below it
use react to create a homepage shows a list of frontend frameworks like react/vue/angular, when clicking the framework, navigate to the route to show its introduction

- You are a professional python/typescript/nodejs fullstack developer.
  - please provide a comprehensive overview of this project. analyze the project architecture and major features, then analyze some important source code to explain the core architecture and data flow.
  - i want more details about rag ingest/chunking/embedding/persistence logic
  - how to refactor related source code to support more vector db including qdrant/chromadb/pgvector? show me some code and explain the architecture migration
- analyze the project architecture and related code. explain the core architecture and data flow

- You are a professional python/typescript/nodejs fullstack developer and a system administrator.
  - I want to run this project fully locally without docker and nginx for local development and debugging.
  - please read setup-related files like docker-compose.yaml and README.md, and tell me step by step how to configure and run frontend/backend locally.
  - i have already installed python/uv/npm/chromadb/Ollama/postgresql/mysql/redis on my local macos.
  - just tell me steps and commands to set up backend/frontend, i will start services like db/redis later.

- 你是一个专业且友善的 AI 助手。你的回应应该： 1. 使用简体中文回答 2. 当需要展示代码时，使用适当的语法高亮（如 typescript, python, javascript 等） 3. 当需要解释复杂概念时，可以使用 Mermaid 图表 4. 当涉及数学公式时，使用 LaTeX 语法 5. 保持回应简洁明确，适时使用列表和表格来组织信息. 
  - 请按以上要求介绍reactjs前端框架

- the northwinds excel contains the sales data for a company called Northwind Traders, which imports and exports specialty foods from around the world. 
  - The sales team wants to identify for which month they perform well and bad in 2014.
  - please give me the result with tables and plots

- you can add more debugging logs to make it easy to trace data flow, then i restarted and give the log to you. 


- when writing or editing large files, it's easy to fail if the content to write is large. you can write small edits many times to avoid large edits.


# running locally by "./dist/one-api --config config.yaml". the log is at folder `~/Documents/runlog/donehublocal` .

# cd ~/Documents/repos/ai-ml-llm/done-hub-local && dist/one-api --config config.yaml

launchctl stop com.donehub && launchctl start com.donehub
launchctl stop com.cpap && launchctl start com.cpap

# DATA_DIR=~/sub2api-local-data ./sub2api -setup

DATA_DIR=~/Documents/runappdata/sub2api2026 ./sub2api

# auto checkin

cd ~/Documents/repos/ai-ml-llm/metapi && npm start

ollama run --verbose gemma3:4b
OLLAMA_DEBUG=2 ollama serve gemma3:4b

# llama-server -m model.gguf --port 8080 --alias name

./build/bin/llama-server -m ~/.lmstudio/models/ 

# llama-cli -m model.gguf -cnv --chat-template chatml

./build/bin/llama-cli -m ~/.lmstudio/models/mradermacher/merged-mermaid-7b-GGUF/merged-mermaid-7b. Q6_K.gguf
llama-cli -hf ggml-org/gemma-3-1b-it-GGUF

VLLM_LOGGING_LEVEL=debug VLLM_CONFIGURE_LOGGING=1 vllm serve RUC-DataLab/DeepAnalyze-8B --max-num-batched-tokens 40000 --max-model-len 28000 --enable-log-requests --enable-log-outputs --enable-prompt-tokens-details --uvicorn-log-level debug 

cd ~/Documents/opt/compiled/qdrant && ./qdrant

# https://www.npmjs.com/package/@tencent-weixin/openclaw-weixin

npx -y @tencent-weixin/openclaw-weixin-cli install

  • goal-to 增强特色

    • editor
    • crud
    • 业务系统与架构增强: lasuite-docs, knowledgebase, cms
    • 📌 pdf-editor
    • 📌 export-ppt
    • 📌 fix text/Chinese
    • translation: 一键翻译 pdf/ppt
    • reuse bg/graphics/fonts

  • dev-to

    • ?

  • dev-log

    • ?

0723

  • Optimize server adapter syncNodes() with cursor-based diff

    • Problem: syncNodes() does a full table scan of both local and mirror SQLite databases on every pass. For a large workspace this is O(n_local + n_remote) row reads on every sync, including when nothing changed.
    • Fix: Use the replication_changes journal (already populated by ReplicationService.recordWorkspaceEvent()) and the checkpoint's lastChangeSequence to identify which entities actually changed since the last successful pass
    • This is a meaningful optimization for workspaces with thousands of nodes and frequent sync passes.

  • your optimization for server adapter with cursor-based attribute diff (performance at scale) has some issues

    • Local SQLite changes are recorded in replication_changes.
    • The server mirror intentionally does not record that journal.
    • Therefore, a remote edit can arrive through the mirror WebSocket, trigger watch(), and still be skipped because its entity ID is absent from the local change set.

  • I just fixed it: Add one monotonic change sequence on the server, scoped to a workspace lineage.

    • This changes the expensive operation from: "scan every node/document on every run" to "fetch changes since the last cursor load only affected entities"

  • There are two ways to enforce this:

    • The feed includes the changed payload, allowing the adapter to apply it directly.
    • Preferably, the mirror synchronizer records the server sequence when it applies each change. The adapter waits until the mirror’s applied sequence reaches the feed cursor, then reads the mirror as usual.
    • The second option preserves the existing mirror architecture and keeps SQLite as the adapter’s content source.

0721

  • ERR_UNSAFE_PORT

    • The webpage at http://127.0.0.1:5060/ might be temporarily down or it may have moved permanently to a new web address.

  • Chromium restricted ports. 2049, // nfs 3659, // apple-sasl / PasswordServer 4045, // lockd 5060, // sip 5061, // sips 6000, // X11 6566, // sane-port 6665, // Alternate IRC [Apple addition] 6666, // Alternate IRC [Apple addition] 6667, // Standard IRC [Apple addition] 6668, // Alternate IRC [Apple addition] 6669, // Alternate IRC [Apple addition] 6697, // IRC + TLS 10080, // Amanda

  • 🤔 i updated better-sqlite3 to latest version at apps/desktop/package.json. i pinned better-sqlite3 to a old version at apps/desktop/package.json. in root ./package.json, when postinstall runs, which better-sqlite3 will be used? this project uses npm workspaces, analyze related docs/rules, then explain to me.

    • npm installs one tree for the whole monorepo, then tries to hoist shared deps to the root node_modules when ranges allow a single version.

  • Can you force the opposite layout?

    • Yes. The reliable npm-native way is to make 12.8.0 a direct dependency of the root package

  • 🤔 electron-rebuild executable itself is hoisted at root, its dependency walker includes that nested desktop copy as well as the root copy, so electron-rebuild -f -w better-sqlite3 rebuilds both versions, not just the desktop version?

    • -w / --which- module: Adds those names into the “must consider” set (prodDeps / extraModules). Does not mean “rebuild only these.”
    • The -w better-sqlite3 flag adds it to extraModules/prodDeps, and the walker scans all node_modules from apps/desktop up to the monorepo root.
    • -o better-sqlite3 Name-only; both paths still match
    • -m apps/desktop Same as current buildPath; still walks up via projectRootPath = monorepo root
    • The reliable solution with your installed @electron/rebuild@4.2.0 is to use its JavaScript API

  • Error occurred in handler for 'init': Error: The module '~/Documents/repos/ai-ml-llm/all-docai/redmansion/node_modules/better-sqlite3/build/Release/better_sqlite3.node' was compiled against a different Node.js version using NODE_MODULE_VERSION 137. This version of Node.js requires NODE_MODULE_VERSION 143. Please try re-compiling or re-installing the module (for instance, using npm rebuild or npm install). at process.func [as dlopen] (node:electron/js2c/node_init:2:2617) at Module._extensions..node (node:internal/modules/cjs/loader:1980:18) at Object.func [as .node] (node:electron/js2c/node_init:2:2617) at Module.load (node:internal/modules/cjs/loader:1540:32) at Module._load (node:internal/modules/cjs/loader:1342:12) at c._load (node:electron/js2c/node_init:2:18047) at wrapModuleLoad (node:internal/modules/cjs/loader:262:19) at Module.require (node:internal/modules/cjs/loader:1563:12) at require (node:internal/modules/helpers:152:16) at bindings (/Users/yaoo/Documents/repos/ai-ml-llm/all-docai/redmansion/node_modules/bindings/bindings.js:112:48) { code: 'ERR_DLOPEN_FAILED' } Error: App is not initialized at ~/Documents/repos/ai-ml-llm/all-docai/redmansion/apps/desktop/.vite/build/main.js:59261:15 at AsyncFunction. (node:electron/js2c/browser_init:2:59676) Error: App is not initialized at ~/Documents/repos/ai-ml-llm/all-docai/redmansion/apps/desktop/.vite/build/main.js:59261:15 at AsyncFunction. (node:electron/js2c/browser_init:2:59676)

  • Native module ABI mismatch: better-sqlite3 was built for a different Node than Electron.

    • Your system Node (v24.16.0) 137
    • Electron 40.8.5 (ships Node 24.14.0) 143
    • After npm install, better-sqlite3 is built/downloaded for system Node (137). The desktop app runs inside Electron (143), so dlopen fails
    • There's already a rebuild script for Electron. Checking forge config and ABI versions, then rebuilding better-sqlite3 for Electron.
    • electron-rebuild -f -w better-sqlite3

0720

  • 🤔 there are so many markdown parsers, is there any open source solutions that implement streaming parsing for markdown so that it can support very large .md file? supporting both full parsing and streaming parsing would be even better. deep research related solutions/ideas, if you found any open source solutions or inspiration projects, provide overview/github-repo/website for each.

  • Markdown "streaming" actually covers two pretty different problems

    • Input-streaming — the file itself is too big to slurp into memory as one string, so the parser needs to consume it in chunks (or emit output without building a full tree).
    • Forward-only append streaming — this is the LLM-chat-UI problem: text arrives token by token and grows, syntax is often unterminated mid-stream, and you're re-rendering, not re-reading a file.

  • Incremental parsers (re-parse only what changed — great for big files under live editing)

  • https://github.com/lezer-parser/markdown

    • when a document is edited, the parser can reuse parts of the previous parse tree unaffected by the change, significantly improving performance for large documents with small edits.

  • tree-sitter / tree-sitter-markdown

    • the general-purpose incremental parsing framework used across editors
    • Tree-sitter solves a different but related problem: "How do I parse very large documents and update them efficiently?"
    • It provides: incremental parsing, partial tree updates, error recovery, syntax trees

  • https://github.com/chuanqisun/semidown

    • A semi-incremental streaming parser designed for LLM output. It incrementally processes and renders new blocks
    • balance correctness and performance by incrementally parsing at the block level while re-rendering inline content.

  • https://github.com/commonmark/cmark /c

    • the C reference implementation of CommonMark.
    • it exposes both a one-shot cmark_parse_document() and a genuine streaming API

  • https://github.com/micromark/micromark /js/rust

    • implemented as a state machine tokenizer that explicitly works on chunks.The parser takes chunks and turns them into events — the start or end of a token amongst other events It even ships a Node duplex stream.
    • two interfaces: buffering and streaming. The first takes all input at once whereas the last uses a Node.js stream to take input separately.

  • https://github.com/pulldown-cmark/pulldown-cmark /rust

    • a pull parser for CommonMark
    • events are produced lazily as you pull them rather than materializing a tree.

  • https://github.com/mity/md4c /c

    • a SAX-style push parser

  • "Streaming markdown" for LLM output (append-only, unterminated syntax)

    • Streamdown
    • FluidMarkdown (Ant Group) — native Android/iOS/HarmonyOS streaming markdown engine for AI chat UIs
    • Textual's approach (Will McGugan, terminal UI framework) isn't a standalone library but is a genuinely clever idea worth stealing: rather than reparsing the whole growing document on every token, track the line number where the last open block began and feed the parser only from there to the end — parse cost then stays sub-millisecond no matter how large the document gets. That's a general streaming-parser trick

0719

  • LPT means Longest Processing Time first.
    • It’s a scheduling heuristic: order jobs by estimated duration descending, then assign the next job to the least-loaded worker/bin. The idea is that long jobs start early so they don’t sit at the end and stretch the makespan.

0716

  • 🤔 I want to develop a saas solution with client/server architecture that provides webapp/electron-app/cli, and the electron-app should just be a thin wrapper of webapp. the electron-app/webapp/cli uses the same server backend/api. is there any popular open source solutions that use similar idea that building electron-app as lightweight webapp wrapper (cli is optional, not required)? deep research related solutions/ideas, if you found any open source solutions or inspiration projects, provide overview/github-repo/website for each.

    • 🌰
    • Zulip, Element (Matrix), Mattermost, Rocket.Chat
    • Trilium Notes, Standard Notes, SiYuan, AFFiNE
    • comfyui

  • well-established patterns in open source

    • (1) Electron ships as a pure client that points at a remote server, exactly like your browser tab does,
    • (2) Electron bundles both the frontend and a local copy of the backend server, so the desktop app can run fully offline and sync later.

0713

// 社区分享的2个配置都没用
 optimizeDeps: {
    include: ["@tanstack/react-form-start"],
  },

resolve: { alias: [ { find: "use-sync-external-store/shim/index.js", replacement: "react", } ], }

// ai给的配置最有用
  optimizeDeps: {
    include: [
      'use-sync-external-store/shim',
      'use-sync-external-store/shim/with-selector',
    ],
  },

  • Dep Optimization Options | Vite

    • optimizeDeps.include: By default, linked packages not inside node_modules are not pre-bundled. Use this option to force a linked package to be pre-bundled.
    • optimizeDeps.exclude: CommonJS dependencies should not be excluded from optimization. If an ESM dependency is excluded from optimization, but has a nested CommonJS dependency, the CommonJS dependency should be added to optimizeDeps.include.

  • 🤔 What is the best practice to develop a documentation site that contains translations in different language, like English and Chinese, and a documentation site also contains versions like v1, v2, ... etc? My documentation source files are markdown files. How should I organize the markdown files locally in languages and versions? What about the URL for different languages and versions? Is there any open source solutions or good practice in the documentation industry that have provided good conventions?

    • The main design decision is whether versions or languages are the primary dimension.
    • For most software documentation, the convention is: Version → Language → Page
    • because every release has its own translated documentation, even if some translations are incomplete.

  • version-first 适合api文档

    • examples: Docusaurus
    • every release is self-contained
    • translators only work inside one version
    • older versions remain frozen, 减少修改面, Git history is cleaner

  • language-first 适合普通文档

    • examples: VitePress
    • Each language has its own complete tree, making it easy to hand off to separate translation teams.
    • inconvenient when releasing new versions because updates span every language tree.
    • Language First, Version Second: The language dictates the user's entire browsing context, so it usually comes first in the path. This is also preferred by search engines for SEO.

  • Suffix-Based(getting-started.en.md)

    • examples: Nextra, MkDocs-static-i18n
    • simpler for single-version docs but gets messy with versions.

  • The industry standard is /docs/{language}/{version}/{page-slug}

    • easy redirects

  • shared 平行目录时， 内容引用shared目录的路径是相同的

    • Images
    • snippets like code

  • Google and SEO best practices recommend using subdirectories (not subdomains) for language separation, with clear language codes like /en/, /zh/, /zh-cn/

  • Regardless of your URL structure, you must implement hreflang annotations to tell search engines about language and regional variants of your pages. This is a non-negotiable best practice for multilingual sites

  • I have enough evidence to treat app-version-raw-collection.test.ts as a shared-process instability candidate: it failed once in the full-root parallel batch, then passed both standalone and when rerunning the entire shard. I’m isolating that file in the API runner so versioning coverage stays deterministic without changing runtime behavior.

  • makefile - How does "make" app know default target to build if no target is specified? - Stack Overflow

  • By default, it begins by processing the first target that does not begin with a . aka the default goal; to do that, it may have to process other targets - specifically, ones the first target depends on.

    • Calling the first target all is just a convention.

  • gnu make - Makefile: all vs default targets - Stack Overflow

    • The default behavior of make is to run the first target in the Makefile if you don't specify a target as a command-line argument.
    • The default goal is the first rule in the makefile that does not start with '.' -- unless overridden by specifying the special variable . DEFAULT_GOAL.
    • The only difference, is that all is recommended in the GNU Make manual, to be the first (default) target, and default has no such special recommendation.
.DEFAULT_GOAL := mytarget

# If you have an older version of make (<= 3.80)
.PHONY: default
default: mytarget ;

0711

  • 🤔 cms is not required. i want some open source examples that shows how to sync between db and files, so that when user edits a file, the db updates, when the db updates, the file also updates. deep research related solutions/ideas, if you found any open source solutions or inspiration projects, provide overview/github-repo/website for each.

  • Joplin's File System sync target is the cleanest real match.

    • Joplin (note-taking app) stores all notes, notebooks, and metadata in an internal SQLite database.
    • But it ships a built-in sync target called File System, which is genuinely bidirectional: point Joplin at a folder, and it continuously mirrors every note to a .md file in that folder — external edits to those files are detected and re-imported into the SQLite database on the next sync pass.
    • all three of its apps — desktop, mobile, and CLI — share this same sync engine

  • Beets — music library manager (SQLite ↔ audio file tags)

    • ID3/Vorbis/APE tags live in the files, fields live in the database, and a user might edit either side independently (retagging in iTunes vs. editing in beets).
    • beets is explicit that it does not do automatic bidirectional sync.
    • What it does contribute is a clean staleness-detection primitive: beets tries to maintain the invariant that if the on-disk metadata differs from the DB metadata, then the on-disk mtime must be greater than the DB mtime, letting it skip re-reading files that haven't changed. That mtime-comparison trick is worth stealing even if you build true bidirectional sync yourself.

  • sqlite-sync is the closest to genuine automatic bidirectional sync as a reusable library rather than a full app. Its Block-Level LWW mode was specifically designed to keep markdown files in sync — splitting text into lines so that two concurrent editors of the same document both keep their edits after merge, rather than one clobbering the other.

  • MarkdownDB's --watch flag is a small, readable example of just the file→DB half — it continuously watches for any modifications in the specified folder and automatically rebuilds the database whenever a change is detected, using chokidar under the hood.

  • The building blocks

  • File-side change detection: chokidar, Watchman

  • SQLite has no built-in change notification, but two practical patterns work:

    • Polling with updated_at
    • sqlite3_update_hook

  • PostgreSQL has a much richer option: LISTEN/NOTIFY combined with a trigger.

    • CREATE TRIGGER note_change_trigger

  • Debezium — for heavier production use, reads the Postgres WAL / MySQL binlog directly and emits every change as a Kafka event. Overkill for a single-machine file-sync daemon, but the standard choice if the database is remote / multi-writer.

  • 🏘️ Architectural Blueprint: How to build your own

If you are building your own CMS or tool, you shouldn't rely on raw FUSE. The industry-standard way to achieve Bidirectional MD ↔ DB Sync requires three components:

  • The Schema Mapping:
    • Database Columns: id, title, slug, metadata (JSONB), content (TEXT), updated_at.
    • Markdown Mapping: The metadata JSON object is serialized to YAML frontmatter at the top of the .md file. The content text is dropped below the frontmatter as the body.
  • The Sync Registry (State File):
    • You cannot rely solely on file modified timestamps (mtime), as Git checkouts or OS actions can change them. You must maintain a hidden local cache (e.g., a .sync-state.json) that stores the SHA-256 hash of the file at the last sync.
    • Logic: If DB row updated_at > last sync AND local file hash == old hash, pull DB to File. If local file hash != old hash, push File to DB.
    • The Circuit Breaker (Loop Prevention): Your sync script must keep a lightweight in-memory cache or a hidden .sync-state SQLite file containing the SHA-256 hash of the file/row at the last sync. Before updating the DB from a file event, check: Does the file hash equal the last known hash? If yes, ignore it. Do the same when the DB tries to update the file.
  • Event Watchers:
    • Use a file-watcher (like chokidar in Node.js) on your Markdown folder.
    • Use Database Triggers (or PostgreSQL logical replication/Listen-Notify) to watch for database row changes.

0709

  • project modelbase-power(in current folder) aims to support to create/update Obsidian Flavored Markdown files in folder ../modelbase by scripts in ./modelbase.

  • the current goal is to write configurable/extensible workflow scripts in typescript to automate this process: first read data from sources like ~/Documents/repos/ai-ml-llm/all-router-token/modelpedia/packages/data, then parse the data, then write the transformed markdown to target folder like ../modelbase/providers/vendors. For example, source data like ~/Documents/repos/ai-ml-llm/all-router-token/modelpedia/packages/data/providers/deepseek/_provider.json ended up to be create/update a file ~/Documents/repos/yaoo/modelbase/providers/vendors/DeepSeek.md. you might read and understands the example source/target data format first, then write ts scripts like ``./modelbase/model-providers-port.tsto automate this process. the default automation should work only for_providers.json` files that contains popular models like `Claude/OpenAI/Gemini/Mistral/DeepSeek/GLM/zai/moonshoot/minimax/qwen/kimi` , make these configs all configurable in `./.env` file with sensible defaults for use out of the box. fields from `_providers.json` files that can be ignored when porting : sdk, free_tier. merge values of discord_url/support_url to `Community URL` field. Try to perfer using YAML list for property values in Obsidian Flavored Markdown files. Field Names should try to use the names like in example file `~/Documents/repos/yaoo/modelbase/providers/vendors/DeepSeek.md`, missing values just leave empty.

  • you should make the task running scripts extensible to make it easy to add more automation scripts later.

  • business code in current folder might be ignored, but you might reuse the dependencies and npm toolchain.

  • the target provider file name may just use the name field in _provider.json. when i run the scripts multiple times, The script should only update the values from source data fields to target markdown yaml fields that value has changed. If the field values are unchanged, the update can be skipped.

  • you should parse source .json objects and targe .md yaml properties, only update the fields that value has changed when running the scripts multiple times. if value is not changed, skip the update.

  • i tried the automation scripts several times. some improvements need to implement.

    • for the fields/properties/values that exist both in source .json files and target .md yaml, when you parse and compare what have changed, please relax the equals condition, ignore changes of properties order and values order. if i change the properties order or values order in targe .md files, as long as the value content is equal, the update should be skipped. when values do change, only update the changed properties/values in place, do not do full overwrite.
    • for the properties that values is empty in source .json files but target .md files have values, or the properties is non-existent in source .json files but target .md have new properties, running the port scripts should not remove the new values, update should be skipped.

0704

  • 🤔 running git status in this folder hangs, there seems to be some issue with this git repo.
    • This repo is not generally broken. The specific problem is repo-local fsmonitor.
    • The same command returns immediately with core.fsmonitor disabled
    • the original problem comes back immediately with core.fsmonitor=true
    • I also confirmed the daemon state is unhealthy: stop hung, start returned without leaving a running watcher, and a stale fsmonitor--daemon.ipc socket remained.
git config --local core.fsmonitor false

dev-06

0628

  • Session header can show "Agents.md: " even though the workspace AGENTS.md is loaded later · Issue · openai/codex _202604

    • session starts before AGENTS.md exists, AGENTS.md is created later
    • this persisted after later resuming/reopening the same session

  • 🤔 in a typical typescript monorepo project using npm workspaces , can different sub packages use typescript module declaration to declare the same module name? is there syntax error? is it valid? deep research related docs/discussions/issues, explain to me with code examples. for examples, ./packages contains utils, ./apps/webapp contain main web app using tanstack router module declaration for routes in main webapp, ./apps/admin contain admin web app also using tanstack router module declaration for routes in admin webapp.

    • TypeScript module augmentation (declare module) is scoped to the compilation unit — meaning it only merges within the set of files that a single tsconfig.json compiles together. This comes directly from how TypeScript project references work.
    • TypeScript project references treat each project as its own isolated piece of code.
    • Declaration merging works on a TS config level. So you could even have different typed router in the same application if you put multiple tsconfig.json files.

  • There's an open TanStack Router discussion specifically about this: how do you get type-safe <Link> inside a shared library when the augmentation only exists in each app's own compilation unit?

    • The solution is to make the shared component generic over the router type rather than relying on the ambient augmentation
    • Then in each app, you instantiate it with the local router type

  • 🤔 is there any good prompt or popular projects that helps to rewrite a AGPL license open source project to new code to avoid license issue with AI ? deep research related solutions/ideas, if you found any open source solutions or inspiration projects, provide overview/github-repo/website for each.

    • Based on the chardet rewrite docs and Malus's architecture, the working methodology (often called "vibe-porting" or AI clean room) follows this pattern
    • Phase 1 — Specification (the "dirty" team, who may know the original)
    • Phase 2 — Implementation (the "clean" AI agent, isolated from source)

0627 - db-file-sync

  • 🤔 Bidirectional Markdown ↔ Database Sync seems to be the best solution for my use case. is there any open source solutions that use similar idea? deep research related solutions/ideas, if you found any open source solutions or inspiration projects, provide overview/github-repo/website for each.

  • The three hard subproblems

    • Change detection. On the file side: a filesystem watcher (chokidar, inotify, FSEvents) detects .md saves. On the database side: Change Data Capture via the WAL (Debezium), database triggers, or timestamp-based polling detects row mutations. Both sides need to be reliably watched without polling overhead.
    • Identity anchoring. A Markdown file and a database row have no intrinsic relationship. You must create one — typically by storing the database row's primary key in the file's YAML frontmatter (e.g. db_id: abc123). Every tool in this document solves this differently
    • Conflict resolution. When a file and its corresponding DB row are both modified between syncs, which wins? Common strategies: last-write-wins by mtime vs updated_at; Git merge (conflicts become merge conflicts in a PR); CRDT-based merge (block-level LWW for text); or simply making one side the canonical authority and treating the other as a derived mirror.

  • Wiki.js stores content in a PostgreSQL database but optionally syncs pages to a Git repository and the Git storage module forces all content currently in the DB to be output to files in the local repository, with bidirectional sync on a configurable interval . It's the most production-ready open source implementation of the full pattern.

    • The sync is genuinely bidirectional: committing Markdown files directly to the Git repo is a supported authoring workflow — Wiki.js pulls the changes and imports them into the database on the next sync interval (default 5 minutes, configurable).
    • the DB is the runtime source of truth (fast queries, ACLs, search), and the Git repo is the archival/editing source of truth (diffs, branching, editor tooling). Conflict resolution uses last-write-wins with a force-sync option.

  • Outline Wiki (community scripts)

    • Outline stores content in PostgreSQL and does not have native file-based sync.
    • However, the community has built solid tooling for pushing Markdown files to Outline's PostgreSQL-backed document store using the Admin API.

  • Logseq as a cautionary study. The community is living through exactly the tradeoff you're facing. In the file version, the files are always canonical. In the DB version, while you will be able to export to markdown files, the database version is always canonical — in the MD version you can modify your graph by editing the MD files directly, but in the DB version you cannot do this. Logseq crossed this line because their file-based approach hit a hard performance ceiling at ~2, 000 pages.

  • Obsidian DB Folder renders a Notion-style table view where each row is a Markdown file, and each column maps to a YAML frontmatter field.

    • Edits made in the table UI are written back to the frontmatter of the corresponding file — fully bidirectional. Supports relations between databases, rollups, formulas, dropdowns, ratings, checkboxes, and nested subdirectory organization.
    • This is an entire bidirectional sync engine, just scoped to a local vault rather than a remote DB.

  • directus-schema-sync exports the database schema and selected content collections to JSON files in a Git repository, and imports them back on startup.

  • The ID anchoring pattern. Every robust implementation stores the DB primary key in the file's frontmatter.

    • The outline-sync-action uses a frontmatter block at the top of the source-controlled markdown docs to set the metadata for the Outline document and store the document ID when created — this is the universal anchor that makes a stable roundtrip possible.
    • The Telefonica team built a bidirectional sync library for Markdown ↔ Confluence (a PostgreSQL-backed wiki). Pages are identified by Confluence page IDs stored in frontmatter

  • Content sources overview | Netlify Docs

    • Content Source Interface (CSI) provides a two-way synching mechanism between the visual editor and your content source(s) (API-based CMS, remote database, files, etc.).
    • CSI defines methods to load the content and its schema from the underlying content source, perform CRUD operations (create/read/update/delete) on the content, upload assets, and other content-related operations.
    • The following modules are supported directly by Visual Editor: Contentful, DatoCMS, Git CMS
    • Because content source modules are defined as instantiated JavaScript classes in the configuration file, you can bring your own content source, even if not officially supported by Visual Editor.
    • 👀 Netlify does publish and maintain many open-source projects, but the core SaaS platform and Visual Editor are proprietary.

  • Build-your-own primitives. For a custom sync daemon: gray-matter (JS) or python-frontmatter (Python) handles the serialization boundary; chokidar watches for file changes; Debezium or PostgreSQL triggers + an outbox table handle DB-side CDC.

    • The trickiest part is the "echo suppression" — preventing a DB write from triggering a file write which triggers another DB write. The standard solution is a sync-in-progress flag that skips change events while writing.

  • Developers want the query speed and relational structure of a database (PostgreSQL/SQLite), but the portability, ease-of-editing, and version control of standard Markdown files.

    • Instead of dealing with OS-level virtual file systems (like FUSE), the modern approach is Dual-Storage / Event-Driven Synchronization.

  • Key Design Idea: Event Log

    • Instead of syncing files and DB directly, Every change becomes a log
    • Markdown files, Database rows, Search index, Embeddings, Git commits are derived from the same event stream.

0626 - db-file-cms-comparisoon

  • 🤔 there are many cms or documentation-centric website that are built on top of database like sqlite/postgresql/... but it is not intuitive to view or manage the content in db as common files. is there any open source solutions that can map/derive the content from db to files to make it easy to interact with contents? deep research related solutions/ideas, if you found any open source solutions or inspiration projects, provide overview/github-repo/website for each.

    • To solve the friction of managing database-backed content, developers have created ingenious solutions that bridge the gap between relational databases (like PostgreSQL/SQLite) and the hierarchical POSIX filesystem.
    • These solutions generally fall into two categories: Live Virtual Filesystems (FUSE) that mount the database directly to your OS, and Bi-directional Sync Tools that export database rows into Markdown files and sync them back.

  • 📌 FUSE virtual filesystem bridges

    • 此方法不支持windows

  • Filesystem in Userspace (FUSE) allows developers to write custom file systems. These tools intercept standard file commands (like cat, ls, or saving a file in VS Code) and translate them into SELECT, INSERT, and UPDATE SQL queries in real-time.

    • FUSE-based solutions (e.g. TigerFS, libsqlfs) allow live editing but require Linux/macOS support and careful synchronization

  • AgentFS (by Turso): a standard SQLite schema and FUSE driver that represents a filesystem. While initially built to give AI agents an isolated sandbox to read/write files that are safely stored in a single SQLite database, it serves beautifully as a way to manage SQLite content as standard files. It supports "Copy-on-Write overlays", meaning you can branch your content like Git

  • TigerFS (by Timescale): TigerFS is a groundbreaking FUSE filesystem explicitly backed by PostgreSQL. It allows you to mount a Postgres database to a directory (e.g., /mnt/db). Tables become directories, rows become nested folders based on their Primary Keys, and columns become files. You can literally grep your database, or edit a text column using Vim, and it translates to atomic, fully reversible PostgreSQL transactions

    • it provides a mount on Linux/macOS where each DB row is a file (supporting edits, search, undo).

  • wddbfs (SQLite to WebDAV): wddbfs takes a clever cross-platform approach: it mounts a SQLite database as a WebDAV filesystem. Once mounted, you can open it in standard file managers (like macOS Finder or Windows Explorer) or text editors. Tables appear as files (like .csv or .jsonl), and it allows seamless browsing of the database contents natively in the OS.

  • PostgreSQLFS / PGFS: community implementations of Postgres-to-FUSE mappers.

  • 📌 Hybrid CMS: DB + Git 2way sync

  • If you don't want a live mount, but rather want to extract your database into physical Markdown files, edit them locally, and push the changes back, these tools automate the synchronization.

  • Hybrid DB+Git is the sweet spot for existing CMS systems.

    • Wiki.js has a native Git storage module where all content in the DB is continuously output to files in a local repository, and changes committed to the repo are synced back — bidirectional, configurable sync interval. with a native bidirectional Git storage module, When enabled, every wiki page is continuously synced to a Git repository as a Markdown file. You can edit the Markdown files directly, push to the remote, and Wiki.js pulls the changes on the next sync interval. The DB handles users, sessions, and search indexes; Git handles the actual page content.
    • The https://github.com/bcc-code/directus-schema-sync extension automatically exports and imports both the schema and data between a Directus instance and JSON files in a Git repository, with auto-import on startup useful for CI/CD environments.

  • Ghost (the Node.js CMS, https://ghost.org) stores content in a SQLite/MySQL database. While no single canonical OSS plugin exists for bidirectional sync, the pattern of Ghost ↔ Markdown Git is well-documented:

    • ghost-to-md exports Ghost's export JSON to Markdown files
    • MD2Ghost publishes a directory of Markdown files to Ghost via the Admin API

  • Simon Willison's Datasette project is built on a philosophy that SQLite databases are "files that behave like APIs"—portable, diffable, shareable.

    • sqlite-diffable dumps every SQLite table to a directory of newline-delimited JSON files designed to be git-diffable — Simon uses it to keep a public daily backup of his blog's PostgreSQL database where every content edit shows up as a readable git diff.
    • The pipeline is: PostgreSQL → db-to-sqlite → sqlite-diffable → files in Git.

  • https://github.com/pausan/syncdbdocs /GPL/202107/go/inactive

    • a tool to help you keep your database documented with a single source of truth
    • This project aims to provide a simple command to generate a textual representation (in txt, markdown or dbml) of the database structure and be able to comment on it and keep the documentation updated easily.
    • The original intend was to be able to sync back the documentation onto the database, and while still possible and probably not hard to do, I've decided that synching comments back to the database is not worth it due to the different constraints of some databases of limiting comment length and/or comment availability altogether.

  • flowcommerce/readme-sync, which syncs local Markdown files with frontmatter up to a documentation database

    • Inspiration: You can build a simple Node.js/Python script that runs on a Git hook: it parses your .md files (extracting title, tags, and content from YAML frontmatter) and performs an UPSERT on your Postgres/SQLite database.

  • 📌 Files → DB indexing layer

  • these solutions store content natively as Markdown files (backed by Git) and generate a local database/index for fast querying.

  • MarkdownDB transforms Markdown content into a queryable SQLite database — files are the source of truth, the SQLite is a derived read index — exposing frontmatter, tags, links, and tasks as SQL-queryable fields.

  • Velite (the actively maintained successor to Contentlayer) turns Markdown/MDX/YAML/JSON files into type-safe data using Zod schema validation, outputting typed JSON at build time.

  • Contentlayer: The original "files as typed data layer" SDK for Next.js. Transformed Markdown/MDX files into type-safe JSON via a contentlayer.config.ts schema.

  • PoloDB / GroundDB concepts: Experimental architectures where the database engine itself uses Markdown files (with YAML frontmatter) as its raw storage medium, exposing a SQL layer on top for querying

  • TinaCMS: It treats Git as the database, but compiles a local SQLite/GraphQL index of your files so developers can query the Markdown exactly like a relational database.

    • internal "data layer" backed by SQLite that makes the Markdown files queryable via GraphQL

  • 📌 File-native CMS (no database)

  • These systems eliminate the database entirely. Every piece of content lives as a Markdown, YAML, or JSON file in a directory

  • Keystatic: connects to your GitHub repository and reads/writes strictly to Markdown/JSON files, completely eliminating the need for a relational database for content storage.

    • Keystatic is a TypeScript API, Markdown and YAML/JSON-based CMS with no database — schema defined in code, content committed directly to Git.
    • Schema is defined in a keystatic.config.ts file; content is stored as Markdown, YAML, or JSON files directly in the repository.
    • Ships with a built-in visual admin UI that operates entirely against the local filesystem (or GitHub API in "GitHub mode"). No server required.

  • Decap CMS (formerly Netlify CMS)

    • A single-page React app that serves as a visual editor for Markdown files in a Git repository.
    • No backend server required beyond the Git provider's API. Content changes become Git commits.
    • Supports GitHub, GitLab, Bitbucket, and Gitea as backends.

  • Grav: A flat-file PHP CMS—no database at all. Content is a folder of Markdown files + YAML. Pages, config, themes, and plugins all live as files. Fully Git-versionable. 2025 saw a major 2.0 release with a new SvelteKit admin UI and REST API.

  • Version Control Systems (Fossil, Git as DB) – SQLite’s own version control system Fossil is an example of a content-addressed, versioned store (though designed for code/data under SQLite). One could also use Git smudge/clean filters or custom diff drivers to store a SQL dump in Git. These are patterns (e.g. storing schema+DML as SQL text), but there is no widespread OSS tool that fully syncs a live DB with Git.

  • Many headless CMS (Strapi, Directus, Drupal JSON API, etc.) use SQL databases to store content. Some provide export or “push to Git” capabilities via plugins. For example, Strapi (Postgres/MySQL) has community tools to generate Markdown (e.g. jekyll-strapi plugin) or dump JSON for static sites. These are typically framework-specific and outside pure DB-to-file scope, but are in the same spirit.

  • The Shift Toward Flat-File Architectures

    • Because databases introduce hosting, scaling, and deployment dependencies, many engineering teams are moving toward flat-file content architectures.
    • For example, the engineering team at Cursor migrated their documentation, product changelogs, and blogs from a database-backed API CMS to raw Markdown files inside their codebase. This migration reduced build times, eliminated database connection failures, and allowed the team to use standard development tools (such as grep, git log, and git blame) directly against their content.

0623

  • apple introduces container on latest mac - https://github.com/apple/container. i want to download and install it on my mac, on the release page, which one should i download: container-1.0.0-installer-signed.pkg or container-dSYM.zip ?
    • container-1.0.0-installer-signed.pkg: This is the standard macOS installer file. You simply double-click it, and it will guide you through the setup process, placing all the necessary files in the correct directories on your Mac (usually /usr/local/bin and related system folders).
    • container-dSYM.zip: This file contains Debugging Symbols (dSYM). It does not contain the actual software or the installer. It is only used by software developers who need to translate raw crash logs into readable code if the program crashes. You do not need this file to run the containers.

0622

0618

0613

  • uv run --directory:

    • Change to the given directory prior to running the command.
    • Relative paths are resolved with the given directory as the base.
    • See --project to only change the project root directory.
    • May also be set with the UV_WORKING_DIR environment variable.

  • aichorage: improve the devops workflow

    • change default backend port to 5678
    • change default webapp port to 5771
    • change default desktop app port to 5772, so that webapp and desktop can run at the same time
    • make these ports configurable in config files like server/.env.example, or apps/web/.env.example, or other config files
    • for js/ts sub packages in this monorepo, the main bundling output should be esm by default instead of cjs. so the main field in package.json should not point to cjs files.
    • migrate devops/testing scripts from .mjs to .ts, making it easier to maintain in the long time, also reducing ts types complaints in vscode.

  • migrate webapp bundling toolchain from vite to rspack without rsbuild.

    • 暂时不要迁移， tanstack-router 对于rspack的支持不成熟

0611

0603


TanStack Start + Rsbuild is a win-win for both communities

Rspack users get a full-stack choice: 100% TanStack Start, with router, SSR, RSC, Server functions out of the box

TanStack users can adopt the Rspack toolchain for stable bundled dev and first-class MF support
  • what does MF mean?
    • MF means Module Federation. In the Rspack/Rsbuild world, it refers to a way for multiple JavaScript apps to share code and load parts of each other at runtime, which is commonly used for micro-frontends. Rspack’s docs explicitly call out “first-class support for Module Federation.”

0601

  • Feature Request: session-sticky-round-robin routing strategy for stateful APIs (Codex / Responses API) · Issue · router-for-me/CLIProxyAPI _202604

    • This request is already covered by the existing session affinity routing support.
    • session-affinity: true
    • routing.session-affinity was introduced in v6.9.27.

  • 其实没用，我CPA自动更新的，也一直用的填充，结果今早三个plus都登出了，远程登出无解

  • CPA 的维护速度绝对比 sub2api 好

  • someone gives me some openai api keys, like oai-m, oai-w... can you figure out what is the possible meaning and differences for these keys?

    • -w (Web): This key is likely backed by a Web-to-API script. It takes your API requests and reverse-engineers them through the standard ChatGPT web browser interface.
    • -m (Mobile): This key is likely backed by a Mobile-to-API script. It routes your API requests by simulating the ChatGPT mobile app (iOS or Android).
    • The oai-w (Web) keys are often subject to strict browser-level bot protections (like Cloudflare Turnstile). If OpenAI updates their web security, web-based proxies often break temporarily. oai-m (Mobile) keys, on the other hand, use the mobile app's API endpoints. These are sometimes considered more stable by proxy providers because they use different authentication protocols (like Apple/Google app attestation) that have different anti-bot security.

dev-05

0530

  • 🤔 popular rust programs often compiled to wasm like turso-db/automerge. can js/ts/python code be compiled to wasm so that it can be run in browser? explain to me and give me some popular wasm programs with github-url/overview for each

  • Python to Wasm

    • You generally do not compile Python scripts directly into a Wasm binary. Instead, the standard C-based Python interpreter (CPython) is compiled into WebAssembly. When you load this in the browser, you are effectively running a miniature operating system environment that boots up the Python interpreter, which then executes your .py files.

  • ts/js to Wasm

    • Standard TypeScript is fundamentally tied to JavaScript semantics and garbage collection, making direct compilation to Wasm inefficient. However, the community created AssemblyScript.
    • AssemblyScript uses strict, statically-typed TypeScript syntax, but instead of transpiling to JavaScript, it compiles directly to WebAssembly. It is essentially a Wasm-first language built to look exactly like TypeScript.
    • compiling JS to Wasm is very popular for serverless/edge computing and plugin systems. Tools like Javy take a lightweight C-based JS engine (like QuickJS), bundle it with your JS code, and output a single .wasm file. This allows you to run JS in any environment that supports Wasm, in a strictly sandboxed way.
    • unplugin-use-wasm — A Vite/Rollup plugin that lets you mark a .ts file with a "use wasm" directive; it then compiles that file via AssemblyScript. This only works for AssemblyScript-compatible code, not full TypeScript.

  • Pyodide is a port of CPython to WebAssembly. It enables you to install and run Python packages directly in the browser. Crucially, it comes with the Python scientific stack pre-compiled (NumPy, Pandas, Matplotlib, SciPy). It bridges the gap between Python and JS, allowing Python code to manipulate the DOM and JS code to call Python functions. (This project powers the highly popular PyScript).

  • https://github.com/GoogleChromeLabs/squoosh — a browser image-compression app that processes images locally and uses wasm-based codecs

  • codex status_code=400, The encrypted content QVhO...og== could not be verified. Reason: Encrypted content could not be decrypted or parsed. - LINUX DO _202605

    • 这个问题我之前也遇到过。 后来发现是因为混用不同渠道的模型导致的。比如有OpenAI官方的，还有来自azure的渠道的。不同渠道的模型产生的加密块是互相不可解密的，所以就会出现你这样的情况。而你又用的是中转，很有可能是上游的中转站混用不同渠道的模型。这个目前来看应该是无解的。

  • 我之前研究的结果是，思考的过程会被加密。你可以理解为每个session中的上下文包含两部分，一部分就是JSON中完全没有加密的明文内容，也就是你的输入和你看到的大模型给你的反馈。而另一部分就是加密的思考过程。其实你是可以把一个session的JSON中的加密的内容全删掉的，这样你就可以继续那个session的对话了，只不过这样就会丢失部分上下文。

    • 正解，我用cpa部署，一直在一个之前用其他api的session重试出现解密失败的情况，后来打开了新的session，完全没有问题

  • 更换渠道导致invalid_encrypted_content 的简单解决办法 - LINUX DO _202605

    • 更换了上游渠道，会触发invalid_encrypted_content
    • {"error":{"message":"The encrypted content QVhO... Rw== could not be verified. Reason: Encrypted content could not be decrypted or parsed.", "type":"invalid_request_error", "param":"", "code":"invalid_encrypted_content"}}
    • 这时候一般就是只能切换session，对于没有git记录的小项目连贯性不好，可以复制当前会话的session id在新开的session中发送，让它去找会话文件继续

  • pro号池和team/plus/free号池体验还是不一样的 - LINUX DO _202604

    • 要注意，假如有用不同渠道的gpt混合，例如说azure pro号池和一般号池，切忌做好对话分离，不要混用，不然出现 { “error”: { “message”: “The encrypted content xxxxx could not be verified. Reason: Encrypted content could not be decrypted or parsed.”, “type”: “invalid_request_error”, “param”: null, “code”: “invalid_encrypted_content” } }
    • 那只能把对话复制出来重新开一个对话了

  • any牌路由器使用gpt-5.5时'tools[15].tools'和encrypt问题的暂时解决方法 - LINUX DO _202605

0528

0527

  • 🤔 find some popular projects that are using pi coding agent like openclaw? give a overview/github-url/url for each. if i want to build a custom agent for chat with docs, should i use pi or vercel ai sdk, compare them and help me choose
  • OpenClaw's architecture uses the Pi framework as its embedded agent runtime to manage tasks, execute code, and retain persistent cross-platform memory
  • https://github.com/Dicklesworthstone/pi_agent_rust
    • Rust port of the Pi Agent CLI
  • https://github.com/dimetron/pi-go
    • fast adaptation of the Pi coding agent written entirely in Go
  • Choose Vercel AI SDK if:
    • You're building a web-based chat interface (Next.js/React) and want the best streaming UX with minimal code
    • You want to ship fast with an official RAG template and community examples
  • Choose Pi if:
    • You want deep control over the agent harness itself—custom tool injection, system prompt engineering, session lifecycle management
    • You're building something that needs to run outside a web browser (terminal, Slack bot, embedded in another app)
    • If you're building a terminal/CLI doc-chat tool (internal dev tool, local knowledge base): Pi is the stronger choice. Its dynamic context injection, skills system, and extension hooks make it well-suited for plugging in RAG without building a whole web stack. Pi's dynamic context feature lets extensions inject messages before each turn, filter message history, implement RAG, or build long-term memory — exactly what "chat with docs" needs.

0525

0524

0523

  • Codex 授权就是一个号码可以授权 3 个账号

  • 服务器被oai风控了

    • 机房ip同时50以上并发会被cf挡下来

  • OpenAI API 原始请求 "service_tier": "priority" 请求 Priority processing

    • Codex config.toml service_tier = "fast" Codex 把它映射成 API 的 priority/快速层级 所以在 Codex 里，你应该写： service_tier = "fast" 而不是： service_tier = "priority" 在 直接调用 OpenAI API 时，应该写： "service_tier": "priority" 一句话：fast 是 Codex 配置里的名字，priority 是 API 请求里的名字；目标都是走更快的 Priority processing。

0521

  • /goal slash command does not work in 0.128.0 · Issue #20591 · openai/codex _202605

    • Failed to read thread goal: thread/goal/get failed in TUI

  • works after remove ~/.codex/state_5.sqlite file for 0.128.0, mac os. install via npm.

  • ik_llama.cpp runs on AVX-512 CPU + CUDA

    • AVX stands for Advanced Vector Extensions. It is an instruction set architecture (ISA) that allows a CPU to perform the exact same mathematical operation on multiple pieces of data simultaneously. This is called SIMD (Single Instruction, Multiple Data).
    • The "512" means the CPU has massive 512-bit data registers.
    • The Analogy: Imagine a toll booth. A standard CPU (64-bit) is a 1-lane road. AVX2 (256-bit) is a 4-lane highway. AVX-512 is an 8-lane superhighway.
    • The AVX-512 landscape is highly ironic. Intel invented it, but AMD is currently the king of it in the consumer market.
    • Intel introduced AVX-512 on their server and high-end desktop chips years ago. They eventually brought it to consumer desktops with 11th Gen (Rocket Lake). However, starting with 12th Gen (Alder Lake), Intel moved to a "hybrid" architecture (Performance cores + Efficiency cores). Because the E-cores could not run AVX-512, Intel disabled AVX-512 entirely on 12th, 13th, 14th, and 15th Gen consumer CPUs to prevent crashes. Today, you can only get Intel AVX-512 on expensive Xeon Server/Workstation CPUs.
    • AMD introduced AVX-512 support with their Zen 4 architecture (Ryzen 7000 series) and perfected it with Zen 5 (Ryzen 9000 series). Furthermore, AMD designed it so that running AVX-512 doesn't cause the CPU to overheat or aggressively drop clock speeds (which was a major issue with older Intel chips). Today, almost all modern AMD CPUs support AVX-512.

0518

0516

  • aichorage model/runtime caching
    • Hugging Face assets should live in a dedicated app cache and be referenced directly, while managed runtimes should build once into a canonical prepared cache and materialize cheap references from that cache instead of full copies.

0509

  • The issue is that the curly quotes in the file are Unicode characters that don't visually match when I type them
    • The file uses Unicode curly quotes (\xe2\x80\x9c and \xe2\x80\x9d). Let me use a script to fix this precisely
    • The shell is interpreting the escape sequences. Let me use a different approach - write a Python script to a file and execute it

0508

  • Failed to load model: Subprocess error: Failed to import ML libraries: Unsloth: Please install unsloth_zoo via pip install unsloth_zoo then retry!
    • Failed to load model: Subprocess error: Failed to import ML libraries: Unsloth currently only works on NVIDIA, AMD and Intel GPUs.
    • unsloth_zoo provides unsloth_zoo.mlx_loader. FastMLXModel (the Python wrapper), but the actual MLX framework (mlx and mlx-lm packages) are separate dependencies — they are not part of unsloth_zoo.
    • mlx-vlm transitively pulls in mlx-lm, which transitively pulls in mlx. But if you only ran pip install unsloth_zoo, the mlx family packages were never installed.
    • Studio is correctly taking the MLX path, but when it tries to load the MLX backend it still needs unsloth_zoo.mlx_loader. Your manual local install skipped the unsloth-zoo git-main overlay that the repo’s supported local setup performs in install.sh:1795.
    • In your current .venv, the installed unsloth_zoo wheel has no mlx_loader.py or mlx_trainer.py, and its package init imports device_type first, which raises the misleading Unsloth currently only works on NVIDIA, AMD and Intel GPUs. on Apple Silicon. That is why every local model fails the same way.
    • The clean fix is to install the MLX-capable unsloth-zoo from git main, not the published wheel you got via uv pip install unsloth_zoo ....
# Either rerun the supported local setup:
cd ~/Documents/repos/ai-ml-llm/unsloth
./install.sh --local

# or do the minimal repair in your current venv:
cd ~/Users/yaoo~/Documents/repos/ai-ml-llm/unsloth
uv pip install --python .venv/bin/python --no-deps --force-reinstall \
  "unsloth-zoo @ git+https://github.com/unslothai/unsloth-zoo"
uv pip install --python .venv/bin/python -e . --no-deps
python studio/backend/run.py --port 8888
  • TFL_HOME_DIR="$HOME/.transformerlab2026": can $HOME be used in .env value
    • it depends on the context in which the .env file is loaded.
    • In api/run.sh (lines 25–43), the .env file is sourced directly in bash: source "$env_file". Bash performs variable expansion, so $HOME resolves to the user's home directory
    • Python load_dotenv() context — NO
    • Frontend / dotenv-cli context — NO

0505

  • Integrate NVIDIA NIM as an Inference Provider · Issue · openai/codex _202605
    • closed as not planned
    • Since NVIDIA NIM uses a different API schema and not a fully OpenAI-compatible one, the practical approach would be through an adapter/proxy layer.
    • Codex -> Adapter Proxy -> NVIDIA NIM
    • The proxy would translate OpenAI-style /v1/chat/completions requests into NIM’s expected request format and then convert the response back for Codex.

0504

dev-04-pretext-rich-text-&-liteparse-or-nomic-model-citation-&-stirling-pdf/image-&-superdoc

0428

  • i want to build a demo website for js library. https://github.com/formidablelabs/react-live renders demo as html directly. https://github.com/codesandbox/sandpack and https://github.com/huozhi/devjar renders demo in iframe. which solution should i choose?
  • Use iframe when you want:
    • strong isolation from your site’s CSS and JS
    • safer execution of untrusted or user-edited code
    • fewer collisions with your app’s state, styles, and global variables
    • support for more realistic “mini app” demos
    • Crash Protection: If the demo has an infinite loop or throws a fatal error, only the iframe crashes. Your docs site stays alive.
    • If your library involves responsive design (e.g., CSS media queries, grid layouts), iframes are vastly superior.
    • True Event Isolation
    • Z-Index and Fixed Positioning: If your library includes elements like sticky headers or fixed sidebars, rendering them in direct HTML will make them stick to the documentation's window, which breaks the layout.
    • Framework Agnostic
    • optional advanced tooling: npm import
    • 🐛
      • Performance Overhead: Booting up the bundler and iframe takes time
      • Modals, Dropdowns, and Tooltips: This is the biggest drawback of iframes. If your library includes a dropdown menu, a tooltip, or a modal popup, an iframe will cut it off if the dropdown is taller than the iframe itself.
      • Interacting with iframes on mobile devices can be frustrating.
  • Use direct HTML injection when you want:
    • fast
    • the simplest setup
    • tighter integration with the host page styling
    • very small, controlled examples
    • lower overhead and easier messaging between demo and page
    • 🐛
      • Shared State: If your library mutates window or document, it might mess up your docs site. Easier to share state between the demo and surrounding docs (e.g., theme toggles)

0427

  • superdoc: when i run pnpm dev, there is a editor demo in browser. in the demo config menus, "Tracked replacements" supports "paired (google docs)" or "independent (word)", read related code and explain to me what's the difference when i open a .docx .
    • When you open a DOCX file with tracked changes, this setting controls how tracked replacements (typing over selected text) are interpreted
    • Word documents represent replacements as two separate tracked changes in the XML. Google Docs treats a replacement as one operation.
    • Paired (Google Docs): default - Adjacent w:ins (insertion) and w:del (deletion) elements with matching author and timestamp share one internal ID. The editor treats them as a single logical change. User sees one accept/reject button for the replacement. Matches the Google Docs user experience
    • Independent (Word): Each w:ins and w:del element gets its own unique ID. Each is addressable and resolves independently. User sees two separate accept/reject buttons (one for deletion, one for insertion). Matches the Microsoft Word / ECMA-376 §17.13.5 standard behavior.
  • pnpm dev and pnpm dev:superdoc shows similar demo, what is the difference? pnpm dev:super-editor" shows a simpler demo, what is the point of it?
    • pnpm dev and pnpm dev:superdoc - Identical : All editing features + Full application demo
    • pnpm dev:super-editor - Minimal Editor Demo : just the editor + toolbar, no sidebar, no panels

0425

curl cip.cc

IP	: 124.240.71.187
地址	: 中国 广东 佛山
运营商	: 广电

数据二	: 中国广东佛山 | 广电网

数据三	: 中国广东省广州市 | 广东广电

URL	: http://www.cip.cc/124.240.71.187

0421

  • The local ONLYOFFICE docs confirm the core point: it does not win by universally regenerating arbitrary original operators. It wins by converting editable page content into its own document/ drawing model and then saving through a PDF-specific change stream.
    • I’m drilling into Hardoc’s current export-plan/serializer seam now to move it one step closer to that model instead of preserving mixed “native-like” thinking.

0418

  • Problem: JavaScript’s .sort() mutates the array.
  • Yup. and there are other non-mutating array methods like toSpliced() , toReversed() and with(), return new arrays instead of modifying the original.

0416

  • 🤔 Microsoft Word support track changes. Please check for me whether suggestion mode has to be turned on if I want to use track changes in word. another question, does office excel or PowerPoint also support track changes or suggestion mode? if yes, is there any differences in feature differences or implementation differences for word, excel PowerPoint check changes?
    • "Suggestion Mode" is a Google Docs term, whereas "Track Changes" is the Microsoft Word equivalent.
  • In Word Desktop (Windows/Mac): You simply turn on Track Changes (go to the Review tab > click Track Changes). Once it is on, any edits you make are automatically marked as suggestions (redlines/strikethroughs) that can be accepted or rejected.
    • In Word for the Web: Microsoft recently adopted a mode-switching interface similar to Google Docs. In the top right corner of the web browser, you will see a dropdown that lets you choose between Editing, Reviewing, and Viewing.
    • inline, and character-by-character tracking.
  • Modern Excel has moved away from the traditional "Track Changes" feature and replaced it with a feature called Show Changes. (There is a "Legacy Track Changes" feature, but Microsoft hides it by default because it disables modern co-authoring and Excel Tables).
    • Cell-level tracking via a sidebar pane, rather than inline text markups.
    • This opens a pane on the right side of the screen. It acts as an audit trail of who changed what, and when.
    • No Accept/Reject: Unlike Word, you cannot "Accept or Reject" a change
    • Edits don't alter the visual look of the spreadsheet (no redlines or strikethroughs).
    • Microsoft also still documents a legacy Track Changes / Shared Workbook path for older workflows. Functionally, this is more of an edit history than Word-style inline tracked revisions.
  • PowerPoint does not have a live "Track Changes" button. Instead, PowerPoint relies on a Compare feature and robust Comments to handle revisions.
    • Offline merging and manual review via a "Revisions" pane.
    • Because tracking every moved image or changed font size live on a slide would be visually chaotic, PowerPoint doesn't have a live tracking toggle. Instead, you use the Compare feature.
    • It highlights changed elements (text boxes, shapes, images) with a small icon. You click the icon and check a box to Accept or uncheck it to Reject their changes.

For the parity refactor, which live edit authority should the plan assume for forms/annotations/reviews on recognized pages?

1. Unify Page-Owned (Recommended)  Use one recognized-page scene/object authority for live editing, with forms/annotations/reviews projected to PDF/native structures only at import/save boundaries.

2. Keep Sidecars                   Keep forms/annotations/reviews as separate live arrays beside the page scene, and only unify text/images/shapes under the page-owned runtime.

3. Hybrid By Family                Unify annotations/reviews into the page scene now, but keep forms as a separate live model for longer.
  • ONLYOFFICE is closer to Keep Sidecars, not Unify Page-Owned.
  • So the ONLYOFFICE-like choice for Hardoc is:
    1. Keep recognized-page drawings/page objects as the authority for rich editable page content: text, images, shapes, groups, tables, charts.
    2. Keep forms, annotations/redactions, and review threads as separate live families in the document model.
    3. Unify them at the command/history/collaboration/selection layer, not by forcing them into one scene schema.

0414

  • "Widow/orphan control" is a typesetting concept that prevents awkward page breaks in paragraphs.
    • Widow: A single line (or few lines) left alone at the top of a new page after a break
    • Orphan: A single line (or few lines) left alone at the bottom of a page before a break
    • This is a standard typesetting practice for professional document formatting, preventing ugly single-line stragglers that look unprofessional.
  • Word's "Widow/Orphan control" checkbox in Paragraph settings:
    • w:widowControl attribute in OOXML
    • When enabled, ensures at least 2 lines on each side of a page break

0412

  • 🤔 hardoc-pdf

  • the core PDF editing model should be headless and DOM-agnostic.

  • PDF.js is enough to get open -> render -> text geometry -> viewport working fast.

  • PDF page render: canvas via PDF.js

  • text edit session: absolutely positioned DOM editor over the selected text block

  • annotations/shapes: DOM SVG overlay or Konva overlay

  • 🆚 can your explain your other plan like wasm-first architecture, and compare it with hybrid?

    • WASM-first is the stronger architecture if your real target is maximum ONLYOFFICE-like parity.
    • Hybrid is the safer architecture if your real target is shipping improvement steadily from the current Hardoc codebase.
    • In WASM-first, the native backend becomes the center of the product, not just the save engine.
    • instead of TypeScript building semantic parcels first and asking WASM to help rewrite, TS asks WASM for the authoritative document model from the start.

  • Hybrid

    • TS still owns much of analysis and view-model building.
    • pdfjs-dist still provides most visual extraction.
    • WASM is mainly added for the hardest backend problems.

  • WASM-first:

    • TS stops being the source of truth for text semantics.
    • the native backend becomes the source of truth for both analysis and rewrite.
    • pdfjs-dist may stay only for raster rendering, or even eventually be replaced.

  • a headless editor needs a document engine, not a browser editing layer

  • ONLYOFFICE is not built around pdfjs-dist or pdf-lib. From the code, it uses a custom native PDF engine exposed to JS through drawingfile.wasm / asm.js bindings, and then layers a document-style editing model on top of that.

0406

  • 🤔 一台主服务器用来存放峰值记录和可视化（不要求计费），其他都是 我试过GoEdge，这个工具不太行，没有现成的记录95峰值，而且之后的版本还收费

    • “95峰值”（通常称为 95th Percentile 或 95计费法）是网络带宽、服务器流量监控中非常经典且常用的一个统计学指标。
    • 95峰值是指：在一段时间内（比如一个月），将所有的带宽/流量采样点按从大到小排序，去掉最高的 5% 的数据，剩下的数据中最大的那个值。
    • 一般监控系统（如阿里云）会每 5分钟 对服务器的带宽采集一次数据。
    • 总采样点： 1个月 = 30天 = 720小时 = 43200分钟。每5分钟一个点，一个月总共有 8640个 采样点。 将这 8640 个带宽数值从大到小排列。 削掉前 5% 的最高值。即 8640 × 5% = 432个 点。排名第 433 大的那个带宽数值，就是这一个月的“95峰值”。
    • 在真实的网络环境中，流量往往是不平稳的。可能会因为以下情况出现短暂的极高波动： 遭受到短时间的 DDoS 攻击； 某天搞活动，用户突然激增了几小时； 运维人员临时拉取了一个超大文件
    • 如果看**“最大峰值”，你可能会因为这仅仅几分钟或几小时的异常流量，被拉高了整体的评估标准
    • 而使用“95峰值”，相当于允许你每个月有 36个小时（432个点 × 5分钟）的流量可以“肆无忌惮”地冲高。只要你剩下的时间的流量相对平稳，那么你的 95峰值 就会是一个非常客观、能反映你服务器真实常态高负载**的数据。

  • Error running remote compact task: unexpected status 503 Service Unavailable: No available channel for model gpt-5.4-openai-compact under group codex

    • 这个是远程压缩，据说比本地压缩效果好

0404

  • Error rendering prompt with jinja template: "Cannot call something that is not a function: got UndefinedValue". This is usually an issue with the model's prompt template. If you are using a popular model, you can try to search the model under lmstudio-community, which will have fixed prompt templates. If you cannot find one, you are welcome to post this issue to our discord or issue tracker on GitHub. Alternatively, if you know how to write jinja templates, you can override the prompt template in My Models > model settings > Prompt Template.
    • The original Hugging Face tokenizer_config.json for the IBM Granite Vision model contains a very complex Jinja template. It includes Python-like functions, macros (like raise_exception()), or multi-modal list iterators to handle images and function calling.
    • LM Studio uses a lightweight, stripped-down Jinja renderer that does not support these advanced, Hugging Face-specific functions. When LM Studio tries to read the Granite template and hits an unsupported function, it throws the UndefinedValue error.
  • the original chat template is https://huggingface.co/ibm-granite/granite-4.0-3b-vision/raw/main/chat_template.jinja . can you improve and provide a usable chat template in lm studio without advanced jinja features while keeping major semantics and features of original chat template? i want to copy-paste your improved chat template to lm studio and test it. please also give a good prompt that conforms to the model prompt requirement

0403

  • 🤔 i am using my m4 macbook now. From both clashx meta network monitor and NetSpeedMonitor.app, it shows download speed is 1.2-3.2 MB/s, it keeps showing this network speed for hours. please find which processes/apps are downloading and eating my network. the reason may not be chrome browser, because when i close chrome, it still showed the download speed. from both clashx pro network monitor and NetSpeedMonitor.app, now it is showing download speed is 1.2-3.2 MB/s. please analyze the root cause and tell me how to fix it step by step.
    • ❓ 手动强制退出 ClashX Pro 再打开， 网络自动恢复正常， 所以可能是这个闭源代理软件自身的问题
    • This is a known issue with proxy clients - they can get stuck in connection loops, especially with unreliable proxy servers

0402

  • google/gemma-4-E4B-it · Hugging Face _202604
    • The "E" in E2B and E4B stands for "effective" parameters. The smaller models incorporate Per-Layer Embeddings (PLE) to maximize parameter efficiency in on-device deployments. Rather than adding more layers or parameters to the model, PLE gives each decoder layer its own small embedding for every token. These embedding tables are large but are only used for quick lookups, which is why the effective parameter count is much smaller than the total.
brew install llama.cpp --HEAD

llama-server -hf ggml-org/gemma-4-26B-A4B-it-GGUF:Q4_K_M

0401

  • mac m4 ollama test simple

  • qwen3.5:4b-q4_K_M 3.4GB

total duration:       2m35.794602583s
load duration:        111.727375ms
prompt eval count:    18 token(s)
prompt eval duration: 323.14ms
prompt eval rate:     55.70 tokens/s
eval count:           2771 token(s)
eval duration:        2m34.614017634s
eval rate:            17.92 tokens/s

total duration:       9.83627225s
load duration:        103.945834ms
prompt eval count:    15 token(s)
prompt eval duration: 270.228875ms
prompt eval rate:     55.51 tokens/s
eval count:           167 token(s)
eval duration:        9.418482123s
eval rate:            17.73 tokens/s
  • qwen3.5:4b-nvfp4 4.0GB
total duration:       33.366493667s
load duration:        40.022ms
prompt eval count:    18 token(s)
prompt eval duration: 1.140746542s
prompt eval rate:     15.78 tokens/s
eval count:           847 token(s)
eval duration:        32.184634208s
eval rate:            26.32 tokens/s

total duration:       9.009692792s
load duration:        37.448417ms
prompt eval count:    15 token(s)
prompt eval duration: 221.004458ms
prompt eval rate:     67.87 tokens/s
eval count:           228 token(s)
eval duration:        8.749817833s
eval rate:            26.06 tokens/s

dev-03-openclaw-local-first-&-huggingface-storage-s3-&-nodejs-vfs-&-electricsql-durable-transport

0325

  • i want to develop a cms that features document relationships. what's the most popular graph database for this? give me some solutions and tips
    • Neo4j — best default choice if relationships are the core feature. Neo4j uses a property graph model with nodes, relationships, and properties, and it has a broad ecosystem of tools and libraries.
    • ArangoDB — best if your CMS is already document-first. ArangoDB stores JSON documents and natively supports graphs, so you can keep content and relationships in one database. Its docs also describe a single database core for graph, document, key-value, search, and vector needs.
    • Amazon Neptune — best if you want a fully managed AWS service. AWS describes Neptune as a fully managed graph database, and it supports Gremlin, openCypher, and SPARQL.
    • JanusGraph — best if you expect very large graphs and are comfortable with more operational complexity. Its docs emphasize scale beyond a single machine and real-time traversals.
    • PostgreSQL (with Apache AGE): You can store document content in JSONB columns, handle basic hierarchies with recursive CTEs or the ltree extension, and if you need true graph capabilities, you can install Apache AGE (an extension that gives Postgres Neo4j-like graph capabilities using OpenCypher).

0323

  • Qwen3.5 no think? : r/ollama _202603

    • It works in the Ollama CLI by /set nothink command

  • [Bug]: bluebubbles plugin installation fails with zod dependency error · Issue · openclaw/openclaw _202603

    • The plugin installer needs to run dependency installation (pnpm install / npm install) in the extension directory after extracting the tarball, OR the plugin build process should bundle all dependencies (including zod) into the published package so no separate install step is needed. As a user workaround, manually running 'pnpm install' inside ~/.openclaw/extensions/bluebubbles/ resolves the missing zod dependency.
    • 👷 可以打开 ~/.openclaw/extensions 然后删除名称异常的目录(这些目录可能是之前网络问题或其他问题导致安装未成功的), 然后重新执行安装就行了
      • rm .openclaw-install-stage-eOx4vP
      • rm .openclaw-install-backups
# User workaround:
cd ~/.openclaw/extensions/bluebubbles
npm install
# Then restart openclaw

# Maintainer fix (in the plugin installer logic, after tarball extraction):
# After: extractTarball(tarballPath, extensionDir)
# Add:   await execAsync('pnpm install --prod', { cwd: extensionDir })

0320

0318

  • i have run unsloth-studio locally on my macbook without docker. i want to reuse its features/code into my custom projects. is its license commercial friendly? please read related backend code and web ui code for unsloth studio, and explain to me

  • 美国CF 线路 DOH查询

    • DOH (DNS over HTTPS)
    • 传统的 DNS： 当你在浏览器输入网址（如 google.com）时，电脑需要通过 DNS（域名系统）把网址翻译成 IP 地址。传统的 DNS 查询是明文的，这意味着你的网络运营商（ISP）或中间节点可以看到你访问了什么网站，且容易遭到DNS污染/劫持（比如把你引导到错误的网页，这也是很多网站在国内打不开的原因之一）。
    • DOH： 将完整的 DNS 查询过程封装在 HTTPS 协议（就是网页加密协议）中进行。
    • 作用： 因为加了密，别人只看到你在和某台服务器进行加密的数据交换，无法知道你具体查询了哪个网站的域名。这极大地保护了隐私，并且有效防止了 DNS 污染。

0317

  • i want to run unsloth-studio locally on my macbook without docker.
  • i followed the readme.md
git clone https://github.com/unslothai/unsloth.git
cd unsloth
uv tool install -e .
unsloth studio setup
unsloth studio -H 0.0.0.0 -p 8888
  • but i am using uv instead of pip. after uv tool install -e . , unsloth studio setup failed with error:
[02:26:38] ➜  unsloth git:(main) unsloth studio setup
╔══════════════════════════════════════╗
║     Unsloth Studio Setup Script      ║
╚══════════════════════════════════════╝
✅ Node v24.14.0 and npm 11.11.1 already meet requirements. Skipping nvm install.
✅ Node v24.14.0 | npm 11.11.1
✅ Frontend built to frontend/dist
finished finding best python
✅ Using python3 (3.13.5) — compatible (3.11.x – 3.13.x)
Error: Command '['/Users/yaoo/.unsloth/studio/.venv/bin/python3', '-m', 'ensurepip', '--upgrade', '--default-pip']' returned non-zero exit status 1.

  • read related code and docs, tell me how to run unsloth-studio locally step by step

  • NVFP4 并非简单的 4-bit 浮点格式，它利用了 Blackwell 架构中第五代 Tensor Core（张量核心）的硬件加速能力，并配合先进的双级缩放（dual-level scaling）技术，在保持模型精度的同时，大幅减少显存占用并提升推理速度

  • NVFP4 requires Blackwell architecture (GeForce RTX 50-series / Blackwell Pro / select workstation cards). Don’t expect NVFP4 on older 40/30-series.

    • frameworks like TensorRT-LLM, vLLM, and recent toolchains already add NVFP4 support — but some kernels or specific MoE/FlashInfer kernels may require particular versions or builds (you may need an updated wheel/Docker image or to build from source).

  • Older, much cheaper GPUs can run 4-bit models using INT4 formats (like AWQ, GPTQ, EXL2, or GGUF).

0316

0315

  • ndjson vs jsonl format
    • There is no technical difference between NDJSON and JSONL (or JSONNL). They are exactly the same data format.
    • Most people call it NDJSON (newline-delimited JSON) or JSONL / JSONLINES.
    • Use NDJSON/JSONL for logs, streaming, big datasets, or appendable files.
    • Use a normal JSON array when a single valid JSON document is required.
  • there is a slight difference in naming conventions and specifications between NDJSON and JSONL.
  • application/x-ndjson
    • Heavily used in streaming data, Elasticsearch, and big data pipelines.
    • The spec explicitly allows for optional carriage returns (\r\n) and specifically addresses streaming scenarios.
    • Use NDJSON if you are working with streaming APIs, logs, or tools like Elasticsearch.
  • applicatioƒn/jsonl
    • Heavily used in data science, Python (pandas), and machine learning datasets.
    • The spec is slightly stricter about standardizing how text is encoded (UTF-8) and handling line endings.
    • Use JSONL if you are working with datasets, Python pandas, or static files.
  • Both are superior to standard JSON for large datasets because they allow you to read one line (one record) at a time without loading the entire file into memory.

0310

  • 🤔 from both clashx pro network monitor and NetSpeedMonitor.app, it shows download speed is 6.16.9 MB/s, it keeps showing for hours. please find which apps are downloading and eating my network. from both clashx pro network monitor and NetSpeedMonitor.app, now it still shows download speed is 6.16.9 MB/s.
    • 这个问题非常奇怪, 在从22:00到凌晨03:05， 突然就没有异常流量了, 一切恢复正常了
    • 试了codex/iflow，都没有正确分析出问题
  • the heavy downloader is Microsoft Edge Helper, not Chrome. Evidence from live Clash connection deltas (8-second window):
  • Microsoft Edge Helper -> stun.chat.bilibili.com (UDP 3478): 54, 670, 336 bytes / 8s
    • That is about 6.52 MB/s, matching your observed 6.1–6.9 MB/s.
  • Next highest traffic in same window was tiny (node -> api.telegram.org: 6, 309 bytes).
  • So the app eating traffic is:
  • Microsoft Edge (background helper process)
  • Host pattern: stun.chat.bilibili.com (likely Edge tab/background RTC stream)

0309

  • How long does It typically take for an extension to get reviewed? : r/chrome_extensions _202411

    • My extensions were initially approved in 4 and 7 days. It depends on permissions you request, overall quality: content, features, etc.
    • It varies; may take up to 10 days also. It mainly depends upon how many "permissions" your chrome extension requires.

  • 企微官方机器人接入 openclaw

  • i get it working in chrome. in chrome://extensions/shortcuts , i set a hot key for current tab with date: [title _date](url). when i pressed the hotkey, i want to replace some text in title to make the title clean. please make a plan to add a copy-format.json as configuration file, so that i can configure some rules to replace oldText with newText . the oldText and newText should support simple regular expression. for example, the old copied content is [QMD: Local hybrid search engine by 95% +. | by DevSphere | Coding Nexus | Feb, 2026 | Medium _202603](https://medium.com/coding-nexus/qmd- local-hybrid-search-engine-for-markdown-that-cuts-token-usage-by-95-e0f9d21f89af), after your implementation, the new content should be [QMD: Local hybrid search engine by 95%+. | Medium _202603](https://medium.com/coding-nexus/qmd-local-hybrid-search-engine-for-markdown-that-cuts- token-usage-by-95-e0f9d21f89af). please a make a plan to design a extensible implementation to make the example text replacement use case above work.

  • in current git uncommited files and codebase , i can set a hot key for current tab with date: [title _date](url). when i pressed the hotkey, i want to replace some text in title to make the title clean. the text replacement rules should be configurable by src/static/copy-format.json, so that it is extensible.

    • the goal is to review the uncommited code, recheck logic, code reuse, extensible, maintainable.
    • analyze the architecture and core data flow, make sure the implementation is correct and clear.

  • improve your implementation by your code review results, fixing medium to severe bugs is enough, no unnecessary work

0307

  • 有没有什么在线大模型或本地大模型，说话或聊天的风格偏向于不正经的聊天，偏向于抬杠或毒舌，有没有一些热门的抬杠或毒舌模型？ 如果有，可以列出 huggingface url并给出简介
    • 抬杠, 毒舌, 嘲讽, 阴阳

0302

  • 🤔 i want to use a sandbox for a agentic electron app. aws firecracker seems fast to start and use. is there any popular solution that uses firecracker ? if i package it into electron, does it work on linux/macos/windows?

    • No. AWS Firecracker is a Virtual Machine Monitor (VMM) that relies exclusively on KVM (Kernel-based Virtual Machine) to create microVMs.
    • Linux: It will work natively, provided the host Linux machine has KVM enabled and hardware virtualization supported.
    • macOS: macOS does not have KVM (it uses Apple's Hypervisor.framework). Firecracker cannot run natively on macOS.
    • Windows: Windows uses Hyper-V, not KVM. To run Firecracker on Windows, the user would need WSL2 (Windows Subsystem for Linux) configured with nested virtualization.

  • Approach A: Cloud Sandboxing (The "Firecracker" Route)

    • Use an API like E2B or Daytona.

  • Approach B: Local Cross-Platform Sandboxing

  • WebAssembly (Wasm) / WASI (Highly Recommended). Check out Wasmer, Wasmtime, or Pyodide (if your agent writes Python).

  • V8 Isolates / Deno: If your agent executes JavaScript/TypeScript, you can use Node.js vm2 (deprecated/unsafe) or better, run a bundled instance of Deno.

    • Deno has built-in permission flags (e.g., --allow-read, --deny-net) which creates a secure, cross-platform sandbox out of the box.

  • Local Docker / Podman (The Heavy Route): You can design your Electron app to check if the user has Docker installed.

    • If they do, your app uses the Docker API to spin up containers locally for the agent to use.
    • Tools: Testcontainers or standard Dockerode library.

  • e2b: recommended: keep the Firecracker sandboxes off the user’s mac/win host and run them remotely (or in a lightweight Linux helper VM you install separately). This lets your Electron app be cross-platform UI + controller while the microVMs run where KVM is available.

  • Firecracker is a Linux/KVM user-space VMM — it requires access to KVM (i.e. /dev/kvm) on the host. That means it natively runs only on Linux hosts with KVM enabled (or on hosts that provide an equivalent kernel device). You will need host privileges (or special ACLs/capabilities) to let the Firecracker binary talk to /dev/kvm.

0301

  • 🤔 latest chromium/chrome has experimental features like ai/split-view, how can i enable these features automatically on my custom electron app? explain to me and give me some docs and urls for references
    • enable the Chromium flags you need at app startup (via app.commandLine.appendSwitch) and/or turn on Renderer-level runtime flags via BrowserWindow's webPreferences (experimentalFeatures / enableBlinkFeatures).
  • Electron is built on Chromium's web rendering engine, not the Chrome browser UI. Because "Split Tabs" is strictly a Chrome Browser UI feature, appending the split-view flag in Electron will do absolutely nothing.
    • To implement a split-view in Electron, you don't use flags; you build it natively using Electron's WebContentsView API (the modern replacement for BrowserView). This allows you to embed multiple independent web views side-by-side in a single window.
  • Google Chrome recently introduced a built-in AI API (window.ai.languageModel) powered by a local Gemini Nano model.
    • While appending the flags above will successfully expose the window.ai JavaScript API bindings in your Electron renderer process, it will not actually work out-of-the-box.
    • Google Chrome downloads the massive gigabyte-sized Gemini Nano model weights dynamically using Chrome's proprietary "Component Updater" (chrome://components). Electron does not include this component updater or Google's proprietary server connections, meaning the model will never download and the API will return a "No model available" error
  • the official Electron maintainers created an experimental library called @electron/llm
    • It perfectly mimics Chromium's window.ai API but allows you to bundle and load your own local .gguf open-source models (like Llama 3) entirely offline

dev-02-vlm-powerful-than-ocr-&-code-indexing-mcp-&-unify-code-search-and-rag-with-skills-&-context-engine-and-memsearch-qmd

0228

0224

  • 介绍下 MINISFORUM 铭凡 这家公司，及主力产品， 融资历程，投资关系， 发展前景
    • MINISFORUM铭凡是深圳市美高电子设备有限公司旗下的数码品牌，成立于2012年（公司主体），并于2018年正式以MINISFORUM品牌运营。品牌于2022年11月公布了中文名“铭凡”。公司总部位于深圳，是一家专注于高性能微型计算机研发、生产和销售的技术企业
    • 专注AMD平台：相比Intel NUC，铭凡更专注于AMD锐龙处理器，提供更高性价比的CPU配置
    • 极客定位：产品均价高于联想、戴尔等巨头，常采用300美元级别的高端CPU（如R9 7940HS），而非主流的150美元CPU
    • 超过80%的收入来自海外市场
    • 公司更多以自有品牌与 OEM/ODM 生产、并通过全球分销与直销渠道（官网、海外零售商与平台）支撑成长，而非明显靠期权/风投驱动的扩张路径。

0223

  • search rag-skill, + rag-cli

0222

  • aionui + notebooklm-like-search

0221

  • coding-agent的

    • 代码搜索增强, 可参考 (augment-)context-engine, chunkhound
    • 文本搜索增强, 可参考 qmd(仅命令行), mgrep, notebooklm

  • this project provides MCP/cli for code search.

    • the legacy cli scripts/ctx.py only implements partial features of mcp servers.
    • in current git uncommited files, it's a new cli in a new separate folder cli that has implemented full features of code search and auto reindexing, using programatic function call and import useful existing code/lib instead of using mcp api call. features related to memory/context enhancement are not required to implement, focusing on good code search first.
    • there is a new skill at skills/context-engine-cli/SKILL.md to provide the new cli for other agent clients.

  • the goal is to review the uncommited code and refactor the new cli at cli to be pip installable, while making logic correct, code reuse, extensible, maintainable.

    • after refacotring, the new cli should be installable by pip install -e . or uv tool install -e . , and the cli name should be power-context, usage should be like power-context search "auth middleware". rename the skill name to be power-context.
    • analyze the architecture and core data flow, refactor the new cli and make sure the new cli code indexing and search is correct and clear. finally, provide updated agent skills .

0220

  • pip install -e . can install a package globally in every terminal cli. when i run uv pip install -e ., my package is not available from terminal . how to use uv to install a package Install in editable mode globally?
# --editable, -e: Install the target package in editable mode, such that changes in the package's source directory are reflected without reinstallation
uv tool install -e .

uv tool update-shell

uv tool list

  • git add -A vs git add .

    • git add .: Stages changes in the current directory and its subfolders. If you are in a subfolder (e.g., /src/components), it will only add files inside that folder. It ignores changes in the root or other sibling folders.
    • git add -A(--all): Stages changes in the entire repository.

  • this project provides MCP/cli for code search. the existing cli scripts/ctx.py only implements partial features of mcp servers. please write a new cli in a new separate folder that implements full features of code search and auto reindexing, using programatic function call and import useful existing code/lib instead of using mcp api call. features related to memory/context enhancement are not required to implement, focusing on good code search first. then write a new skill at skills/context-engine-cli/SKILL.md to provide the new cli for other agent clients.

  • this project provides MCP/cli for code search.

    • the existing cli scripts/ctx.py only implements partial features of mcp servers.
    • in current git uncommited files, it's a new cli in a new separate folder cli that has implemented full features of code search and auto reindexing as power-context, using programatic function call and import useful existing code/lib instead of using mcp api call. features related to memory/context enhancement are not required to implement, focusing on good code search first.
    • there is a new skill at skills/power-context/SKILL.md to provide the new cli for other agent clients.

  • the goal is to review the uncommited code and provide feedback for improvements, focusing on logic correctness, code reuse, extensibility, maintainability.

    • review the mcp implementation and the new power-context cli implementation, recheck code resuse and extensibility. analyze the architecture and core data flow, make sure the new cli code indexing and search is correct and clear. provide concise agent skills at skills/power-context/SKILL.md, removing commands that are unrelated to code indexing and search.

0219

  • 🤔 There are so many cli coding agents like claude-code/codex-cli/gemini-cli, is there any popular solution to unify the chat message into an interoperable format? for example, unify/export/manage claude code message and codex cli message. Is there any popular open source solution to this problem? if there is, list github repo and provide description for each.

    • there’s no single “one true” universal format yet — but two practical standards have emerged and are already used by many projects, and a few open-source tools already act as adapters/bridges.
    • If you want one place to start, treat the Model Context Protocol (MCP) as the canonical message/tool-call wire format and use AGENTS.md for repo-level agent instructions; then plug adapters (or use projects that already do this) so different CLIs/agents can interoperate.

  • AGENTS.md doesn’t replace a wire protocol, but it unifies how repositories present instructions and constraints to different agents. Good to combine with MCP for behavior + tooling.

  • https://github.com/open-voice-interoperability/openfloor-docs

    • This repository contains the specification and schemas for the Open-Floor Protocol family of Vendor-Independent specifications and supporting schemas developed by the Voiceinteroperability.ai initiative
    • The Open-Floor Conversation Envelope is a universal JSON structure whose purpose is to allow human or automatic agents (assistants) to interoperably participate in a conversation. When coupled with a specific protocol, such as HTTPS, a dialog agent that can generate and send Conversation Envelopes is capable of inter-operating with any other Open-Floor-compliant agent, regardless of the technology or architecture on which that other agent is based.

  • Model Context Protocol (MCP) : An open-source standard (maintained by Anthropic) for connecting AI applications to external systems. While not specifically for chat history export, it provides a standardized way for agents to interact with tools and data sources, creating a foundation for interoperability. Claude Code, Gemini CLI, and Codex CLI all support MCP integrations.

0216

  • 🤔 when i add a mcp to claude code like claude mcp add n8n-mcp, how does agent know when to use the mcp tools and what mcp tools are available? is it required to add explicit mcp instructions to CLAUDE.md ? there are many open source mcp on github, after adding some by commands like claude mcp add n8n-mcp, i am curious the internals about the mcp integration. does opencode-cli work the similar way?

  • How the Agent Discovers Available MCP Tools

    • When you run claude mcp add n8n-mcp, here's what happens under the hood:
    • Registration Phase: This stores the MCP server configuration in Claude Code's settings
    • Tool Discovery Phase (At Startup): When Claude Code starts a session, it Launches each registered MCP server as a subprocess (or connects via SSE/HTTP for remote servers), Calls tools/list on each MCP server via the MCP protocol — this is a standardized JSON-RPC method. These tool definitions are injected into the model's context — they become part of the tool-use schema that Claude (the LLM) sees. The model sees them exactly the same way it sees built-in tools like Read, Write, Bash, etc.

  • How the Agent Knows When to Use MCP Tools

    • The agent relies entirely on the tool descriptions and names. There's no magic routing — it works the same way all tool use works with LLMs. This is why good tool descriptions in MCP servers are critical.

  • Do You Need to Add Instructions to CLAUDE.md?

    • It's NOT required, but it's highly recommended for complex MCP setups.
    • Without CLAUDE.md instructions: The model only has the tool names and descriptions from the MCP server
    • It may not know the preferred workflow or when to prefer one tool over another

  • Does opencode-cli Work the Same Way?

    • Yes, opencode-cli follows the same MCP protocol, since MCP is a standardized protocol. The core mechanics are the same:
    • You configure MCP servers in opencode's config (typically opencode.json or similar)
    • At startup, it connects to MCP servers and calls tools/list
    • Tool definitions are injected into the LLM's context
    • The LLM decides when to call them based on descriptions

  • The MCP protocol is model-agnostic — any agent framework that implements the MCP client spec will discover and call tools the same way. The only difference is which LLM is doing the reasoning about when to use which tool.

0215

  • Still the same category of errors — WiredMemoryTicket, ToolCallFormat, ToolCallParser are all types that exist in mlx-swift 0.30.6 but not in 0.30.3. Even this older commit of mlx-swift-lm already depends on them.
    • The root cause is clear: the Package.resolved in the repo is stale. The CI passes because it resolves fresh and gets mlx-swift 0.30.6. Trying to find an mlx-swift-lm commit old enough to work with 0.30.3 would mean going back very far and likely breaking FlowDown's own code that depends on newer mlx-swift-lm APIs.
    • The correct fix is the other direction — update Package.resolved to use mlx-swift 0.30.6. Run these commands:
    • rm FlowDown.xcworkspace/xcshareddata/swiftpm/Package.resolved
    • rm FlowDown.xcodeproj/project.xcworkspace/xcshareddata/swiftpm/Package.resolved
    • rm -rf build
    • xcodebuild build
# FlowDown built from source and debugging

xcodebuild build \
    -workspace FlowDown.xcworkspace \
    -scheme FlowDown \
    -configuration Debug \
    -destination 'generic/platform=macOS' \
    -derivedDataPath ./build \
    CODE_SIGN_IDENTITY=- \
    CODE_SIGN_STYLE=Manual \
    CODE_SIGNING_REQUIRED=NO \
    CODE_SIGNING_ALLOWED=NO \
    COMPILER_INDEX_STORE_ENABLE=NO

lldb ./build/Build/Products/Debug-maccatalyst/FlowDown.app/Contents/MacOS/FlowDown

run

bt

cp -R ./build/Build/Products/Release-maccatalyst/FlowDown.app /Applications/

xattr -cr /Applications/FlowDown.app

0213

  • {"type":"10163", "error":{"type":"system_error", "message":"Provider API error: xunfei response error: sid: cht000bd483@dx19c584c088ab8aa700 msg: RequestParamsError:(02:38:24.169) '$.parameter.cbm.max_tokens' value must be less or equal than 16384; (request id: 20260214023823724232000Scx7MLQe)"}}
    • set max_tokens or remove it

0211

  • the README.md shows how to setup app with swift impelmentation at Build from Source. please add docs-mlx-py.md to guide the user how to setup with mlx python backend.

  • file dev-arch-gguf-mlx.md describes the core architecture for this llm chat app. analyze how the mlx swift server is implemented and integrated into the backend. please write a similar python implementation to replace the swift implementation. You should keep the existing features still working, and keep as many code as possible unchanged, then add a environment variable ENABLE_MLX_PY_BACKEND, if it's set to true, use python impelementation instead of the swift implementation. if it's set to false or unset, existing swift implementation is still used.

    • it's better to implement the python package as a separate module so that it's easy to maintain and keep changes to existing code as small as possible.
    • avoid writing python implementation from scratch, use project mlx-openai-server at folder /Users/yaoo/Documents/repos/ai-ml-llm/all-runtime-mlx/mlx-openai-server as a util/library, analyze its architecture, write a wrapper or glue code to implement the features like swift. make it easy for me to update the wrapper/glue code if mlx-openai-server code is updated.

  • this project is a llm chat app built with tauri. it supports using external llm api like openai/mistral api, as well as running local .gguf models and mlx models to provide api.

    • please analyze the project architecture and related code. explain the core architecture and data flow for the extensible architecture to support local models in different formats. write your result to dev-arch-gguf-mlx.md.
    • there are different approaches to run local models. is it possible to write a extensible module to make the logic of running swift mlx server swappable. i want to use python mlx-server implementation to replace the swift implementation.

  • 🤔 when i use claude-code-cli on my mac, why is it always using sonnet? will it switch between sonnet and opus automatically according to task complexity just like it uses haiku automatically ?

    • Claude Code does NOT automatically switch between Sonnet and Opus based on task complexity.
    • Main model (Sonnet 4) — Used for the primary agent loop (reasoning, coding, tool use)
    • Haiku — Used automatically for lightweight/cheap subtasks like: File summarization Background context gathering Simple classifications
    • Unlike the Sonnet → Haiku auto-switching, there is no automatic escalation to Opus for complex tasks. Opus is only used if you explicitly request it.

  • i want to run a local openai-compatible api . project mlx-lm and project mlx-openai-server both provide a solution. you can read mlx-lm/SERVER.md and mlx-openai-server/README.md. please analyze the code and architecture, compare the solutions to help me choose one.

  • 🤔 can i open multiple terminals on different folders, and run multiple claude code at the same time to work on different projects? will messages get messy and confused?

    • Yes, You Can Run Multiple Claude Code Instances Simultaneously
    • Each terminal session runs as a completely independent instance.

  • what if i open multiple terminals on the same folder, and run claude code on each terminal?

    • Yes, you can do it, but it gets risky.
    • Each terminal is still its own independent process with its own conversation. Claude won't confuse who said what across sessions.
    • But the Real Problem: File Conflicts

  • 🤔 i want to package python backend code into stand-alone executables. what's the most popular solutions? pyinstaller is licensed under GPL, why is it popular?

    • PyInstaller comes with a special "Bootloader Exception" (similar to the GCC Runtime Library Exception).
    • The Bootloader Exception: The actual executable you generate contains a small piece of binary code called the "bootloader" (which sets up the environment and runs your script). The authors explicitly grant an exception that allows you to link this bootloader with your own proprietary code without triggering the GPL requirement to open-source your app.
    • PyInstaller has a massive library of "hooks" that automatically find hidden imports for complex libraries like pandas or matplotlib, which often break in other packagers.

0208

  • context-engine for claude/MCP-client
cd ~/Documents/opt/compiled/qdrant && ./qdrant

uv run --env-file .env -- python -m scripts.mcp_memory_server
uv run --env-file .env -- python -m scripts.mcp_indexer_server

FASTMCP_TRANSPORT=http FASTMCP_PORT=8002 uv run --env-file .env -- python -m scripts.mcp_memory_server

FASTMCP_TRANSPORT=http FASTMCP_INDEXER_PORT=8003 uv run --env-file .env -- python -m scripts.mcp_indexer_server

uv run --env-file .env -- python -m scripts.ingest_code --root /Users/yaoo/Documents/repos/ai-ml-llm/aionui-office

# 更改vector相关配置时，需要
curl -X DELETE http://localhost:6333/collections/codebase
uv run --env-file .env -- python -m scripts.ingest_code --root /Users/yaoo/Documents/repos/ai-ml-llm/aionui-office --recreate

# --scope local (default): Available only to you in the current project
# --scope project: Shared with everyone in the project via .mcp.json file
claude mcp add --transport http --scope project qdrant-indexer http://localhost:8003/mcp
  • test mcp
    • Both servers are responding correctly — the initialize handshake succeeds on both ports. So the servers themselves are fine.
    • 💡 The issue is on the Claude Code side.
    • 排查方向转为 模型的 mcp tool call 是否能成功调用， 实测讯飞模型kimi调用会失败
    • Claude Code won't automatically use MCP tools for every question. The model decides based on relevance. Try being explicit: "Use the repo_search tool to search for 'authentication'" or "Use the qdrant-indexer MCP server to find code related to embeddings".
# test mcp connection
curl -s -X POST -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" http://localhost:8003/mcp -d '{"jsonrpc":"2.0","method":"initialize","params":{"protocolVersion":"2024- 11-05","capabilities":{},"clientInfo":{"name":"test","version":"0.1"}},"id":1}'

# event: message
# data: {"jsonrpc":"2.0","id":1,"result":{"protocolVersion":"2025-06-18","capabilities":{"experimental":{},"prompts":{"listChanged":false},"resources":{"subscribe":false,"listChanged":false},"tools":{"listChanged":false}},"serverInfo":{"name":"qdrant-indexer-mcp","version":"1.17.0"}}}

  • You are a professional python/typescript/nodejs fullstack developer and a system administrator.

    • I want to run this project fully locally without docker and nginx for local development and debugging.
    • please read setup-related files like docker-compose.yml/README.md/docs/ARCHITECTURE.md or other files, and tell me step by step how to configure and run this project as MCP server locally. i want to self host this mcp server and use it with local claude-code.
    • i have already installed python/uv/npm/QdrantDB/Ollama/postgresql/mysql/redis on my local macos.
    • just tell me steps and commands to set up backend/frontend, i will start services like db/redis later.

  • Chroma Architecture

    • Chroma delegates, as much as possible, problems of data durability to trusted sub-systems such as SQLite and Cloud Object Storage, focusing the system design on core problems of data management and information retrieval.
    • In Local and Single Node mode, all components share a process and use the local filesystem for durability.
    • v0.4.0_202307
      • drops duckdb and clickhouse in favor of sqlite for metadata storage.

0206

0201

  • 美国最大电子零售商处理摸摸机, 指的是那个平台或网站
    • Best Buy (百思买)：是美国最大的消费电子零售商（实体+线上）。
    • 而在海淘圈或数码爱好者口中，专门处理“摸摸机”（即被顾客退货、仅开箱或短暂使用过的产品）的平台，通常指的是 Best Buy 官网旗下的 Open-Box 板块。
    • Open-Box (开箱版)：这是 Best Buy 官网上一个专门的分类。由于美国退货政策宽松（通常为14-30天无理由退货），许多顾客买回家拆封试用几天后退货，这些产品经过检测后会重新上架销售，价格通常比全新版便宜很多。
    • 为什么叫“摸摸机”：因为这些机器被上一任买家“摸过”（使用过），所以中文社区戏称为“摸摸机”。
    • CowBoom 曾是 Best Buy 旗下的独立清仓网站，专门用来以极低的价格甩卖二手、翻新和开箱产品。 现状：该网站已于几年前被关闭，相关业务已完全整合回 Best Buy 官网的 Outlet / Open-Box 频道 以及 Best Buy 在 eBay 上的官方店。
  • 在 Best Buy 购买“摸摸机”时，通常会看到以下等级，成色越差价格越低：
    • Excellent - Certified：官方认证，接近全新，通常有原盒和完整配件。
    • Excellent：外观看起来像新的，无明显划痕，配件齐全。
    • Satisfactory：有轻微划痕或使用痕迹，可能缺少非必要配件。
    • Fair：有明显划痕或凹痕，可能缺少重要配件，但功能正常。
  • 另一个常见平台：Amazon Warehouse (现更名为 Amazon Resale)
    • 亚马逊处理退货产品的部门原名叫 Amazon Warehouse（最近改名为 Amazon Resale/Renewed）。很多海淘用户也会去那里淘二手数码产品。

dev-01-ppt-edit-eg-&-promptfoo-eval-&-llm-backend-llamacpp-mlx-&-donehub-llm-api

0130

  • 🤔 i want to implement a rag app for pdf files. To support scanned pdfs, i want to create a solution that support different ocr models like mineru and paddleocr. but the outputs of mineru and paddleocr is different . Is there a popular ocr protocol or specification that unifies the outputs of different ocr models? analyze popular apps or open source projects, and explain to me what's the best practice

    • there is no single "official" industry standard protocol (like ALTO or hOCR) that modern RAG applications use. While legacy XML formats exist, they are too verbose for LLMs.
    • The best practice today, adopted by popular open-source frameworks (like Docling, DeepDoctection, and Unstructured), is to normalize everything into an internal Intermediate Representation (IR)—usually a structured JSON object—and then export that to Markdown for the LLM.

  • Since MinerU and PaddleOCR speak different languages, you should build a Wrapper / Adapter Layer that converts their raw output into your own Unified Data Class.

  • How Popular Projects Handle Multi-OCR Unification

  • Pattern A: Adapter/Plugin Architecture (RAGFlow)

    • RAGFlow treats OCR as layout parsers rather than text extractors
    • RAGFlow doesn't try to unify at the OCR output level; instead, it unifies at the document object level after full parsing. They treat MinerU as a "layout analyzer" that feeds into chunking strategies

  • Pattern B: Unified Interface Wrapper (Upsonic OCR)

    • Upsonic provides a factory pattern that normalizes at the API level

  • Pattern C: Pipeline Abstraction (ocrpy)

    • ocrpy library takes a configuration-driven approach
    • They abstract the storage layer (S3, GCS, local) alongside OCR backends, treating document processing as an ETL pipeline

  • For a RAG application supporting MinerU and PaddleOCR, I recommend creating a canonical internal representation rather than forcing both into an existing standard.

    • Step 1: Define a Canonical Schema (Pydantic)
    • Step 2: Implement Adapter Pattern
    • Step 3: Factory & Configuration

  • IBM's Docling implements exactly this pattern with their DoclingDocument class—a unified internal representation that can export to Markdown, HTML, or JSON. They support plugging in different layout models and OCR backends while maintaining a consistent document object model

0129

{
    "code": 0,
    "msg": "ok",
    "trace_id": "ff0527169d6eeda17d5b558b2f650580",
    "data": {
        "batch_id": "1820a77f-ee2b-4d7c-ba09-9029b6d254df",
        "file_urls": [
            "https://mineru.oss-cn-shanghai.aliyuncs.com/api-upload/extract/2026-01-29/1820a77f-ee2b-4d7c-ba09-9029b6d254df/9a9ea9b9-8b3a-4a63-994c-0a7a79b697d3.pdf?Expires=1769765834&OSSAccessKeyId=LTAI5t9nGwatk85zetzojXbn&Signature=0ctVyoNI14t0qGVziHlkTDpmAW4%3D"
        ]
    }
}
  • “based” 在英美互联网里是褒义俚语，意思大致是“真诚、不迎合潮流、值得尊敬/赞同”（反义是 “cringe”）。
    • 在现代英文网络文化（尤其是 4chan, Reddit, Twitch, Twitter）中，"Based" 是一个非常流行且高度褒义的形容词。
    • 所以 “Is drinking water based?” 更像是在开玩笑地问“喝水这事儿酷不酷/值得赞？” —— 典型的幽默/讽刺提问。
    • 字面意思： 喝水这件事很酷/很赞/很硬核吗？

0128

  • the goal is opencode-cli bundled just like the existing gemini-cli. and you provide a new environment variable for user to choose which cli to use. you have aleady implemented it, but with bugs. so opencode-cli is just implemented by referring to gemini-cli, but with bugs.

  • i start electron app with opencode-cli by npm run opencode:start. when i select a custom model from chatbox models dropdown and send chat message, ai answers well. then i click "New Chat" button, and send a new message to start a new chat, ai also answers well but the terminal often shows a error log like below

  • when i start electron app by npm start, it uses gemini-cli by default, not opencode-cli. when i select a folder fo1 at chatbox and start chatting, why is a new .opencode folder generated at the folder fo1? analyze related code and architecture, find the reason and fix it. .opencode folder should only be generated when i set environment variable to use opencode-cli.

  • your solution should make it work for starting a new chat with the same model or with a different model that user selected from the chatbox models dropdown menu.

    • Looking at the architecture, I see the real issue: each chat is trying to use its own workspace, but the OpenCode server is shared across all chats. When the second chat creates a config in its workspace, it's either: - Overwriting the config in the same workspace (if workspaces are accidentally shared) - Creating a config in a different workspace that the server can't see
    • The solution is to: 1. Use a single global workspace for all OpenCode chats (since OpenCode has built-in session management) 2. Merge model configs instead of overwriting when adding a new model 3. Track which models are already configured to avoid unnecessary config updates

0127

  • Uses @ai-sdk/openai-compatible: This is the key - OpenCode has built-in support for OpenAI-compatible APIs

[Config] Using OpenCode CLI provider
[OpenCode] Configuration:
  - Base URL: https://integrate.api.nvidia.com/v1
  - Custom Provider ID: custom-nvidia
  - Model String: moonshotai/kimi-k2-thinking
[OpenCode] Creating config: {
  "provider": {

    "custom-nvidia": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Custom Provider (nvidia)",
      "options": {
        "baseURL": "https://integrate.api.nvidia.com/v1",
        "apiKey": " ***MASKED*** "
      },
      "models": {
        "moonshotai/kimi-k2-thinking": {
          "name": "moonshotai/kimi-k2-thinking"
        }
      }
    }

  }, 
  "model": "custom-nvidia/moonshotai/kimi-k2-thinking"
}
[OpenCode] Created config at: /Users/yaoo/.aionui/gemini-temp-1769495685105/.opencode/opencode.json
[OpenCode] Configured provider: custom-nvidia, model: moonshotai/kimi-k2-thinking
[OpenCode] Starting server on port 4096
[OpenCode] Using binary: /Users/yaoo/Documents/repos/office/aionui-office/node_modules/.bin/opencode
[OpenCode] Working directory: /Users/yaoo/.aionui/gemini-temp-1769495685105
[OpenCode Server] INFO  2026-01-27T06:34:45 +18ms service=models.dev file={} refreshing
[OpenCode Server] Error: Unexpected error, check log file at /Users/yaoo/.local/share/opencode/log/2026-01-27T063445.log for more details

Failed to start server on port 4096
[OpenCode] Stopping server
[OpenCode] Force killing server


[Config] Using OpenCode CLI provider
[OpenCode] Configuration:
  - Base URL: https://integrate.api.nvidia.com/v1
  - Custom Provider ID: custom-nvidia
  - Model String: moonshotai/kimi-k2-instruct-0905
[OpenCode] Creating config: {
  "provider": {

    "custom-nvidia": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Custom Provider (nvidia)",
      "options": {
        "baseURL": "https://integrate.api.nvidia.com/v1",
        "apiKey": " ***MASKED*** "
      },
      "models": {
        "moonshotai/kimi-k2-instruct-0905": {
          "name": "moonshotai/kimi-k2-instruct-0905"
        }
      }
    }

  }, 
  "model": "custom-nvidia/moonshotai/kimi-k2-instruct-0905"
}
[OpenCode] Created config at: /Users/yaoo/.aionui/gemini-temp-1769495507065/.opencode/opencode.json
[OpenCode] Configured provider: custom-nvidia, model: moonshotai/kimi-k2-instruct-0905
[OpenCode] Starting server on port 4096
[OpenCode] Using binary: /Users/yaoo/Documents/repos/office/aionui-office/node_modules/.bin/opencode
[OpenCode] Working directory: /Users/yaoo/.aionui/gemini-temp-1769495507065
[OpenCode Server] INFO  2026-01-27T06:31:47 +20ms service=models.dev file={} refreshing
[OpenCode] Server ready
[OpenCode] Session created: ses_401d94c64ffeqICmuZ6Vvhzs8V
[OpenCode] Initialization complete
[OpenCode] Already initialized
[OpenCode] refreshAuth called (no-op for OpenCode)
[OpenCode] Tool registration skipped: aionui_web_fetch
Loaded cached credentials.
[OpenCode] Tool registration skipped: gemini_web_search
[OpenCode] setTools called (no-op for OpenCode)
[StreamMonitor] State changed to: connecting 
[OpenCode] sendMessageStream - Query text: tell a joke within 20 words...
[OpenCode] Sending request to: http://localhost:4096/session/ses_401d94c64ffeqICmuZ6Vvhzs8V/message
[OpenCode] Request body: {
  "parts": [

    {
      "type": "text",
      "text": "tell a joke within 20 words"
    }

  ], 
  "model": {

    "providerID": "custom-nvidia",
    "modelID": "moonshotai/kimi-k2-instruct-0905"

  }
}
Loaded cached credentials. jinyaoo86@gmail.com
[OpenCode] Response status: 200 OK
[OpenCode] Response received, info: {
  "id": "msg_bfe26bd6a001GvLaLYy51OVjXt", 
  "sessionID": "ses_401d94c64ffeqICmuZ6Vvhzs8V", 
  "role": "assistant", 
  "time": {

    "created": 1769495510378,
    "completed": 1769495513270

  }, 
  "parentID": "msg_bfe26bd51001ZT2WptJDT1M2ue", 
  "modelID": "moonshotai/kimi-k2-instruct-0905", 
  "providerID": "custom-nvidia", 
  "mode": "build", 
  "agent": "build", 
  "path": {

    "cwd": "/Users/yaoo/.aionui/gemini-temp-1769495507065",
    "root": "/"

  }, 
  "cost": 0, 
  "tokens": {

    "input": 10420,
    "output": 13,
    "reasoning": 0,
    "cache": {
      "read": 0,
      "write": 0
    }

  }, 
  "finish": "stop"
}
[OpenCode] Response parts count: 3
[OpenCode] Processing 3 parts
[OpenCode] Processing part: step-start
[OpenCode] Processing part: text
[OpenCode] Yielding text part, length: 66
[StreamMonitor] State changed to: connected 
[OpenCode] Processing part: step-finish
[OpenCode] Token usage: {
  input: 10420, 
  output: 13, 
  reasoning: 0, 
  cache: { read: 0, write: 0 }
}
[OpenCode] Returning final turn, hasContent: true parts: 1
[StreamMonitor] State changed to: disconnected 
Loaded cached credentials. jinyaoo86@gmail.com

0126

  • 🎯 the goal is opencode-cli bundled just like the existing gemini-cli. and you provide a new environment variable for user to choose which cli to use. you aleady have implemented it, but with bugs. so opencode-cli is just implemented by referring to gemini-cli, but with bugs.

  • i start electron app with opencode-cli by npm run opencode:start. when i chatted, it not work.

  • when i restarted and chatted again, it not work. the terminal log is

  • the original workflow for gemini-cli is that user selects a custom provider and model from chatbox dropdown, and gemini-cli will use it for chatting. please analyze the code and dataflow, and make it work for opencode-cli.

  • user can configure custom provider and custom model from settings ui, then use it from chatbox dropdown menu. please assume user is always using custom provider and custom model, do not rely on the naming pattern of model-name or provier-name.

  • analyze related code and review the data flow. the original gemini-cli works well when chatting with custom model. please make the chatting with opencode-cli work in a similar way.

  • your previous fix by searching "think" in model name is not robust. when i use a thinking model that does not contain think in the model name, it will not work. a better solution is to parse the think event in ai response. you can read gemini-cli related code and analyze how it deals with thinking parts in response . then read opencode-cli related code , try to parse and show thinking content in electron ui in a similar way.

  • review your implementation. when i select custom model from chatbox dropdown ui, will chat work with opencode-cli? the original gemini-cli works well. recheck the data flow, and make it work for opencode-cli

  • opencode-cli is not required to install globally. you already include it via a wrapper like the original gemini-cli wrapper "@office-ai/aioncli-core".

  • please refer to how gemini-cli supports openai-compatible provider, and make opencode-cli supports openai-compatible provider in the similar way.

  • the original gemini-cli works well. for the opencode implementation, please read related code and architecture to make text-chat/streaming/tool-call/file-read/file-write more robust

  • the original gemini-cli is imported as @office-ai/aioncli-core as an npm package dependency, and i can use the default gemini-cli without installing gemini-cli. is your implementation for opencode can be used in a similar way? if i set the environment variable to opencode, can i use it without installing opencode-cli?

  • the task has already been implemented by you . i want you to review the existing gemini-cli implementation and improve your opencode-cli implementation. just use git diff to see what you have edited

  • the goal is opencode-cli bundled just like the existing gemini-cli. and you provide a new environment variable for user to choose which cli to use. the opencode-cli architecture should be like gemini-cli. analyze related code and architecture, review your edits and improve your code.

  • remove testing step in your plan. you should do the core implementation first, we will write tests later.

  • this project provides llm electron app and web app that can chat with cli agent like claude-code/codex-cli/gemini-cli/opencode-cli. a modified gemini-cli is bundled by default, other cli needs to be installed manually. Chatting with the built-in bundled gemini-cli is implemented internally, while chatting with other cli is handled by ACP protocol.

  • the goal is to add a new opencode-cli-mini bundled just like the existing gemini-cli. and add a new icon of opencode-cli-mini after the first default gemini-cli icon for user to select which cli to use. when using the app, if the first gemini-cli icon is selected, bundled gemini-cli should be used, and existing features should still work. if the second opencode-cli-mini icon is selected, bundled opencode-cli should be used, and most existing features should still work. features for the existing bundled gemini-cli should also work for the new bundled opencode-cli-mini. the original gemini-cli is imported by @office-ai/aioncli-core as an npm package dependency, and i can use the default gemini-cli without installing gemini-cli. make your implementation for opencode-cli can be used in a similar way.

  • The implementation should be extensible so that it should be easy to add more bundled cli in the future. creating a standalone package like gemini-cli wrapper @office-ai/aioncli-core for opencode-cli-mini may be an approach. when user configures the llm model at Settings--Model page and select the model at chatbox models dropdown list , it should work for all bundled cli like gemini-cli/opencode-cli-mini.

  • the existing acp impelmentation with opencode-cli should be kept unchaged for backward compatibility, it will not be used anymore. do not use the existing opencode acp integration.

  • you should keep as many existing code as possible to stay unchanged so that it is easy to merge upstream changes later.

  • the following resources may be useful for your reference:

  • the source code for gemini-cli wrapper @office-ai/aioncli-core is at folder /Users/yaoo/Documents/repos/office/aioncli/packages/core. you can find api or docs and more details at /Users/yaoo/Documents/repos/office/aioncli .

  • opencode cli can be installed by npm install opencode-ai. the source code for opencode-cli is at /Users/yaoo/Documents/repos/ai-ml-llm/opencode/packages/opencode/src/cli. you can find api or docs and more details at /Users/yaoo/Documents/repos/ai-ml-llm/opencode .

  • analyze related code and architecture , make a plan and write your plan to plan-opencode-cli-mini.md, ask for approval before implement it.

  • when writing or editing large files, it's easy to fail if the content to write is large. you can write small edits multiple times to avoid large edits.

  • review the goal, analyze related code and architecture , finally update your plan at plan-opencode-updated.md

  • I want the opencode-cli bundled just like the existing gemini-cli. and you provide a new environment variable for user to choose which cli to use. if the environment variable is not set, gemini-cli should be used, and existing features still work. if environment variable is set to opencode, opencode-cli should be used, and the most existing features still work. The implementation should be extensible so that other environment variable value can be used to support more cli in the future. reiew your previous plan at plan-opencode-updated.md and recheck the goal. optimize and update the plan.

  • I want you to make a standalone package like @office-ai/aioncli-core for opencode-cli-mini. the source code for "@office-ai/aioncli-core" is at folder /Users/yaoo/Documents/repos/office/aioncli/packages/core. you can find api/docs and more details at /Users/yaoo/Documents/repos/office/aioncli. Now review your previous plan at plan-opencode.md and updated your plan. I have reverted all your previous edits.

0125

0124

0123

  • Some love for MacOS gpu · Issue · microsoft/onnxruntime _202207

    • onnxruntime-gpu depends on CUDA.
    • Nvidia only provide CUDA downloads for two operating system: Linux and Windows.
    • macOS users need to use coreml for GPU acceleration, or webgpu which we are still developing the support.

  • dev-to

    • ocr api as openai api

  • dev-log

    • ocr solution: deepseek-ocr api as openai api

0122

  • claude "query" vs claude -p "query":

    • claude "query" opens the interactive REPL with that query as the initial prompt;
    • claude -p "query" runs a one-off (print/SDK) query, prints the result, and exits — useful for scripts or piping.

  • 🤔 is there any popular apps or open source projects that is a cli tool wrapper? vlc is a good example, as ffmpeg wrapper. I'm trying to build something similar and need some references. find related examples and provide each with description/github-repo...

    • ollama
    • git ui

0121

  • 🤔 is there any popular apps or open source projects that use database as storage and files as cache? git is a good example, because the the internal human-unreadable data is storage in .git, and files are just a cache. Is there any other apps or projects use this architecture or design? and how to make data/db and files sync? I am looking for a good reference for implement my own. find related examples and provide each with description
  • Git — content-addressable object DB + working tree as cache
    • Git stores everything (blobs, trees, commits) inside .git (object database and refs); the working directory is a checked-out, human-readable cache of that data. You can reconstruct the repo entirely from .git.
  • git-annex — content stored in annex (key/value) tracked by Git refs, working files optional
    • git-annex stores file contents in a separate annex directory and keeps metadata/location information in Git. Files in the working tree can be pointers or actual content; clones collectively host the distributed key/value store.
  • DVC (Data Version Control) — metadata in Git, large files in remote store, local files as cache
    • DVC keeps small pointer/metadata files in Git (hashes, remotes, versions). Large data (datasets, models) is stored in remote object stores (S3/GCS/etc). The local filesystem holds a cache/checkout of the currently needed blobs.
  • IPFS (content-addressed block store) — block/object DB + file DAGs + local pin/cache
    • IPFS stores content-addressed blocks in a blockstore; files are DAGs of those blocks. Nodes pin the blocks they want to keep; a local filesystem view (FUSE mounts, HTTP gateways) materializes files from the blockstore.

0120

  • [BUG] Mistral LLM Fails with Tools Due to Role Expectation · Issue · crewAIInc/crewAI

  • 🧩 in local mlx llm, q5.5bit quant achieved 1.25 perplexity in our testing. what does perplexity mean for model?

    • Perplexity (PPL) is the standard metric used to evaluate how well a model predicts the next token in a sequence.
    • Perplexity is a measurement of how well a probability model (like your LLM) predicts a sample of text. In simple terms, it measures the model's "surprise" or "uncertainty" when seeing new text.
    • Lower is better. A lower score means the model is less surprised by the text it sees.
    • PPL = 1.0 is perfect (model always assigns probability 1 to the true token).
    • A PPL of 1.25 implies the model is highly confident and usually puts ~80% probability mass on the true next token — unusually good for typical open-domain text.
    • Higher is worse. A high score means the model is confused and struggling to guess what comes next.
    • If the Perplexity is 100, the model is as confused as if it had to pick blindly from a bag of 100 equally likely words.
    • If the Perplexity is 1.25, the model is effectively choosing between 1.25 options.
    • A perplexity of 1.25 is extremely low: it means the model’s geometric mean probability for the true next token is 1 / 1.25 = 0.8 (80%).

0116

  • 🤔 i want to develop a electron app with python backend server bundled as a single package . user downloads the package and use it , without separate commands for starting server. what's the best practice to achieve this? is there any open source app or github repo that already implemented this? if there is, give me the app or github repo url with description. comfyui desktop app seems to be a good example, but it's too complicated. find more examples and explain to me.

    • Most robust option: bundle a standalone Python runtime (or a PyInstaller’d single executable) into the app, and have the Electron main process spawn that Python server on app start, wait for it to become ready, then load the renderer

  • Approaches

  • 💡 Bundle a full Python runtime (standalone) + spawn it at startup

    • include a ready-to-run Python folder (or embeddable Python) in your app resources and call it directly. The app does not require the user to install Python.
    • full Python features, supports dynamic pip install if needed.
    • Cons: large binary size.
    • 🌰 Real project pattern: Datasette Desktop (Simon Willison) describes bundling a standalone Python in the app.
    • Bundling Python inside an Electron app | Simon Willison’s TILs _202109

  • 💡 Compile your Python backend to a single executable (PyInstaller / pyoxidize / py2exe) and include that executable

    • produce a single exe (or macOS binary) and include it in extraResources of your Electron build.
    • smaller than full runtime in some cases; simpler startup (one binary to spawn).
    • Cons: platform build complexity, native deps can be tricky.
    • Electron packaging guides and many community posts recommend this flow.

  • 💡 Sidecar / managed install on first run (ComfyUI style)

    • ship a lightweight bootstrap/electron wrapper that installs Python dependencies at first start (or downloads model files) and then starts the server. Useful for huge dep sets (e.g., ML models).
    • Pros: smaller initial download; flexible updating of backend and models.
    • Cons: first-run complexity and long install times; network required.

  • 💡 Use Tauri with a sidecar binary (alternative to Electron)

    • Tauri has official sidecar support and first-class bundling for external binaries
    • Cons: different stack (Rust toolchain) and ecosystem differences.

  • https://github.com/lmstudio-ai/venvstacks

    • venvstacks is a tooling / packaging model that layers Python virtual environments into three conceptual layers — runtime (the Python interpreter), framework (big shared frameworks such as PyTorch/CUDA/MLX), and application (your app code).
    • Layers are built and published as deterministic, self-contained archives and then composed on the target machine so multiple apps can share large framework/runtime pieces instead of duplicating them.

  • LM Studio needed to ship frequent app features that depend on heavy Python ML stacks, but they didn’t want every release to include a full copy of PyTorch/CUDA or duplicate runtime binaries.

    • On the client, layers are unpacked into a shared place, post-install scripts are run starting from the runtime up, and then the app layer is launched with the runtime’s interpreter
    • This enables smaller per-app downloads, and independent upgrades of framework/runtime layers.

  • Building layer archives and maintaining cross-platform build automation is more complex than a single PyInstaller build.

    • There are constraints on relocatability, native extension linking, and you must run postinstall scripts carefully on the client. venvstacks documents these limitations.

  • ComfyUI / Portable style, you are looking for the Bundled Runtime (Portable Python) architecture.

    • This differs from the PyInstaller approach. Instead of compiling your code into a frozen .exe, you ship a raw, miniature Python folder (interpreter) inside your app.
    • This approach is popular for AI apps (like ComfyUI, Automatic1111) because it allows the app to be extensible. Users can add custom nodes or modify Python files because the code isn't locked inside a compiled binary.

0115

  • electron python runtime

  • transformerlab-app model site:reddit.com

  • multiple inference mlx llama.cpp github

  • which expression is more natural in english: "please use the articles above to create a summary" vs "please use the above articles to create a summary"

    • "Please use the articles above..." (Most Common/Natural)
    • This is the most standard way to say it in modern English. Using "above" after the noun (as a post-positive modifier) indicates location clearly.
    • "Please summarize the provided articles."

0114

  • electron 打包 python runtime 的示例

  • 广州商科集团是一家创立于1994年的公司，旗下主要运营着铭瑄(Maxsun)、梅捷(SOYO)和台电（TECLAST） 这三大品牌

    • 梅捷品牌：源自台湾，创立于1985年，专注于主板研发。目前，该品牌在中国大陆的运营权归属于广州商科集团。
    • 梅捷的产品线非常专注于主板领域，其特点是在主流和入门级价位段
    • “梅捷”就是品牌名 SOYO（中文常写作“梅捷”/“梅捷科技”），原为台湾主板厂，后来大陆业务被商科集团（也就是铭瑄/台电同集团）收购并在大陆以 SOYO/梅捷 名义继续销售主板、显卡等产品

0113

  • it's hard to find llm server example that supports pluggable backend like .gguf/.mlx. can you find some other server example that supports pluggable backend? you can find examples for other cases like reading/conversion/editing for document/image/pdf ... . I want to see the best practice on how to implement pluggable backends. if you can find, give me some github repos and description

  • Docling — document converter with format-specific backends

    • Study how it maps file-type → backend and orchestrates pipelines. Very relevant for mapping model file format (.gguf/.mlx) → runtime backend.

  • Dynamic Loading: Use Python's importlib if you want to drop new backends into a folder without restarting the server, or simple if/else factories if you only have 2-3 backends.

  • How to Design Your Own (Best Practices)

    • you should use the Registry + Adapter Pattern.
    • Step 1: Define the Protocol (The "Interface") Don't write code for Llama or MLX yet. First, define what a "Model" is to your server.
    • Step 2: Implement the Adapters (The "Plugins") Create separate files for each backend. This isolates dependencies. If a user doesn't have Apple Silicon, the MLXBackend import will fail, but the server will still run LlamaCppBackend.
    • Step 3: The Factory (The "Router") This is the piece most tutorials skip. You need a function that looks at the file extension and picks the right class.

0111

{
  "compilerOptions": {
    "noUnusedLocals": false
  }
}
# After making edits and committing:
git add .
git commit -m "your message"
git tag v1.0.3
# pushes both the main branch commits AND the v1.0.3 tag in one command
git push origin main v1.0.3
  • When you push a tag, both build.yml and release.yml will trigger. They both build and release, which is redundant. You may want to disable one of them later, but for now both will create releases.

0110

  • 🤔 is there any electron examples that use client/server architecture so that it supports both windows/mac desktop app and webapp? i want to support both web ui and desktop app usage. if there's any open source repo, show the url and description

  • Actual Budget (Best "Local Server" Example)

    • Repository: github.com/actualbudget/actual
    • It uses a client/server architecture where the "server" can run in the cloud (for the web app) or locally (inside the Electron app)
    • Web Mode: The frontend runs in the browser and talks to a remote server API.
    • Desktop Mode: The Electron process spawns a local instance of the server code. The frontend (running in the Electron window) connects to this local server via localhost.

  • Hoppscotch (Best "Shared Frontend" Example)

    • Repository: github.com/hoppscotch/hoppscotch
    • It is built as a Progressive Web App (PWA) first. The desktop version is essentially a wrapper around the web application but adds "native" capabilities (like bypassing CORS) that a browser cannot do.
    • It treats the "Client" as a completely separate entity from the environment it runs in.
    • It uses a "Proxy" server approach to handle requests that would otherwise fail in a pure web environment due to browser security restrictions.
    • It shows how to structure a massive Vue.js application so it works flawlessly in a browser and as an installed desktop app.

  • Visual Studio Code (The "Gold Standard")

    • Architecture: Process Separation. They separate the Workbench (UI) from the Extension Host (Logic/Server).
    • When you run the Desktop app, the "Server" runs locally on your machine (accessing your local files).
    • When you run the Web version, the "Server" runs remotely (like in GitHub Codespaces) or in a limited browser sandbox.
    • The UI code communicates with the Server code via JSON-RPC, meaning the UI doesn't care if the server is local or remote.

  • Next.js + Electron Boilerplate (Best for Starting New)

    • Repository: github.com/saltyshiomix/nextron
    • If you are starting from scratch and want to build a React/Next.js app that serves as both, this is the most popular boilerplate (often called "Nextron").
    • It configures the build system (Webpack/Turbo) to output two targets from your code:
    • Web: A standard Next.js build for your website.
    • Desktop: An Electron renderer build that loads the Next.js pages.
    • It doesn't strictly force a "server" architecture, but it sets up the Shared Code structure for you. You can put your logic in a shared/ folder and import it into both the renderer/ (Frontend) and main/ (Electron Backend) folders.

  • 🤔 for a github repo with a package.json file, for one author, it's "author": { "name": "Jonathan Wheeler", "email": "jonathan.wheeler87@gmail.com" }, . if there are 2 authors, how to write?

    • If you have two authors, you should use the contributors array
    • Option 1: Co-Authors (Equal Status)
    • Option 2: Author + Contributor

0109

  • Conversation Compaction Failure: Summary Generation Error · Issue · anthropics/claude-code

    • I launched the compact command for a second try and it worked without issues

  • 🤔 when i have used claude code for a long time , context is too long but todos are still in progress. can i interrupt it and execute /compact to reduce context and continue to finish todos? if it's possible, how to do it in claude code?

    • If Claude is currently running a long task or stuck in a loop, you can interrupt it by pressing: Ctrl + C
    • While you can just type /compact, the safest way to ensure your specific todos are not lost in the summary is to provide a prompt to the compact command.

0108

  • 🆚 i want to build an online image editor webapp. I want to add text and resize image. knova and fabric.js js seems to be good library. please compare them. or do you have any better suggestion?
  • Choose Konva.js if you are using React and need high performance (e.g., thousands of objects). However, you will have to build your own "resize handles" and "text editor overlay" (using a hidden HTML <textarea>), as Konva does not have these native UI controls.
    • If you want high-performance shape/animation-heavy editors and a very polished React integration → Konva (with react-konva).
    • Scene Graph Architecture (like game engines) . Objects are organized in a hierarchical tree (layers, groups, shapes).
  • Choose Fabric.js if you want "out-of-the-box" editor features. It has built-in support for resizing handles, rotating, and a real text cursor (selectable text), saving you weeks of coding.
    • If you want ready-made canvas object-model features like inline text editing, SVG import/export, image filters/cropping and lots of editor examples → Fabric.js.
    • Object-Oriented Canvas Model. It provides a rich object model over the native Canvas API, treating everything (images, text, shapes) as objects that can be manipulated individually
  • Konva: modern canvas abstraction with layers, nodes and Transformers. Works best if you treat canvas like a scenegraph; editing text is usually done via a DOM <input> overlay (Konva recommends using native inputs for editing).
    • Konva. Text for rendering. For user editing you typically overlay an input/textarea and sync it back to the Konva node (Konva has examples).
  • Fabric: a higher-level object model over canvas (objects, groups, IText/Textbox, image primitives) and built-in inline text editing (IText/Textbox). Easier to get an editable text UX fully on-canvas.
    • IText/Textbox support native editing behavior on canvas (selection, caret, copy/paste, wrapping). If editable-on-canvas text is a big requirement, Fabric is simpler out of the box.
  • Both libraries can run in Node (via node-canvas / explicit canvas backends) and can export canvases to images;

0106

  • 🤔 i want to run ocr llm model locally. why does llama.cpp not support deepseek-ocr gguf, but ollama supports deepseek-ocr since ollama uses llama.cpp under the hood?
  • Ollama's new engine for multimodal models · Ollama Blog _202505
    • Ollama has so far relied on the ggml-org/llama.cpp project for model support and has instead focused on ease of use and model portability.
    • As more multimodal models are released by major research labs, the task of supporting these models the way Ollama intends became more and more challenging.
    • We set out to support a new engine that makes multimodal models first-class citizens, and getting Ollama’s partners to contribute more directly to the community via the GGML tensor library.
    • Today, ggml/llama.cpp offers first-class support for text-only models. For multimodal systems, however, the text decoder and vision encoder are split into separate models and executed independently. Passing image embeddings from the vision model into the text model therefore demands model-specific logic in the orchestration layer that can break specific model implementations.
    • Within Ollama, each model is fully self-contained and can expose its own projection layer, aligned with how that model was trained. This isolation lets model creators implement and ship their code without patching multiple files or adding cascading if statements. They no longer need to understand a shared multimodal projection function or worry about breaking other models—they can focus solely on their own model and its training.

0104

  • 🤔 https://huggingface.co/datalab-to/chandra this model uses OpenRAIL license. if i use this model locally on ocr saas webapp, is it free to use? is OpenRAIL license commercial friendly?

    • 此问题deepseek回答无法访问网页而拒绝，gemini/grok/chat-glm幻觉，chatgpt询问是否要fetch license文件的内容因而最准确

    • https://huggingface.co/datalab-to/chandra/blob/main/LICENSE

    • check the exact OpenRAIL variant and its prohibited-use clauses. OpenRAIL licenses are explicitly designed to permit reuse, distribution and commercialization of models while adding responsibility / prohibited-use rules.

    • it’s a Modified OpenRAIL-M license, with explicit restrictions

    • Attachment A - USE RESTRICTIONS

      • Commercial and broader use licenses may be available from Licensor
      • for any purpose if You (your employer, or the entity you are affiliated with) generated/raised more than two million US Dollars

  • 65风格发言指的是什么

    • “65风格发言”源自中国 CS: GO（反恐精英） 圈子，特指知名主播QUQU的老板/队友 B65（人称B哥、65）的说话方式。
    • 要掌握或识别“真正的65风格”，你需要抓住以下几个核心要素：极度的自信、独特的口头禅、对“游戏理解”的自我吹捧，以及一种“老板”特有的指点江山的气质。
    • 真正的65风格离不开这几个词，如果缺少了它们，就没有那个味儿：
    • “常规”：这是65风格的灵魂。无论做什么操作（哪怕是白给），都要说是“常规操作”。
    • “顶级”：形容自己的意识、道具或枪法。
    • “理解”：指游戏阅读能力。
    • “满昏”：即“满分”，口音梗。
    • “甚至”：用来递进吹嘘自己的操作。
    • “拿下”：表示胜利或击杀。