# What Programming Language Is k‑skill Written In? A Deep Dive Into the NomaDamas Repository

> Discover the programming languages powering k-skill. Explore the NomaDamas repository to understand its TypeScript core and Python script support.

- Repository: [NomaDamas/k-skill](https://github.com/NomaDamas/k-skill)
- Tags: deep-dive
- Published: 2026-08-04

---

**k‑skill is primarily written in TypeScript for its core Node.js framework, with extensive Python support for individual skill scripts.**

The [NomaDamas/k-skill](https://github.com/NomaDamas/k-skill) repository is a polyglot monorepo that combines a TypeScript-powered skill execution platform with Python-based utility modules. Understanding this dual-language architecture helps developers contribute effectively to the right parts of the codebase.

## TypeScript: The Core Framework Language

The infrastructure of k‑skill is built on Node.js and TypeScript, managed as an npm workspace.

### CLI Package (`packages/k-skill-cli/`)

The command-line interface that orchestrates skill execution lives in [[`packages/k-skill-cli/package.json`](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-cli/package.json)](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-cli/package.json). This package defines the core TypeScript runtime:

```json
{
  "name": "@nomadamas/k-skill-cli",
  "version": "0.1.0",
  "description": "k-skill CLI",
  "main": "dist/index.js",
  "scripts": {
    "build": "tsc",
    "start": "node dist/index.js"
  },
  "dependencies": {
    "commander": "^11.0.0",
    "glob": "^10.0.0"
  }
}

```

The CLI compiles TypeScript (`tsc`) and executes skills through Node.js, making **TypeScript the primary language for framework-level logic**.

### Proxy Server (`packages/k-skill-proxy/`)

API routing functionality is implemented in [[`packages/k-skill-proxy/package.json`](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-proxy/package.json)](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-proxy/package.json), another TypeScript/Node.js package that handles free-API request management across skills.

### TypeScript Configuration

Root-level TypeScript settings are defined in [[`tsconfig.json`](https://github.com/NomaDamas/k-skill/blob/main/tsconfig.json)](https://github.com/NomaDamas/k-skill/blob/main/tsconfig.json), confirming the entire monorepo uses strict TypeScript compilation with shared compiler options.

## Python: The Skill Script Language

While the framework runs on TypeScript, **individual skills predominantly use Python** for their executable scripts. These scripts implement domain-specific logic and are invoked by the CLI at runtime.

### ZIP Code Search Utility

The [[`zipcode-search/scripts/zipcode_search.py`](https://github.com/NomaDamas/k-skill/blob/main/zipcode-search/scripts/zipcode_search.py)](https://github.com/NomaDamas/k-skill/blob/main/zipcode-search/scripts/zipcode_search.py) demonstrates typical Python skill implementation:

```python
import sys
import requests

def search_zipcode(address: str) -> dict:
    """Fetch ZIP code data from Korean address API."""
    resp = requests.get(
        "https://api.zipcode.kr/search",
        params={"address": address}
    )
    resp.raise_for_status()
    return resp.json()

if __name__ == "__main__":
    address = " ".join(sys.argv[1:])
    result = search_zipcode(address)
    print(result)

```

This pattern—**Python scripts accepting CLI arguments and returning JSON/printed output**—is repeated across most skills.

### News Search Implementation

Similarly, [[`geeknews-search/scripts/geeknews_search.py`](https://github.com/NomaDamas/k-skill/blob/main/geeknews-search/scripts/geeknews_search.py)](https://github.com/NomaDamas/k-skill/blob/main/geeknews-search/scripts/geeknews_search.py) uses Python with `requests` and `beautifulsoup4` for web scraping:

```python
import requests
from bs4 import BeautifulSoup

def fetch_geeknews():
    """Scrape GeekNews articles."""
    resp = requests.get("https://news.hada.io/new")
    soup = BeautifulSoup(resp.text, "html.parser")
    # Parsing logic...

    return articles

```

## Repository Language Distribution

| Component | Primary Language | Key File |
|-----------|-----------------|----------|
| CLI executor | TypeScript | [[`packages/k-skill-cli/package.json`](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-cli/package.json)](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-cli/package.json) |
| API proxy | TypeScript | [[`packages/k-skill-proxy/package.json`](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-proxy/package.json)](https://github.com/NomaDamas/k-skill/blob/main/packages/k-skill-proxy/package.json) |
| Skill scripts | Python | `*/scripts/*.py` (e.g., [[`zipcode_search.py`](https://github.com/NomaDamas/k-skill/blob/main/zipcode_search.py)](https://github.com/NomaDamas/k-skill/blob/main/zipcode-search/scripts/zipcode_search.py)) |
| Build tooling | TypeScript/JSON | [[`tsconfig.json`](https://github.com/NomaDamas/k-skill/blob/main/tsconfig.json)](https://github.com/NomaDamas/k-skill/blob/main/tsconfig.json), [`package.json`](https://github.com/NomaDamas/k-skill/blob/main/package.json) files |

## How the Languages Interact

The TypeScript CLI discovers and executes Python scripts through a standardized interface:

```bash

# TypeScript CLI invokes Python skill

npx k-skill exec zipcode-search scripts/zipcode_search.py "Seoul Gangnam"

```

Execution flow:
1. **TypeScript** (`k-skill-cli`) parses arguments and locates the skill
2. **TypeScript** spawns a subprocess running the Python script
3. **Python** executes domain logic (API calls, scraping, computation)
4. **Python** returns structured output via stdout
5. **TypeScript** captures, formats, and returns the result

This architecture cleanly **separates framework concerns (TypeScript) from business logic (Python)**, allowing skill authors to write data-processing code without touching the execution engine.

## Summary

- **k-skill's core framework is TypeScript/Node.js**, implementing the CLI, proxy server, and build system
- **Individual skills are predominantly Python**, handling API interactions, web scraping, and data transformation
- The repository uses an npm workspace structure with TypeScript configuration at the root
- Python scripts follow a consistent CLI-argument interface for seamless TypeScript orchestration

## Frequently Asked Questions

### Is k‑skill a Python framework or a TypeScript framework?

k‑skill is a **TypeScript framework that executes Python scripts**. The infrastructure—parsing, routing, and execution management—is built in TypeScript/Node.js, while skill implementations are written in Python for rapid data-processing development.

### Can I write a k‑skill entirely in TypeScript?

Currently, the framework expects skill logic in Python scripts referenced by [`instruction.md`](https://github.com/NomaDamas/k-skill/blob/main/instruction.md) files. While the CLI itself is extensible TypeScript, **skill contributions require Python** to maintain consistency with the existing ecosystem and execution model.

### Why does k‑skill use two languages instead of one?

The dual-language approach **optimizes for different use cases**: TypeScript provides robust async I/O and package management for the platform layer, while Python offers superior libraries for web scraping (`beautifulsoup4`), data science (`pandas`, `requests`), and rapid script development. This separation lets contributors leverage each language's strengths.