DEV Community: Gokul Krishna. S

I Built RepoDrift: A Local-First CLI That Audits Your Repository Before Deployment

Gokul Krishna. S — Tue, 01 Sep 2026 09:21:21 +0000

Most developers focus on whether their application works.

But before deploying a project, there are other questions worth asking:

Are there exposed secrets?
Are dependencies outdated?
Is a lockfile missing?
How large has the codebase become?
Are there large or suspicious files?
Is the Git working tree clean?
Are there obvious technical debt signals?
Is the repository actually healthy?

I wanted a simple way to answer those questions directly from the terminal.

So I built RepoDrift.

RepoDrift is a local-first repository intelligence CLI for developers.

It analyzes a repository and produces a health report without requiring source code to be uploaded to a cloud service.

What is RepoDrift?

RepoDrift is designed to run directly inside a project:

npx @repodrift/cli scan

It currently analyzes:

Files and directories
Dependencies
Lockfiles
Security patterns
Git status
Code metrics
Repository health
Actionable findings

The current release is Phase 1 — local repository analysis.

AI-powered explanations and a remote API are planned for a future phase.

Why I built it

A repository can work perfectly and still have problems.

For example, a project might contain:

.env
API_KEY=...

Or have:

package.json

without a lockfile.

Or contain a huge source file that has gradually become difficult to maintain.

Or have several uncommitted changes before a production deployment.

These aren't always visible when you're simply running:

npm run dev

I wanted a single command that could give developers a quick overview.

That's the idea behind RepoDrift.

Quick Start

You can install the CLI globally:

npm install -g @repodrift/cli

Then run it inside a repository:

repodrift scan

You can also scan another project:

repodrift scan ./my-project

For development, the same functionality can be run without globally installing the package:

npm run dev -- scan

What does RepoDrift actually check?

1. File Analysis

RepoDrift scans the repository structure and identifies:

Source files
Test files
Configuration files
Documentation
Binary files
Large files
File extensions
Directories

It also ignores directories that normally don't need to be analyzed:

node_modules
.git
dist
build
.next
coverage
.cache

Custom ignore patterns can also be configured with:

.repodriftignore

2. Dependency Analysis

RepoDrift looks at the project's dependency configuration.

Currently it supports common Node.js dependency files such as:

package.json
package-lock.json
yarn.lock
pnpm-lock.yaml

It can identify things such as:

Dependencies
Dev dependencies
Missing lockfiles
Deprecated package metadata
npm security advisories when network auditing is enabled

For example:

repodrift scan

can give you an early warning that the dependency configuration needs attention.

3. Security Scanning

One of the most important parts of RepoDrift is local security analysis.

It looks for patterns that may indicate:

API keys
Tokens
AWS credentials
GitHub credentials
Private keys
Hardcoded passwords
Database URLs
Environment files

The goal isn't to replace a dedicated security platform.

Instead, RepoDrift provides a fast first layer of repository inspection before development or deployment.

And privacy is a major part of the design.

Local-First by Design

RepoDrift is designed around a simple principle:

Your source code should stay on your machine unless you explicitly choose otherwise.

The current Phase 1 analyzer performs its repository analysis locally.

You can also use:

repodrift scan --local-only

This guarantees that RepoDrift does not make a network request for the scan.

This is especially important when analyzing:

Private repositories
Client projects
Internal applications
Proprietary source code

4. Git Analysis

RepoDrift can inspect the local Git repository.

It can provide information such as:

Current branch
Working tree status
Commit count
Contributors
Recent commits
Uncommitted files

Git analysis is optional.

If Git isn't installed or the target isn't a Git repository, RepoDrift gracefully continues with the other analyzers.

5. Code Metrics

RepoDrift also looks at basic repository metrics.

For example:

Lines of code
Largest source files
Source file count
Repository size signals

These metrics aren't intended to judge whether your architecture is "good" or "bad."

They're signals.

The idea is to give developers enough information to decide where they should investigate further.

Repository Health Score

One of the things I wanted to avoid was an AI-generated score.

So the health score is currently deterministic.

RepoDrift combines different repository signals into an overall score.

Conceptually:

Security
   +
Dependencies
   +
Code Quality
   +
Complexity
   +
Git Health
   ↓
Repository Health Score

For example:

Repository Health

78 / 100
Grade: B

The score is calculated by the analysis engine rather than by an AI model.

This means the same repository state should produce a predictable result.

JSON Output for CI/CD

RepoDrift isn't only designed for humans.

You can use:

repodrift scan --json

to generate machine-readable output.

This makes it possible to integrate RepoDrift into CI/CD pipelines.

For example:

repodrift scan --json --fail-on high

The idea is simple:

Git Push
   ↓
CI Pipeline
   ↓
RepoDrift
   ↓
Repository Analysis
   ↓
Critical/High Findings?
   ↓
Yes → Fail
No  → Continue

This allows repository health checks to become part of the development workflow.

Architecture

The most important architectural decision was keeping the core analyzer independent from AI.

The current architecture looks like:

Developer
    │
    │ repodrift scan
    ▼
RepoDrift CLI
    │
    ▼
Core Analysis Engine
    │
    ├── File Scanner
    ├── Dependency Analyzer
    ├── Security Scanner
    ├── Git Analyzer
    └── Code Metrics
    │
    ▼
Health Score
    │
    ▼
Terminal / JSON Report

The Core Engine is responsible for finding facts.

AI will be responsible for understanding and explaining those facts later.

Why AI isn't included yet

I deliberately didn't add AI to Phase 1.

It would have been easy to send repository files to an LLM and call the product "AI-powered repository analysis."

But that's not the architecture I want.

Instead, the future architecture will look like:

Local Repository
       ↓
Core Analysis
       ↓
Redacted Findings
       ↓
RepoDrift API
       ↓
AI Provider
       ↓
Summary
Recommendations
Explanations
       ↓
CLI

The AI won't need the entire repository.

It will receive structured and redacted findings.

For example:

{
  "severity": "critical",
  "category": "security",
  "title": "Potential exposed API credential",
  "file": "src/config.ts"
}

Instead of sending:

API_KEY=sk_live_123456789

the sensitive value would be removed or redacted.

What will AI actually do?

The Core Engine can detect:

Potential exposed credential.

But AI can explain:

Why is this dangerous?

What could happen?

What should the developer do next?

For example:

🚨 Critical Security Issue

A potential credential was detected in the repository.

Risk:
The credential may become accessible to anyone
with access to the repository.

Recommended actions:

→ Rotate the credential
→ Remove it from the repository
→ Review Git history
→ Move the secret to a secure environment variable

So the philosophy is:

Core = Detection

AI = Understanding + Explanation + Recommendations

Future: repodrift explain

One of the planned commands is:

repodrift explain

Instead of simply showing:

HIGH
Vulnerable dependency

RepoDrift could provide:

Why does this matter?

This dependency has a known security issue
that could affect production applications.

Recommended action:

Update the dependency to a patched version.

Future: repodrift fix

Eventually, I want RepoDrift to go beyond analysis.

A future command could be:

repodrift fix

The workflow could become:

Find Issue
    ↓
AI Analysis
    ↓
Generate Patch
    ↓
Show Diff
    ↓
Developer Approval
    ↓
Apply Change
    ↓
Run Tests

The important part is that the developer remains in control.

RepoDrift shouldn't silently modify a project.

Docker and CI

RepoDrift is also designed to work in containerized environments.

A repository can be mounted into a container:

docker run --rm \
  -v "$PWD:/repo" \
  -w /repo \
  node:22-bookworm \
  npx --yes @repodrift/cli scan --local-only

For CI:

repodrift scan --json --fail-on high

This makes the CLI suitable for local development as well as automated workflows.

What I learned building it

The biggest lesson so far is that an AI developer tool doesn't need to start with AI.

A reliable developer tool needs a reliable foundation first.

That's why RepoDrift starts with:

Real Repository
      ↓
Deterministic Analysis
      ↓
Structured Findings
      ↓
Actionable Output

Then AI can be added on top.

This makes the system easier to test, easier to debug, and more predictable.

What's next?

RepoDrift is currently in Phase 1.

The roadmap is:

Phase 1 — Local Analysis

File scanning
Dependency analysis
Security patterns
Git analysis
Code metrics
Health score

Phase 2 — Deeper Analysis

Expanded code quality checks
Complexity analysis
Better configuration
More CI fixtures
More language support

Phase 3 — AI

Replaceable AI providers
Redacted AI payloads
AI explanations
AI recommendations

Phase 4 — Cloud

API
Historical scans
Database
Dashboard
Authentication
Repository monitoring

Phase 5 — AI Engineering

AI-generated fixes
Patch generation
Pull request suggestions
Automated repository reviews

Try RepoDrift

Install it with:

npm install -g @repodrift/cli

Then:

cd your-project

repodrift scan

Or:

npx @repodrift/cli scan

The project is open source and available on GitHub.

You can also find the package on npm.

Final Thought

RepoDrift started with a simple question:

"Can I know the health of my repository before it becomes a problem?"

The first version doesn't try to replace developers.

It simply gives them better visibility.

And the long-term goal is to turn that visibility into intelligent, actionable assistance.

Detection first. AI second. Automation later.

That's the direction I'm taking with RepoDrift.

🎙️ Introducing react-native-voice2text: Seamless Voice-to-Text for React Native Android Apps 📱

Gokul Krishna. S — Sat, 17 May 2025 13:02:21 +0000

Voice interaction is revolutionizing mobile app development. Whether it’s enabling hands-free control 🤚, enhancing accessibility ♿, or speeding up input ⏩, speech-to-text functionality is a must-have for modern apps. If you’re a React Native developer building for Android, I’m thrilled to introduce react-native-voice2text — a lightweight, user-friendly module that leverages Android’s native speech recognition APIs to convert voice to text in real-time. 🗣️➡️📝

Designed for simplicity and reliability, react-native-voice2text makes it easy to add voice features to your React Native apps. Let’s explore why this package is a game-changer and how you can get started!

Why Choose react-native-voice2text? ✅

Here’s what sets this library apart:

🎯 Seamless Integration: Built for React Native 0.70+, it supports autolinking for a hassle-free setup. ⚙️
🎤 Real-Time Recognition: Streams speech to text instantly, perfect for voice commands and hands-free inputs. 🔄
🔐 Built-in Permission Handling: Manages microphone permissions effortlessly, no extra configuration needed. 🔒
🚫 Robust Error Handling: Provides clear error callbacks for a smooth user experience. 🛠️
🤖 Powered by Android Native APIs: Uses Android’s native speech services for high accuracy and performance. 📡
🚧 iOS Support Coming Soon!: iOS compatibility is in the works, so stay tuned. 🍏

Whether you’re creating a chat app 💬, a hands-free utility 🤖, or accessibility tools ♿, react-native-voice2text is your go-to solution for voice-to-text with minimal effort.

🚀 Getting Started

Ready to add voice-to-text to your React Native app? Follow these simple steps to integrate react-native-voice2text and start converting speech to text in no time!

Step 1: Install the Package

Install the package using npm or Yarn:

npm install react-native-voice2text
# or
yarn add react-native-voice2text

Step 2: Update Android Permissions

To enable microphone access, add the following permissions to your AndroidManifest.xml (located at android/app/src/main/AndroidManifest.xml):

<uses-permission android:name="android.permission.RECORD_AUDIO" />
<uses-permission android:name="android.permission.INTERNET" />

Step 3: Implement Voice Input

Here’s a complete example of using react-native-voice2text in a React Native app:

import React, { useEffect } from 'react';
import { View, Text, TouchableOpacity, StyleSheet } from 'react-native';
import Voice2Text from 'react-native-voice2text';

const App = () => {
  const startListening = async () => {
    try {
      const granted = await Voice2Text.checkPermissions();
      if (granted) {
        Voice2Text.startListening('en-US'); // Start listening in English (US)
      } else {
        console.warn('Microphone permission denied 🚫🎤');
      }
    } catch (error) {
      console.error('Error checking permissions:', error);
    }
  };

  useEffect(() => {
    // Set up event listeners for results and errors
    Voice2Text.onResults(({ text }) => {
      console.log('Recognized text:', text);
    });

    Voice2Text.onError(({ message }) => {
      console.error('Error:', message);
    });

    // Clean up listeners on component unmount
    return () => {
      Voice2Text.removeAllListeners();
    };
  }, []);

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Voice-to-Text Demo</Text>
      <TouchableOpacity style={styles.button} onPress={startListening}>
        <Text style={styles.buttonText}>Start Voice Input 🎤</Text>
      </TouchableOpacity>
    </View>
  );
};

const styles = StyleSheet.create({
  container: { flex: 1, justifyContent: 'center', alignItems: 'center', padding: 20 },
  title: { fontSize: 24, fontWeight: 'bold', marginBottom: 20 },
  button: { backgroundColor: '#007AFF', padding: 15, borderRadius: 10 },
  buttonText: { color: '#fff', fontSize: 18 },
});

export default App;

What’s Happening Here?

checkPermissions: Verifies microphone access.
startListening: Initiates speech recognition, specifying the language (e.g., 'en-US').
onResults: Receives the recognized text and logs it to the console.
onError: Handles any errors during recognition.
The UI includes a TouchableOpacity button styled for a native mobile experience.

Step 4: Run Your App

Rebuild and run your app on an Android device or emulator:

npx react-native run-android

Speak into your device’s microphone, and the recognized text will appear in your console! 🎤 Note: Ensure your device or emulator has a working microphone for testing.

💡 Why Add Voice-to-Text to Your App?

Voice capabilities can elevate your app’s usability and inclusivity. Here are some compelling use cases for react-native-voice2text:

Accessibility: Empower users with visual or motor impairments to interact via voice. ♿
Hands-Free Operation: Enable voice commands for users on the move, like drivers or multitaskers. 🚗
Faster Input: Allow users to dictate messages or notes, saving time. ⏩
Innovative Features: Create voice-driven search, real-time transcription, or other unique functionalities. 🔍

By integrating react-native-voice2text, you’re making your app more accessible, intuitive, and future-proof.

☕ Support the Project

I’m Gokul, the creator and maintainer of react-native-voice2text. Building open-source libraries takes time and passion, and your support keeps me going! If you find this package helpful, please consider buying me a coffee to fuel my coding sessions. ☕❤️

You can also contribute by:

⭐ Starring the project on GitHub.
🐛 Reporting bugs or suggesting features via GitHub issues.
🛠️ Submitting pull requests to enhance the codebase.

🚀 Try It Out Today!

Ready to bring voice-to-text to your React Native app? Dive into the full documentation and get started with react-native-voice2text on npm: npmjs.com/package/react-native-voice2text.

Have questions or ideas? Drop a comment below or reach out via the GitHub repository. I’d love to hear how you’re using react-native-voice2text in your projects! 💬

Let’s make mobile apps more interactive and inclusive with the power of voice. Happy coding! 🚀

Do We Need a Real-Time Multilingual Voice Translator? Exploring the Potential of SpeakBo AI

Gokul Krishna. S — Mon, 17 Feb 2025 10:14:45 +0000

🌎 Breaking Language Barriers in a Globalized World

In a world where over 7,000 languages are spoken, communication challenges can limit personal connections, business collaborations, and global progress. While technology has made translation more accessible, real-time multilingual voice translation is still a growing need.

Enter SpeakBo AI – a concept designed to eliminate language barriers through instant voice translation while preserving voice tone and style. But before we go deeper, let’s ask the important question:

Do we really need such a platform? 🤔
The Challenge: Why Language Barriers Still Exist

Even with existing tools like Google Translate and AI-powered transcription services, real-time spoken translation with voice preservation is still a challenge. Here’s why:

🚧 Delayed Translations – Many current solutions provide text-based translations, making conversations unnatural.
🚧 Loss of Voice Identity – AI-generated voices often sound robotic and lack personal tone or emotion.
🚧 Limited Integrations – Most tools don’t seamlessly work across apps like YouTube, Google Meet, or Zoom.
🚧 Business & Education Gaps – Industries like customer support, education, and content creation need better translation solutions.

Clearly, there’s room for innovation in this space.
Introducing SpeakBo AI: A Potential Game-Changer?

Imagine an AI-powered platform that lets you speak naturally in your language and instantly hear it in another—while keeping your voice’s unique tone and style.

🔹 Real-Time Translation – Speak in your language, hear in theirs – instantly.
🔹 Voice Preservation – Your unique voice, translated across languages.
🔹 Seamless Integrations – Works with Google Meet, Zoom, YouTube, and more.
🔹 AI-Powered Accuracy – Powered by TensorFlow, React Native, and Node.js.

Whether you're a business professional, traveler, educator, or content creator, SpeakBo AI aims to make global communication effortless.
Does the World Need SpeakBo AI? Your Thoughts Matter!

Now, we turn to you—the users, the thinkers, the innovators.

💬 Would you use a platform like this?
💡 What features do you think are essential?
🚀 How can real-time voice translation impact your work or daily life?

Drop your thoughts in the comments and let’s shape the future of global communication—together!
🔥 Ready to Break Language Barriers? Join the Conversation!

If you believe in the power of seamless multilingual communication, share this post with your network. Let’s make real-time translation a reality! 🌍🎙️.

[Boost]

Gokul Krishna. S — Mon, 17 Feb 2025 09:57:52 +0000