DEV Community: Sabahattin Kalkan

How I Automated My Obsidian Vault with Claude — It Now Works the Night Shift

Sabahattin Kalkan — Thu, 28 May 2026 20:21:28 +0000

I was drowning in my own notes

For about two years, I lived inside Obsidian. Daily notes, fleeting thoughts, meeting takeaways, half-formed ideas at 2am, voice memos I'd transcribe by hand. My vault had over 3,000 notes.

And I remembered almost none of it.

Every morning I'd open my laptop and stare at yesterday's daily note, trying to reconstruct where I was. The vault was full — full of captures that were never synthesized, tasks that were never carried forward, ideas that died in a folder called _inbox. I was doing the work of a knowledge worker but getting none of the compounding returns. Notes went in. Nothing came out.

What made it worse: I knew I was supposed to do the synthesis. Review your notes. Write a morning brief. Connect the dots. But after a full day of work, the last thing I wanted to do was sit down and play editor. So I didn't. And the vault stayed a graveyard.

The real problem isn't note-taking

Here's what I eventually figured out: I wasn't failing at note-taking. I was failing at synthesis — and I was expecting myself to do it at the worst possible time.

Synthesis requires cognitive distance. You need to look at what you captured with fresh eyes. The problem is that "fresh eyes" happen in the morning, and the synthesis work needs to happen after the day is over. That's a structural mismatch, and no productivity system fixes it because it's not a productivity problem.

It's a timing problem. And timing problems are exactly what automation solves.

The thought that changed everything: Claude doesn't get tired at 11pm. It doesn't need cognitive distance — it can read the whole day in one pass and pull out what matters. So I built vault-os to hand that job off.

What vault-os actually does

vault-os has two main jobs: capture anything, anywhere, and synthesize everything while you sleep.

Capture via Telegram bot. I wanted to send notes from my phone without opening Obsidian. The bot uses tag-based routing — anything you send gets sorted into the right section of your daily note automatically. #idea goes into Content Ideas. #signal goes into Research Signals. #link or a bare URL goes into Links to Process. Plain text goes to Captures. Voice messages get transcribed locally and then routed the same way.

Nightly agent at 23:00. A PowerShell script runs 12 phases: it reads your day, runs Claude over your captures, synthesizes patterns, writes an evening review, prepares your morning brief, and carries forward any unfinished tasks. By the time you wake up, your daily note for the new day already has context loaded.

Morning digest API. A REST endpoint serves the morning brief so you can display it anywhere — a home screen widget, a terminal script, a Raycast extension, whatever fits your setup.

Architecture: the two components

server.js — Node.js + Express + Telegraf

The server handles Telegram and the REST API. The core of it is a routing function that decides where each message goes in your daily note:

function routeMessage(text) {
  const t = text.trim();
  if (/^#(idea|fikir)\b/i.test(t))    return '## Content Ideas';
  if (/^#(signal|research|sinyal)\b/i.test(t)) return '## Research Signals';
  if (/^#link\b/i.test(t) || /^https?:\/\//i.test(t)) return '## Links to Process';
  return '## Captures';
}

Simple regex matching. I added Turkish/Azerbaijani aliases (fikir, sinyal) because I switch languages mid-thought constantly. You can extend this to whatever tags your brain uses.

Multi-line messages are handled per-line — if you paste a block of text with five ideas, each line gets routed independently. This matters more than it sounds; it means you can dump a brain dump into Telegram and it lands sorted.

The voice pipeline runs: OGG (Telegram's format) → ffmpeg converts to 16kHz mono WAV → whisper-cli transcribes → text goes through the same routing function. The whole thing is synchronous on my machine and takes about 4 seconds for a 30-second voice memo.

REST endpoints are minimal: GET /morning-brief returns the prepared brief as JSON, POST /capture lets other tools push content directly.

nightly-agent.ps1 — PowerShell, 12 phases

I wrote this in PowerShell because it runs as a Windows Task Scheduler job and I didn't want a dependency on a running Node process. The phases are:

FAZ 1-2: Environment check, date setup, locate today's note
FAZ 3 (Claude Think): Read all captured content, run a synthesis prompt, extract key themes, identify what was actually important vs. noise
FAZ 4-5: Task extraction, carry-forward logic for incomplete items
FAZ 6 (Morning Brief): Write tomorrow's opening section — not a summary of yesterday, but a launch pad for tomorrow. What's the one thing that matters. What task deserves first attention. What idea is worth developing.
FAZ 7-10: Link processing, research signal digestion, content angle extraction
FAZ 11 (Evening Review): Appended to today's note — a short human-readable synthesis of the day that you can read before sleep
FAZ 12: Cleanup, log rotation, error reporting

The Claude API calls follow a consistent pattern: write the prompt to a temp file, call claude --print with --max-turns 1, capture stdout, clean up.

$prompt | Out-File -FilePath $tmpFile -Encoding UTF8
$result = & claude --print --max-turns 1 $tmpFile 2>$null
Remove-Item $tmpFile -ErrorAction SilentlyContinue

I use --max-turns 1 everywhere in the nightly agent because I don't want back-and-forth — I want one focused output per phase. This also keeps costs predictable. A full nightly run on a moderately active day costs me about $0.04.

What a daily note actually looks like

The daily note template has fixed sections that the automation respects:

# 2026-05-29

## Morning Brief
<!-- written by nightly agent from previous night -->

## Captures
<!-- plain Telegram messages land here -->

## Content Ideas
<!-- #idea tags land here -->

## Research Signals
<!-- #signal tags land here -->

## Links to Process
<!-- #link tags and bare URLs land here -->

## Evening Review
<!-- written by nightly agent at 23:00 -->

During the day, you're just sending messages. The structure fills itself in. The Morning Brief is already there when you open Obsidian. The Evening Review appears after the agent runs. You never touch the note directly unless you want to.

This matters for adoption: if the automation requires you to maintain the structure, you'll break it within two weeks. The structure has to be robust enough to survive a messy day where you just dump text into Telegram without thinking.

Voice capture and why local matters

I almost used OpenAI Whisper API for transcription. It's easier to set up and the accuracy is excellent. I switched to whisper.cpp for one reason: the content of voice notes.

When you're thinking out loud into your phone, you're not performing. You're rough-drafting decisions, processing frustrations, working through half-formed ideas that you wouldn't put in a document. That content is genuinely private — not in a paranoid way, but in the way that a sketchbook is private. It's your unedited thinking.

Sending that audio to an API means it transits servers you don't control. Running whisper.cpp locally means the audio never leaves your machine. The model is a file on disk (ggml-small.bin, 466MB), the process runs in a subprocess, and nothing goes over the network.

Accuracy with small is good enough for most voice notes — I get the occasional mishearing on proper nouns and mixed-language sentences, but the meaning survives. If you mostly dictate in a single language, small is the right tradeoff. medium (1.5GB) is noticeably better for multilingual.

What I wake up to

Here's what the Morning Brief section looks like on a real morning:

## Morning Brief

Carry-forward: Finish the vault-os README (started yesterday, left at setup section).

Yesterday's thread: Three captures around API cost optimization clustered
with a research signal on context caching. Worth developing.

Content angle ready: "Local-first AI tools" — #idea from Tuesday still
unaddressed, now has supporting signals from two separate sources.

Today's open question: The routing logic handles single-line captures well
but breaks on multi-paragraph pastes. Worth fixing or acceptable?

The brief is not a summary. It's a launch pad. There's a difference: a summary tells you what happened, a launch pad tells you where to start.

Getting started

Prerequisites: Node.js 18+, PowerShell 7+, Claude CLI authenticated, ffmpeg on PATH, whisper.cpp compiled.

git clone https://github.com/sabahattink/vault-os
cd vault-os
./setup.sh
# Edit .env: VAULT_PATH, TELEGRAM_BOT_TOKEN, ANTHROPIC_API_KEY
node dashboard/server.js

For the nightly agent, register scripts/nightly-agent.ps1 as a Windows Task Scheduler job at 23:00:

pwsh -File scripts/install-scheduler.ps1

What's next

I'm building this in public. Three things on the roadmap I actually need:

Decision intelligence endpoint. Extract decisions from a date range — not summaries, but actual choices made and the reasoning captured around them.

Weekly synthesis agent. Look across seven days of evening reviews and find the thread — what was I actually working on this week vs. what I said I was working on.

Mobile shortcut integration. An iOS Shortcut that records audio and POSTs directly to the capture endpoint, bypassing Telegram entirely for voice-only workflows.

If you use Obsidian and your vault isn't working for you — not because you're bad at it, but because synthesis is genuinely hard to sustain — vault-os might be worth trying.

GitHub: github.com/sabahattink/vault-os

Star it if it looks useful. Issues and PRs welcome.

Tags: obsidian, productivity, ai, opensource

I built a permission-first CLAUDE.md + agent stack for Claude Code (free, MIT)

Sabahattin Kalkan — Thu, 14 May 2026 21:01:45 +0000

I've been using Claude Code daily for months. And I kept hitting the same wall:

The agent would just start doing things. No plan. No approval. Just... acting.

It deleted files I didn't want deleted. It refactored things I didn't ask it to refactor. It made "helpful" assumptions that broke my architecture.

So I built Full Stack HQ — a configuration kit that enforces a permission-first workflow. Here's what I learned.

The core problem with AI coding agents

Most people configure their AI agent once (or never) and just... let it go. The result is an agent that:

Makes assumptions about what you want
Takes irreversible actions without asking
Mixes planning and execution in the same step
Has no consistent code style or architectural awareness

The agent is powerful but unpredictable. That's the worst combination in software development.

The solution: permission-first workflow

Nothing happens without your explicit approval. The agent plans, shows you what it intends to do, and waits.

You:    "Add user authentication with JWT"

Agent:  Here's my plan:
        Phase 1: Create auth module + JWT strategy
        Phase 2: Add guards to protected routes  
        Phase 3: Implement refresh token rotation

        [APPROVAL NEEDED] Should I proceed with Phase 1?

You:    PLAN APPROVED

Agent:  [implements Phase 1 only, then stops and reports]

The only valid approval keywords:

PLAN APPROVED
IMPLEMENTATION APPROVED
PROCEED
DO IT

Anything else — the agent waits. No exceptions.

What's inside Full Stack HQ

Component	Count	Description
`CLAUDE.md`	1	Global rules for Claude Code
`GEMINI.md`	1	Global rules for Google Antigravity IDE
Agents	10	Specialist AI personas
Skills	28	Domain-specific knowledge modules
Workflows	10	Slash command procedures

10 Specialist Agents

Instead of one generic agent trying to do everything, you get domain experts:

Agent	What it handles
`frontend-specialist`	React, Next.js, Tailwind
`backend-specialist`	NestJS, Node.js, APIs
`database-specialist`	Prisma, PostgreSQL, migrations
`architect`	System design, trade-offs, ADRs
`code-reviewer`	Quality, patterns, best practices
`test-engineer`	Vitest, Jest, Playwright
`security-auditor`	Auth, OWASP, input validation
`performance-optimizer`	Bundle, queries, rendering
`devops-engineer`	Docker, CI/CD
`documentation-writer`	READMEs, technical writing

Calling them is simple:

Use the database-specialist to design a user schema with soft deletes.

28 Skills

Deep knowledge modules for the tools you actually use:

Frontend: nextjs-app-router, react-best-practices, ui-ux-pro-max, frontend-design
Backend: nestjs-patterns, prisma-workflow, software-architecture
Testing: test-driven-development, systematic-debugging, webapp-testing
Meta: brainstorming, prompt-engineering, skill-creator

10 Workflows (Slash Commands)

/plan       → phased breakdown with approval checkpoints
/brainstorm → explore architecture options
/debug      → systematic root-cause analysis
/create     → implement an approved plan
/enhance    → improve existing code quality
/test       → generate or fix tests
/orchestrate → coordinate multiple agents

Install in 30 seconds

Mac/Linux:

curl -fsSL https://raw.githubusercontent.com/sabahattink/antigravity-fullstack-hq/main/install.sh | bash

Windows (PowerShell):

irm https://raw.githubusercontent.com/sabahattink/antigravity-fullstack-hq/main/install.ps1 | iex

Options:

./install.sh --only-claude        # Claude Code only
./install.sh --only-antigravity   # Antigravity only
./install.sh --force              # Overwrite existing configs

The script detects which IDEs you have installed and configures them automatically.

What gets installed where

~/.claude/
├── CLAUDE.md          ← global rules (Claude Code)
├── agents/            ← 10 specialist agents
└── skills/            ← 28 skill modules

~/.gemini/
├── GEMINI.md          ← global rules (Antigravity)
└── antigravity/
    ├── agents/
    ├── skills/
    └── workflows/

The CLAUDE.md philosophy

The rules file enforces several things I found critical in practice:

1. Separation of planning and execution

The agent never does both in the same step. First it plans, you approve, then it executes. This alone eliminates 80% of unwanted surprises.

2. Role-based reasoning

Before acting, the agent asks: "Who is the right specialist for this?" A database schema question goes to the database specialist, not the frontend agent pretending to know Prisma.

3. Explicit code style

No semicolons. Single quotes. 2-space indentation. Arrow functions. Named exports. These aren't suggestions — they're enforced rules the agent follows on every file, every time.

4. Security checklist

Before every commit: no hardcoded secrets, all inputs validated, no unbounded queries, rate limiting on public endpoints. The agent checks these automatically.

Why it works

The mental model I was missing: AI agents should behave like senior engineers, not interns with root access.

Senior engineers don't start typing when you describe a problem. They think, propose a plan, get sign-off, then execute — one reversible step at a time.

Full Stack HQ enforces this discipline by default.

Repo

⭐ github.com/sabahattink/antigravity-fullstack-hq

MIT license. Open to PRs — especially new agents and skills.

What does your current CLAUDE.md look like? I'd love to see what rules others have found valuable.

Building MailTest: An Open Source Email Deliverability Debugger

Sabahattin Kalkan — Mon, 13 Apr 2026 03:53:52 +0000

Building MailTest: An Open Source Email Deliverability Debugger

The Problem

[Story about client's 50K emails going to spam]

Why Existing Tools Fall Short

Expensive ($100+/month)
No explanations
SaaS lock-in

What I Built

[Demo GIF/screenshots]

Technical Architecture

Backend

NestJS + Fastify (why not Express)
BullMQ for async jobs
RS256 JWT (why not HS256)

Frontend

Next.js 15 App Router
Radix UI primitives
Real-time updates with SSE

Infrastructure

Docker Compose
PostgreSQL 16
Redis 7
Paddle billing

Interesting Challenges

IMAP Polling: How to catch emails reliably
Scoring Algorithm: Weighted checks (SPF 15%, DKIM 20%, etc.)
PDF Generation: Server-side with Puppeteer

Code Snippets

[Show interesting parts]

What's Next

More integrations
Auto-fix features
API monetization

Try It

https://mailtest.scuton.com

Discussion

What features would you want in a deliverability tool?

I built a CLI that diagnoses your code before you ship

Sabahattin Kalkan — Sat, 28 Mar 2026 10:45:57 +0000

I built a CLI that diagnoses your code before you ship
Every NestJS project I've worked on had the same problems:

POST endpoints without auth guards
Hardcoded API keys in source code
.env not in .gitignore
Zero tests
No Swagger documentation

I was tired of catching these manually in code reviews. So I built codediag.
What it does
bashnpx codediag scan .
One command. It auto-detects your stack and runs 5 analyzers:
codediag — Diagnostic Report

Project: my-nestjs-app
Stack: nestjs + typescript + prisma
Score: B+ (87/100)

API Health ███████████████░░░░░ 78
Security ██████████████████░░ 92
Dependencies ██████████████████░░ 91
Testing ████████████████░░░░ 82
Structure █████████████████░░░ 88
The 5 Analyzers

API Health (NestJS) This is the differentiator. codediag uses ts-morph to do real AST analysis of your NestJS decorators — not regex pattern matching. It discovers every endpoint from @get(), @post(), @Put(), @Delete(), @Patch() decorators and checks:

Auth guards: Does this endpoint have @UseGuards()? Especially important for mutating endpoints.
DTO validation: Is the @body() parameter typed with a DTO class?
Swagger docs: Are @ApiOperation() and @ApiResponse() present?
Return types: Is there an explicit return type annotation?

Security The stuff that ends up on HackerNews for the wrong reasons:

Hardcoded secrets (API keys, Stripe keys, AWS keys, GitHub tokens)
.env in .gitignore
Helmet middleware for HTTP security headers
CORS wildcard (origin: '*') detection
Rate limiting package installed
Password hashing library present

Dependencies Your node_modules is a supply chain. codediag treats it like one:

npm audit vulnerabilities
Lock file existence
Deprecated packages
Engine specification
Essential scripts

Testing

Test file existence and count
Framework detection (Jest, Vitest, Mocha, Ava)
Test-to-source file ratio
E2E test directory
Coverage threshold configuration

Structure

README quality
Linter configuration (ESLint or Biome)
Formatter configuration (Prettier)
TypeScript strict mode
NestJS module organization
.env.example presence

Scoring
Each analyzer scores 0-100. The total is a weighted average:
AnalyzerWeightAPI Health25%Security30%Dependencies20%Testing15%Structure10%
Security gets the highest weight because shipping vulnerable code is the worst bug.
CI/CD
One line in your GitHub Actions:
yaml- run: npx codediag scan . --ci --threshold 80
Exits with code 1 if the score drops below your threshold.
What's next

Next.js analyzer
Express route analyzer
Web dashboard with trend tracking
AI-powered fix suggestions
VS Code extension

Try it
bashnpx codediag scan .
Zero config. MIT licensed. 33KB bundled.

GitHub: https://github.com/scuton-technology/codediag
npm: https://www.npmjs.com/package/codediag

I'd love to hear what checks you'd want added. Drop a comment or open an issue!

Stop switching to GitHub.com for standup — I built a CLI for that

Sabahattin Kalkan — Tue, 17 Mar 2026 09:30:29 +0000

Every morning it's the same routine.

Open GitHub. Filter by author. Scroll through commits. Switch repos. Try
to remember what you did yesterday. Piece together a standup from five
different tabs.

Or worse — you're juggling three different repos, two orgs, and a
contractor's fork, and the GitHub web UI has no idea you want to see all
of it at once.

I built gpulse to fix this.

What it does

gpulse is a CLI toolkit that brings the GitHub insights you actually need
into your terminal. Six focused commands, zero browser required.

npm install -g @sabahattinkalkan/gpulse
export GITHUB_TOKEN=ghp_your_token_here

`gpulse standup`

What did you actually do since yesterday?

gpulse standup           # last 24 hours, all repos
gpulse standup -d 3      # last 3 days
gpulse standup -u alice  # another user's activity

Output:
Standup for @sabahattinkalkan
Since Mar 15, 2026 12:00 AM
Commits
a1b2c3d feat: add user authentication (org/app)
d4e5f6a fix: resolve memory leak in worker (org/api)
Pull Requests

42 Add OAuth2 support (org/app)

Reviews

41 Refactor database layer (org/api)

──────────────────────────────────────────
Summary: 2 commits, 2 PRs, 1 review

This is what I actually read out at standup. Copy, paste, done.

`gpulse health`

Repo health score (A–F). Checks README, LICENSE, CI, stale issues.

gpulse health vercel/next.js
# Score: 90/100 (A)

`gpulse review`

PR dashboard — review requests, assigned PRs, your open PRs.

gpulse review
# Review Requested (2)
#   #87 Add rate limiting middleware (org/api)

`gpulse changelog`

Auto-generate changelog from git tags using Conventional Commits.

gpulse changelog -o CHANGELOG.md

`gpulse digest`

Weekly repo digest — commits, issues, merged PRs, contributors.

gpulse digest -d 7

Why terminal?

Context switching kills flow. gpulse keeps you in the terminal where
you're already working. Also useful in SSH sessions and CI scripts.

Setup

npm install -g @sabahattinkalkan/gpulse
export GITHUB_TOKEN=ghp_...

No config files. No YAML. Just the token and go.

Try it

GitHub: https://github.com/scuton-technology/ghx
npm: npm install -g @sabahattinkalkan/gpulse

MIT licensed. What would you add to a GitHub CLI toolkit? Drop it in the comments.

I built a self-hosted LLM proxy that supports 12 providers (Claude, GPT-4o, Gemini, Ollama...)

Sabahattin Kalkan — Mon, 16 Mar 2026 10:18:50 +0000

Every time a new LLM comes out, someone on your team adds a new SDK,
a new API key in .env, and a new set of error handling logic. Repeat
for OpenAI, Anthropic, Gemini, Groq, Mistral, Ollama...

I got tired of this. So I built llm-gateway.

What it does

llm-gateway is a single Go binary that sits between your app and every
LLM provider. Your code sends one request format (OpenAI-compatible),
and the gateway routes it to the right provider based on the model name.

# One endpoint for all providers
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-sonnet-4-20250514", "messages": [{"role": "user", "content": "hello"}]}'

# Switch provider by changing the model name — zero code changes
curl http://localhost:8080/v1/chat/completions \
  -d '{"model": "gpt-4o", "messages": [...]}'

# Local model — no API key needed
curl http://localhost:8080/v1/chat/completions \
  -d '{"model": "llama3.2", "messages": [...]}'

Model routing is automatic:

claude-* → Anthropic
gpt-*, o1, o3 → OpenAI
gemini-* → Google
llama* → Ollama or Groq
mistral-* → Mistral
grok-* → xAI
sonar-* → Perplexity
command-* → Cohere

Install in 30 seconds

docker run -p 8080:8080 -v gateway-data:/data scutontech/llm-gateway

Open http://localhost:8080/admin → set your admin password → add API
keys from the Settings page. No .env files, no YAML editing.

Admin dashboard

The gateway ships with a full admin dashboard:

Real-time stats — requests, tokens, latency, error rate, estimated cost
Provider breakdown — which providers you're actually using
Cost analytics — daily/monthly spend by model, with CSV export
Request log — last 50 requests with model, provider, tokens, cost, latency
Dark mode — because of course

Streaming support

SSE streaming works for all providers. The gateway normalizes
Anthropic's stream format to OpenAI's SSE format transparently.

curl http://localhost:8080/v1/chat/completions \
  -d '{"model": "claude-sonnet-4-20250514", "stream": true, "messages": [...]}'

Supported providers

Provider	Models
Anthropic	claude-opus-4, claude-sonnet-4, claude-haiku-4
OpenAI	gpt-4o, gpt-4o-mini, o1, o3-mini
Google	gemini-2.0-flash, gemini-1.5-pro
Groq	llama-3.3-70b, mixtral-8x7b
Mistral	mistral-large, codestral
Cohere	command-r-plus, command-r
xAI	grok-2, grok-2-mini
Perplexity	sonar-large, sonar-small
Together AI	50+ open source models
Ollama	any local model
LM Studio	any local model
vLLM	any hosted model

Why Go?

~15MB binary. Under 100ms cold start. ~20MB memory at idle.
Drop it on a $5 VPS and forget about it.

Try it

GitHub: https://github.com/scuton-technology/llm-gateway
Docker: docker pull scutontech/llm-gateway

MIT licensed. PRs welcome.

Stop writing bad commit messages — I built a free AI CLI for that

Sabahattin Kalkan — Mon, 16 Mar 2026 07:09:21 +0000

We've all done it.

git commit -m "fix"
git commit -m "wip"
git commit -m "asdfgh"
git commit -m "changes"

You're deep in flow, you just want to save progress, and writing a meaningful commit message feels like a speed bump. So you write something meaningless and move on.

The problem? Three months later, you (or your teammate) is trying to understand why a change was made. The git log is full of "fix" and "update" and tells you nothing.

The solution: let AI read the diff

I built ai-commit — a CLI that reads your staged git diff and generates 3 Conventional Commit suggestions for you to pick from.

npm install -g @scuton/ai-commit

Then just:

git add .
aic

You get something like:
? Pick a commit message:
❯ feat(auth): add JWT refresh token rotation
feat(auth): implement rotating refresh token with replay protection
chore(auth): update token lifecycle and Redis TTL strategy
✎ Write my own
✗ Cancel

Pick one, hit enter, done. The whole thing takes 3 seconds.

Free option: Ollama (no API key needed)

This is the part I'm most excited about. You can run it completely free using Ollama — a local LLM runner.

# Install Ollama and pull a model
ollama pull llama3.2

# Use ai-commit with Ollama
aic -p ollama

No API key. No cost per commit. Everything stays on your machine.

Supports Claude and GPT-4o too

If you prefer cloud models:

# Claude (best quality)
export ANTHROPIC_API_KEY=sk-ant-...
aic

# GPT-4o
export OPENAI_API_KEY=sk-...
aic -p openai

Cost is around $0.001 per commit with cloud models — basically free.

Install as a git hook

If you want it to run automatically on every git commit:

aic hook

Remove it anytime:

aic hook --remove

Other useful flags

aic --dry-run        # Preview suggestions without committing
aic --count 5        # Get 5 suggestions instead of 3
aic --lang tr        # Generate in Turkish (or any language)
aic --emoji          # Add emoji to commit type

Programmatic API

You can also use it in your own tools:

import { generateCommitMessages } from '@scuton/ai-commit';

const suggestions = await generateCommitMessages({
  provider: 'anthropic',
  count: 3,
});
console.log(suggestions[0].message);
// "feat(auth): add JWT refresh token rotation"

Try it

GitHub: https://github.com/scuton-technology/ai-commit
npm: npm install -g @scuton/ai-commit

MIT licensed, open source. PRs welcome — especially for new provider integrations.

Happy committing.