标签：#open

GitHub热门项目 | RL training environments for Microduck (mjlab) | Stars: 654 | 147 stars today | 语言: Python

GitHub热门项目 | Checkstyle is a development tool to help programmers write Java code that adheres to a coding standard. By default it supports the Google Java Style Guide and Sun Code Conventions, but is highly configurable. It can be invoked with an ANT task and a command line program. | Stars: 9,115 | 78 stars today | 语言: Java

GitHub热门项目 | A collection of MCP servers. | Stars: 93,118 | 65 stars today | 语言:

GitHub热门项目 | Command-line tool that allows searching and downloading app packages (known as ipa files) for iOS, iPadOS, tvOS, and visionOS from the App Store. | Stars: 10,042 | 56 stars today | 语言: Go

Help wanted: validate a configurable SharePoint list SPFx sample I have opened a new SharePoint Framework sample for a read-only, configurable list and records browser: Pull request: https://github.com/pnp/sp-dev-fx-webparts/pull/6476 The sample targets common SMB/SME data-view scenarios without reimplementing SharePoint’s editing experience. It uses React 17, Fluent UI v9, PnPjs v4, and SPFx 1.23.2. What the sample does Configures a SharePoint list title and visible internal fields. Uses explicit PnPjs $select / $expand queries and bounded pages. Supports text, number, currency, date, Boolean, choice, hyperlink, and person fields. Provides sorting, bounded paging, optional search, responsive table/card views, safe links, and native item-form links. Includes loading, empty, retry, permission, throttling, generic error, keyboard, and accessible status states. Keeps the MVP read-only: no create, edit, delete, attachments, bulk actions, or custom query language. Help needed Could someone with access to a SharePoint Online tenant please try the sample and report back on: Configuring it against a small ordinary list. Field discovery and supported field rendering. Sorting, search, paging, empty results, and error/retry behavior. Permission handling and narrow-viewport rendering. Keyboard operation and safe item links. One or two representative screenshots for the README. Dummy data is fine. Please remove or blur tenant names, site URLs, user names, record details, and all other sensitive information before sharing screenshots. The code builds and tests locally, but I do not currently have a tenant available for end-to-end validation. Tenant feedback and screenshots would materially help complete the pull request. Thank you to anyone who can spare the time to test it. sharepoint #spfx #opensource #react

Live API specs for coding agents An agent writing frontend code has to know the backend's API. It has three options. It can read the backend source and work out from scratch what the service already publishes. It can ask you, which promotes you to API documentation. Or it can swallow the entire OpenAPI document in order to use one route out of it. Then it does the same thing again tomorrow, against a stale swagger.json you exported last week. docs-mcpserver takes the spec straight from the running service, caches it, and serves it one operation at a time. The config { "cacheDir" : "./cache" , "libraries" : [ { "name" : "orders-api" , "description" : "Order handling service" , "sources" : [ { "type" : "url" , "origin" : "https://localhost:5001/openapi/v1.json" , "kind" : "schema" , "name" : "orders" } ] } ] } npm install -g docs-mcpserver claude mcp add docs -- docs-mcpserver --config /path/to/dev-docs.json That is the whole setup. One operation, not the whole spec The agent lists the definitions in orders , picks the one it needs, and fetches that. For an OpenAPI document the path operations are exposed as definitions named GET /orders/{id} , so it can also search by keyword. A few hundred tokens for the operation it is writing against, instead of the entire document. That keeps working as the service grows, which a pasted spec does not. The backend does not have to be running Every call is answered from the cached spec, never from the network. The fetch happens on startup and then in the background while you work, so an endpoint you added 20 seconds ago is already visible. Start the backend once, shut it down, and keep building the frontend. The agent still has real routes and real payload shapes. If the service is down, or answers with something that is not a spec, the last known-good copy keeps being served. Code and issues: github.com/jgauffin/dev-docs-mcp . On npm as docs-mcpserver .

Every value in my little embedded key-value store gets encrypted, then its ciphertext gets encoded as a string of A/C/G/T characters before it ever touches the filesystem. Open the file in a text editor and you'll see actual DNA-looking text - not because it's a gimmick, but because that's genuinely the storage format. This is mdc-lite , a ~348KB embeddable encrypted key-value store I built in Rust for places a server can't reach - a watch face, a phone app, a background service. It's part of a larger repo, ModelDB , that also includes MDC, a Python conversational data engine (query AI models, databases, images, and documents in plain English, no SQL) with its own DNA-inspired archival storage tier. The actual storage format Every put() call does this, in order: Pack [key_len][key_bytes][value_bytes] into one plaintext buffer. Encrypt the whole thing with XChaCha20-Poly1305 (a 256-bit key you supply - the crate never generates or stores key material itself; real key custody belongs to the platform's secure hardware, iOS Secure Enclave or Android Keystore). DNA-encode the resulting [nonce][ciphertext][tag] blob: 2 bits per base, 00→A 01→C 10→G 11→T . Every byte maps to exactly 4 bases, so there's no padding ambiguity on decode. Write the ACGT text to disk, atomically (temp file + rename). Filenames are keyed BLAKE3 hashes of the logical key, not the key name itself, so a directory listing alone leaks nothing - no key names, no values, no way to tell how many distinct keys exist versus how many files are on disk. rust pub fn put(&self, key: &str, value: &[u8]) -> Result<(), LiteStoreError> { let mut plaintext = Vec::new(); plaintext.extend_from_slice(&(key.len() as u16).to_le_bytes()); plaintext.extend_from_slice(key.as_bytes()); plaintext.extend_from_slice(value); let nonce = XChaCha20Poly1305::generate_nonce(&mut OsRng); let ciphertext = self.cipher().encrypt(&nonce, plaintext.as_ref())?; let mut record = nonce.to_vec(); record.extend_from_slice(&ciphertext); let ac

Wrap the payment. It runs once across retries, crashes, resumes, and replays. exactly-once is a Python library that makes a side effect run a single time. Wrap the function that pays an invoice or sends an email, or submits a transaction and it executes once per key, then replays its stored result on every later call. Here is the whole integration: from exactly_once import once , Store , current_key store = Store . sqlite ( " effects.db " ) @once ( store , key = lambda inv , ** _ : f " pay: { inv . id } " ) def pay_invoice ( inv ): return payments . transfer ( inv . vendor , inv . amount , idempotency_key = current_key ()) Call pay_invoice(invoice) and it pays the vendor. Call it again from a retry, a resumed run, a replay, or a second worker and it returns the recorded result. The vendor is paid once. The crash it's built for An agent pays an invoice. The transfer reaches the provider and succeeds. The process dies in the moment between the provider's 200 OK and the line that records the result. The agent restarts and reaches the same step again. exactly-once writes a record the instant the agent enters the call. pay_invoice claims the key pay:{invoice.id} , and the store marks it IN_FLIGHT . When the result returns, the store marks it COMMITTED and saves that result. After the crash the record reads IN_FLIGHT with an empty result the library knows a payment started and holds no proof it finished. So it quarantines the key. The agent leaves that payment for a decision and moves on. You give @once a prober that asks the payments API whether a transfer with that idempotency key exists: the library commits the key when the provider confirms the payment, and releases it when the provider confirms none. Until an answer arrives, the held payment stays in the ledger where you can see it: store . list ( state = " in_flight " ) # every payment awaiting a verdict How the guarantee holds Three states, one atomic operation: FRESH ──claim──▶ IN_FLIGHT ──commit──▶ COMMITTED clai

Been looking for a simple, offline ready web application to save things I want to read after Pocket shut down. Couldnt find anything that I liked so created one - hopefully others might like. monkeydust / rightread Read-later: capture links from anywhere, read them clean and offline rightread Capture links from anywhere. Read them clean, later, offline. Paste a link. It gets extracted and it's ready to read, clean and offline. Save a link from your phone's share sheet or your browser toolbar. rightread strips the page down to the article, with no ads, no cookie banners and no newsletter popups, and keeps it readable offline in typography built for long reading. Why this exists On 22 May 2025, Mozilla announced it was winding Pocket down . I'd used it for years for one thing: saving something on my phone and reading it properly later, usually when I was on the tube. The alternatives were mostly 'meh' so I built the small thing I missed. One queue, clean text, works on a plane, running on a server I control with the whole library in a single SQLite file I can copy. The reading list lives on your… View on GitHub

I’m looking for a little community help validating a new SharePoint Framework sample: React Flex Forms . What does it do? The sample contains two SPFx web parts: Form Designer — creates and manages one-page form definitions using supported SharePoint field types. Form Renderer — loads a published form, validates responses, and saves submissions to a SharePoint list. The sample includes automated tests and the local lint, build, and packaging checks are passing. The remaining gap is real-tenant validation and the static screenshots required for the PnP sample README. Could you help? If you have access to a SharePoint Online tenant and a few minutes to spare, please try the sample and capture: The Form Designer working in the SharePoint-hosted workbench. The Form Renderer displaying and submitting a published form. Dummy data is completely fine. Please remove or blur tenant, site, list, user, and other sensitive details before sharing. Feedback about provisioning, permissions, validation, submission, keyboard use, responsive behavior, dark theme, or high-contrast mode would also be very valuable. You can attach the scrubbed screenshots and observations directly to PR #6473 . The setup instructions are included in the sample README. This is a small request, but it would significantly speed up the final validation and help move the contribution toward completion. Thank you to anyone who can lend a tenant or share feedback. sharepoint #spfx #opensource #webdev

I just released Vincent 0.7.0 , and this release marks an important milestone for the project: Vincent now builds Vincent. All development on the project now goes through Vincent workflows — from creating an approved GitHub issue through planning, implementation, verification, human gates, merge, and release preparation. The journey from 0.4.0 to 0.7.0 added quite a bit. Workflows became real interfaces Workflows can declare their expected inputs, including: labels types required fields RE2 validation Vincent also gained a workflow-authoring skill designed around a principle I care about quite a lot: don't use an AI agent when deterministic automation can do the job better. Commands and native control flow come first. Agents are used where reasoning is actually required. Recovery became part of the workflow Real automation fails. So Vincent now has mechanisms for continuing rather than throwing work away: follow-ups on completed tasks recorded repair agents for blocked tasks retry backoff safer daemon backup/restore improved diagnostics through vincent doctor The control plane became scriptable 0.7.0 significantly expands the CLI. Tasks can now be started idempotently, created from GitHub issues, populated through JSON/stdin, queried through vincent status , limited with max_cost_usd , and integrated with notifications. Logs, transcripts, approvals, retries, repairs and task answers can all be handled without entering the TUI. The TUI hasn't been neglected either — tasks now open into a dedicated workspace containing steps, attempts, metadata, output and file-grouped diffs. Vincent builds Vincent This is the part I'm most excited about. My own development workflow now uses Vincent itself: GitHub issue ↓ planning ↓ implementation ↓ documentation ↓ cross-platform verification ↓ human gates ↓ merge ↓ release audit Claude Code, Codex or Cursor can provide the inference. Vincent owns the durable workflow, state and verification around them. That's the architecture I've b

An extension can work perfectly in development and still fail after packaging. The risky change is often not in the feature code itself. It can be a permission that moved, a host pattern that expanded, a content script that now runs somewhere new, or a browser surface that was never included in the release checklist. Here is the small preflight review I now use before testing an MV3 release. 1. Compare the packaged manifests Compare the last version you actually shipped with the new packaged version, not only the source manifest. Check separately: required permissions; optional permissions; required host access; optional host access. A permission moving from optional to required deserves attention even if the set of permission names looks familiar. 2. List every browser surface Turn the manifest into a list of things a person can interact with or that Chrome can start: action popup; options page; side panel; background service worker; content scripts; commands; externally connectable pages; declarative network rules; web-accessible resources. If a surface changed, add at least one release check for it. This sounds obvious, but it is easy to review the main popup while forgetting an options page or a host-specific content script. 3. Check where code can now run For every content script, compare: match patterns; excluded matches; frames; execution world; run timing. The JavaScript file can be unchanged while one of these settings changes the extension's behavior on real sites. 4. Test the packaged build Run the checklist against the same build directory that will be uploaded. A development build can hide packaging, path, minification, or generated-manifest differences. At minimum, reload the packaged extension and exercise one path through each changed surface. 5. Record why each check exists Instead of keeping a generic list such as “test the popup,” connect each check to a release change: host access expanded → test the new host and confirm the old hosts still

An early version of Say It Ahead had a basic problem. A user could listen carefully, ask good questions, and offer a reasonable plan, but the AI character might still sound just as upset as it did at the start. That made the practice feel arbitrary. The user could not tell whether anything they said had changed the conversation. The character had a strong opening mood, but no clear reason to move away from it. The fix was not a list of magic calming phrases. It was a simple model of how a difficult conversation can move forward. This note explains that model, how the live progress display works, and where the system can still get it wrong. The first character knew how to be upset The first parent scenario was easy to start. The prompt described an angry parent, gave the parent a complaint, and told the voice to push back. The result sounded convincing for the first few turns. The problem appeared when the user handled the conversation well. The model had been told why the parent was upset, but not what would make the parent become more open. It often treated anger as the character's permanent personality. A good question might produce an answer, but the next reply could jump back to the original complaint as if no trust had been built. Adding more instructions such as 'calm down when appropriate' did not solve the problem. Appropriate is too vague. The model needed to know what evidence to watch for and how its behavior should change after seeing it. A useful character needs a reason to resist Each ready-made scenario now gives the character more than a mood. It describes what happened, what the character believes, what facts they know, why they do not trust an easy answer, and what a credible resolution would look like. For example, a parent may reject a general promise because two earlier meetings led nowhere. A manager may care less about one missed deadline than about whether the same communication problem will happen again. An interviewer may accept transferabl

Most contributor onboarding starts by collecting identity. Create an account. Join the community. Request repository access. Pick an issue. Only then discover whether the work is relevant, bounded or even ready to be attempted. That sequence is especially awkward in AI-assisted development. An Agent can produce a plausible patch quickly, but speed does not answer the questions that maintainers actually need resolved: Was this problem authorized? What files, systems or external actions were inside the boundary? What evidence would prove completion? Which risks required human review? Who is accountable for the result? A useful contributor surface should reveal those constraints before it asks for commitment. Start with problems, not identity collection WebAZ currently exposes a narrow public contribution entry through the full Remote MCP surface. Without an API key, a person or Agent can: list public build tasks; inspect a task's execution boundary and acceptance criteria; submit an evidence-backed suggestion to the maintainer review inbox. The conceptual flow looks like this: discover public task -> inspect boundary and verification -> decide whether the problem is understood -> submit a structured suggestion -> maintainer review The default buyer-facing MCP surface does not advertise the contribution tool. The full surface exposes webaz_contribute , where list_open , detail and suggest are public starting actions. A compact interaction can begin with: { "action" : "list_open" , "area" : "docs" , "agent_capabilities" : "markdown,read-source" } The result is not merely a title list. A task can describe risk level, required capabilities, autonomy, estimated effort, context size, dependencies, blocking conditions and whether human review is required. Before doing anything, a prospective participant can ask for the detail view: { "action" : "detail" , "task_id" : "<public-task-id>" } That is where a real coordination system should state what may change, what must not cha

Sleep is the ultimate black box. We spend a third of our lives doing it, yet we have almost zero data on what happens during those eight hours—unless you're willing to pay for an expensive sleep clinic. Today, we’re going to change that by building a high-fidelity Sleep Apnea and Snore Monitoring system using Whisper-v3 , Librosa , and PyAudio . In this tutorial, we will tackle Whisper-v3 audio processing , real-time sleep apnea detection , and audio fingerprinting to filter out the sound of your fan or your neighbor's car. If you've been looking for a "Learning in Public" project that combines deep health-tech with high-performance Python, you’re in the right place. 🚀 The Problem: Noise vs. Signal Detecting sleep apnea isn't just about recording sound; it's about identifying the absence of sound followed by a gasp (the "apnea event"). Standard noise-canceling algorithms often wipe out the very frequencies we need. We need a system that can distinguish between ambient white noise, rhythmic snoring, and dangerous respiratory pauses. System Architecture 🛠️ Here is how the data flows from your bedside microphone to a processed health report: graph TD A[PyAudio Stream] -->|Chunked Audio| B(Librosa Pre-processing) B -->|Noise Floor Calculation| C{Is it Snore/Breath?} C -->|Yes| D[Audio Fingerprinting / MFCC] C -->|No| A D --> E[Whisper-v3 Inference] E -->|Timestamped Events| F[Apnea Detection Logic] F --> G[Health Report / Alert] G --> H[Dockerized Storage/API] Prerequisites Before we dive in, ensure you have the following tech stack ready: Whisper-v3 : For high-accuracy audio event tagging. Librosa : For feature extraction and spectral analysis. PyAudio : For low-latency streaming. Docker : To package our environment (handling those pesky C++ dependencies for audio). Step 1: Real-time Audio Capture & Preprocessing 🎙️ We start by capturing audio in chunks. We don't want to process 8 hours of silence, so we use Librosa to calculate the Root Mean Square (RMS) energy. impor

GitHub热门项目 | Stateful agents that are like people, with memory, identity, and the ability to learn and adapt | Stars: 3,149 | 67 stars this week | 语言: TypeScript

GitHub热门项目 | Presentation Slides for Developers | Stars: 48,336 | 168 stars this week | 语言: TypeScript

GitHub热门项目 | The customization marketplace for Windows programs: https://windhawk.net/ | Stars: 8,822 | 7 stars today | 语言: Rust

GitHub热门项目 | ANOLISA (Agentic Nexus Operating Layer & Interface System Architecture) | Agentic OS with runtime, security, observability, and Tokenless response compression for lower token usage and cost. | Stars: 610 | 2 stars today | 语言: Rust

GitHub热门项目 | | Stars: 2,212 | 7 stars today | 语言: TypeScript