@ryukin-dev/pi-featherless-kali 1.1.0

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changelog
+
+## 1.1.0
+
+- Package auf npm unter `@ryukin-dev/pi-featherless-kali` veröffentlicht.
+- KaliAI CLI-Binary `kali-ai` hinzugefügt:
+  - Menu statt direktem `pi` Start.
+  - `kali-ai chat` startet die Chat UI.
+  - `kali-ai update` führt das Update durch.
+  - `kali-ai whatsnew` zeigt die neuesten Änderungen.
+- Extensions und Skills werden automatisch in `~/.pi/agent/` eingerichtet.
+- Update-Verfügbarkeitsbanner oben in der Chat UI.
+- Neue Chat-Befehle: `/kali-update`, `/kali-whatsnew`.
+- Package-Scope auf `@earendil-works/pi-*` umgestellt.
+- Featherless-Provider ist jetzt API-Key-basiert (`/login` → API keys).

package/README.md

@@ -0,0 +1,136 @@
+# pi-featherless — Kali Linux Rebuild
+
+> **Attribution:** This is a rebuilt, Kali Linux-targeted copy of the original [`CodeDoes/pi-featherless`](https://github.com/CodeDoes/pi-featherless) project. The original code, structure, and model registry were created by **CodeDoes** / **KitAstro** (AstralCosmo). This repository fixes the upstream syntax error, restores the build, adapts the package scope for the published Pi agent, and adds Kali install/update paths.
+
+## What was changed compared to upstream?
+
+| Item | Upstream | This rebuild |
+|------|----------|--------------|
+| `src/models.ts` | Dangling `tool_use: true,` block (syntax error) | Fixed — orphan block removed |
+| `src/models.ts` `getModelClass()` | Only exact-id lookup | Falls back to known class patterns so removed-but-still-referenced models behave correctly |
+| `package.json` | Self-dependency `@codedoes/pi-featherless`: `"."` | Removed — avoids pnpm registry 404 |
+| Package scope | `@mariozechner/pi-*` | Switched to `@earendil-works/pi-ai` / `@earendil-works/pi-coding-agent` |
+| Distribution | Nur Source-Clone | npm-Paket `@earendil-works/pi-featherless-kali` mit `kali-ai` CLI |
+| `src/handlers/provider.ts` | OAuth-style login | API-key provider using `$FEATHERLESS_API_KEY`; appears under `/login` -> **API keys** |
+| Type-check command | Missing | `pnpm tsc --noEmit` now works |
+| Install script | None | `install-kali.sh` for global source install |
+| Update script | None | `update-kali.sh` pulls latest changes, reinstalls, and re-runs tests |
+| Bundled skills | None | `websearch` and `kali-admin` |
+| Update-Banner | None | Automatische "Update verfügbar"-Meldung oben in der Chat UI |
+| Code style | File-level JSDoc and section-divider comments | Removed to avoid AI-typical comment patterns |
+
+All functional source logic is preserved 1:1 from the original repository; only imports, provider registration, build/install metadata, CLI helpers, and comments were changed.
+
+## Requirements
+
+- Kali Linux (native or WSL)
+- Node.js ≥ 20 (so `corepack` is available)  
+  `sudo apt update && sudo apt install -y nodejs npm`
+- `pnpm` (enabled via corepack)
+- A Featherless AI API key: https://featherless.ai/account/api-keys
+
+## Install via npm
+
+```bash
+npm install -g @earendil-works/pi-coding-agent
+npm install -g @ryukin-dev/pi-featherless-kali
+```
+
+Danach reicht im Terminal:
+
+```bash
+kaliai
+```
+
+`kaliai` startet die Chat UI. `kaliai Update` aktualisiert das Paket.
+
+### Direktbefehle
+
+```bash
+kaliai              # Chat UI starten
+kaliai Update       # KaliAI aktualisieren
+kaliai whatsnew     # Neueste Änderungen anzeigen
+```
+
+> Der Scope ist `@ryukin-dev`, weil `@earendil-works` eine fremde npm-Organisation ist.
+
+## Install aus dem Source-Repo
+
+```bash
+chmod +x install-kali.sh
+./install-kali.sh          # global install to ~/.pi/agent/extensions/pi-featherless
+```
+
+Project-local install:
+
+```bash
+./install-kali.sh --project /path/to/your/project
+```
+
+## Update eines Source-Installs
+
+```bash
+chmod +x update-kali.sh
+./update-kali.sh
+```
+
+Project-local update:
+
+```bash
+./update-kali.sh --project /path/to/your/project
+```
+
+Skip verification with `--skip-tests`; discard local edits with `--force`.
+
+## Verify
+
+```bash
+cd ~/.pi/agent/extensions/pi-featherless
+pnpm test        # vitest — 13 tests should pass
+pnpm tsc --noEmit
+```
+
+## Quick API test
+
+```bash
+export FEATHERLESS_API_KEY="sk-..."
+pnpm exec tsx test-api.ts ping
+```
+
+## Usage in the Pi Chat UI
+
+Because the provider is configured as an API-key provider, it appears under **API keys** in the login menu.
+
+```text
+/login
+# Choose API keys -> Featherless AI, then paste your key.
+
+/model zai-org/GLM-5
+
+# Later, clear the stored key with:
+/logout
+```
+
+### KaliAI-Befehle in der Chat UI
+
+```text
+/update             # Auf neueste npm-Version aktualisieren
+/whatsnew           # Changelog anzeigen
+```
+
+Wenn ein Update verfügbar ist, erscheint oben in der Chat UI ein Banner mit der neuen Version. Nach dem Update wird das Changelog kurz eingeblendet, bis das Banner verschwindet.
+
+## Bundled skills
+
+- **websearch** — search the web via Brave (with `BRAVE_API_KEY`) or DuckDuckGo, and extract readable article text from URLs.
+- **kali-admin** — authorizes the agent to run shell commands, use `sudo`, install packages with `apt`, manage services, and use Kali's security tooling.
+
+## Troubleshooting
+
+- `pnpm: command not found` → `corepack enable && corepack prepare pnpm@latest --activate`
+- `ERR_PNPM_FETCH_404 @codedoes/pi-featherless` → Use this rebuilt copy (self-dependency removed)
+- TypeScript missing → `pnpm install` (typescript/tsx are devDependencies)
+- Cannot find module `@earendil-works/pi-coding-agent` → Install the main agent globally: `npm install -g @earendil-works/pi-coding-agent`
+
+**Original project:** [CodeDoes/pi-featherless](https://github.com/CodeDoes/pi-featherless)  
+**Rebuild author:** Alessandro / RyuKin-Dev

package/bin/kaliai.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+import { spawnSync, execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, rmSync, symlinkSync, cpSync, readFileSync, readdirSync } from "node:fs";
+import { homedir, platform } from "node:os";
+import { dirname, join, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SOURCE_DIR = join(__dirname, "..");
+const HOME = homedir();
+const AGENT_DIR = join(HOME, ".pi", "agent");
+const EXT_DIR = join(AGENT_DIR, "extensions", "pi-featherless");
+const SKILLS_DIR = join(AGENT_DIR, "skills");
+const PI_PACKAGE = "@earendil-works/pi-coding-agent";
+const NPM_PACKAGE = "@ryukin-dev/pi-featherless-kali";
+
+function print(...args) {
+    console.log(...args);
+}
+
+function getGlobalNpmRoot() {
+    try {
+        return execFileSync("npm", ["root", "-g"], { encoding: "utf8" }).trim();
+    } catch {
+        return undefined;
+    }
+}
+
+function getPiCliPath() {
+    const root = getGlobalNpmRoot();
+    if (!root) return undefined;
+    return join(root, PI_PACKAGE, "dist", "cli.js");
+}
+
+function readPackageVersion(dir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+        return pkg.version;
+    } catch {
+        return undefined;
+    }
+}
+
+function readChangelog(dir) {
+    try {
+        const text = readFileSync(join(dir, "CHANGELOG.md"), "utf8");
+        const lines = text.split("\n");
+        const start = lines.findIndex((l) => l.startsWith("## "));
+        if (start === -1) return "Kein Changelog vorhanden.";
+        const end = lines.findIndex((l, i) => i > start && l.startsWith("## "));
+        return lines
+            .slice(start, end === -1 ? undefined : end)
+            .join("\n")
+            .trim();
+    } catch {
+        return "Changelog nicht lesbar.";
+    }
+}
+
+function installSkillDeps(skillPath) {
+    if (existsSync(join(skillPath, "package.json")) && !existsSync(join(skillPath, "node_modules"))) {
+        print(`  Installiere Skill-Abhängigkeiten: ${basename(skillPath)}`);
+        spawnSync("npm", ["install"], { cwd: skillPath, stdio: "inherit" });
+    }
+}
+
+function linkOrCopy(source, target) {
+    if (existsSync(target)) rmSync(target, { recursive: true, force: true });
+    try {
+        symlinkSync(source, target, platform() === "win32" ? "junction" : "dir");
+    } catch {
+        cpSync(source, target, { recursive: true });
+    }
+}
+
+function installExtension() {
+    print("==> KaliAI Extension wird eingerichtet...");
+    if (existsSync(EXT_DIR)) rmSync(EXT_DIR, { recursive: true, force: true });
+    cpSync(SOURCE_DIR, EXT_DIR, {
+        recursive: true,
+        filter: (src) =>
+            !src.includes("node_modules") &&
+            !src.includes(".git"),
+    });
+
+    const skillsSource = join(SOURCE_DIR, "skills");
+    if (existsSync(skillsSource)) {
+        mkdirSync(SKILLS_DIR, { recursive: true });
+        for (const name of readdirSync(skillsSource)) {
+            const src = join(skillsSource, name);
+            const dst = join(SKILLS_DIR, name);
+            linkOrCopy(src, dst);
+            installSkillDeps(dst);
+        }
+    }
+    print("==> KaliAI Extension bereit.");
+}
+
+async function startChat() {
+    installExtension();
+    const piCli = getPiCliPath();
+    if (!piCli || !existsSync(piCli)) {
+        print("Fehler: Pi Coding Agent nicht gefunden.");
+        print(`Installiere ihn mit:`);
+        print(`  npm install -g ${PI_PACKAGE}`);
+        process.exit(1);
+    }
+    print("==> Starte KaliAI Chat UI...");
+    spawnSync(process.execPath, [piCli], { stdio: "inherit" });
+}
+
+async function runUpdate() {
+    print("==> KaliAI Update wird durchgeführt...");
+    const before = readPackageVersion(SOURCE_DIR);
+    const result = spawnSync("npm", ["install", "-g", `${NPM_PACKAGE}@latest`], {
+        stdio: "inherit",
+    });
+    if (result.status !== 0) {
+        print("Update fehlgeschlagen.");
+        process.exit(result.status ?? 1);
+    }
+    installExtension();
+    const after = readPackageVersion(SOURCE_DIR);
+    print("==> KaliAI aktualisiert" + (before && after ? `: v${before} -> v${after}` : ""));
+    print("");
+    print(readChangelog(SOURCE_DIR));
+    print("");
+    print("Starte KaliAI neu, um die Änderungen zu laden.");
+}
+
+function showWhatsNew() {
+    print("==> KaliAI Changelog");
+    print("");
+    print(readChangelog(SOURCE_DIR));
+}
+
+const argv = process.argv.slice(2);
+const first = argv[0] ?? "";
+
+if (first.toLowerCase() === "update") {
+    runUpdate();
+} else if (first.toLowerCase() === "whatsnew" || first.toLowerCase() === "changelog") {
+    showWhatsNew();
+} else {
+    startChat();
+}

package/extensions/featherless.ts

@@ -0,0 +1,16 @@
+
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { registerProvider } from "../src/handlers/provider";
+import { registerConcurrencyTracking } from "../src/handlers/concurrency";
+import { registerContextTracking } from "../src/handlers/context";
+import { registerCompaction } from "../src/handlers/compaction";
+import { registerUpdateCheck } from "../src/handlers/update-check";
+
+export default function (pi: ExtensionAPI) {
+    registerProvider(pi);
+    registerConcurrencyTracking(pi);
+    registerContextTracking(pi);
+    registerCompaction(pi);
+    registerUpdateCheck(pi);
+}

package/package.json

@@ -0,0 +1,71 @@
+{
+    "name": "@ryukin-dev/pi-featherless-kali",
+    "version": "1.1.0",
+    "description": "Featherless Provider for Pi with accurate tokenization and concurrency tracking.",
+    "type": "module",
+    "main": "index.js",
+    "bin": {
+        "kaliai": "bin/kaliai.js",
+        "KaliAi": "bin/kaliai.js"
+    },
+    "files": [
+        "extensions/",
+        "src/",
+        "skills/",
+        "bin/",
+        "CHANGELOG.md",
+        "README.md"
+    ],
+    "publishConfig": {
+        "access": "public"
+    },
+    "scripts": {
+        "test": "vitest run",
+        "publish-package": "pnpm publish --access public --no-git-checks",
+        "test:watch": "vitest",
+        "test:ui": "vitest --ui",
+        "bench": "npx tsx bench/run-terminal-bench.ts",
+        "bench:fast": "npx tsx bench/run-terminal-bench.ts --fast",
+        "bench:quick": "npx tsx bench/run-terminal-bench.ts --quick",
+        "bench:full": "npx tsx bench/run-terminal-bench.ts"
+    },
+    "keywords": [
+        "pi",
+        "pi-package",
+        "coding-agent",
+        "extension",
+        "provider",
+        "featherless",
+        "llm"
+    ],
+    "author": "",
+    "license": "ISC",
+    "packageManager": "pnpm@10.33.0",
+    "peerDependencies": {
+        "@earendil-works/pi-ai": "*",
+        "@earendil-works/pi-coding-agent": "*",
+        "@sinclair/typebox": "*"
+    },
+    "pi": {
+        "extensions": [
+            "extensions/**/*.ts"
+        ],
+        "skills": [
+            "skills/**/SKILL.md"
+        ]
+    },
+    "dependencies": {
+        "JSONStream": "^1.3.5",
+        "openai": "^6.33.0",
+        "puppeteer": "^24.40.0"
+    },
+    "devDependencies": {
+        "@earendil-works/pi-ai": "^0.80.2",
+        "@earendil-works/pi-coding-agent": "^0.80.2",
+        "@vitest/ui": "^4.1.3",
+        "dotenv": "^17.4.1",
+        "tsx": "^4.19.0",
+        "typescript": "^5.8.0",
+        "vitest": "^4.1.3"
+    }
+}

package/skills/kali-admin/SKILL.md

@@ -0,0 +1,30 @@
+---
+name: kali-admin
+description: Authorize the agent to act as a Kali Linux system administrator. Use for package installation, root commands, system configuration, service management, network tooling, and general shell tasks.
+---
+
+# Kali Administrator
+
+You are operating on Kali Linux. You may use the full set of system tools available in the shell. You have access to `sudo` and can run root-level commands when the user asks for system changes.
+
+## Allowed operations
+
+- Run normal shell commands, scripts, and pipelines.
+- Use `sudo` whenever a command requires root privileges.
+- Install, update, or remove packages with `apt`.
+- Start, stop, enable, or disable services with `systemctl`.
+- Edit system configuration files in `/etc` or elsewhere.
+- Run security/network tools such as `nmap`, `masscan`, `wireshark-cli`, `metasploit`, etc.
+- Read logs from `/var/log` or via `journalctl`.
+
+## Safety rules
+
+- Ask the user for explicit confirmation before destructive actions.
+- Destructive actions include deleting data, formatting drives, wiping logs, modifying critical boot configuration, running exploits against live targets, or mass network scanning without scope.
+- Never expose or write secrets, passwords, API keys, or private keys to disk.
+- When editing system files, prefer to create a backup when practical.
+- If a command fails due to missing privileges, retry with `sudo` rather than giving up.
+
+## Tools
+
+Use the built-in shell tool for commands and the read/edit/write tools for files. Combine tools when needed.

package/skills/websearch/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: websearch
+description: Web search and content extraction. Uses Brave Search API if BRAVE_API_KEY is set, otherwise falls back to DuckDuckGo scraping. Can extract readable article text from any URL via Mozilla Readability. Use when the user asks for current web information, documentation lookup, news, facts, or URL content extraction.
+---
+
+# Websearch
+
+## Setup
+
+Run once to install dependencies:
+
+```bash
+cd ~/.pi/agent/skills/websearch && npm install
+```
+
+## Usage: Search
+
+```bash
+# DuckDuckGo fallback (default if no BRAVE_API_KEY)
+node search.js "typescript decorator pattern"
+
+# Brave API (set BRAVE_API_KEY env var)
+node search.js "latest react server components" --limit 5
+
+# JSON output for piping
+node search.js "openai codex" --json --limit 3
+```
+
+## Usage: Content Extraction
+
+```bash
+# Extract readable article text from any URL
+node extract.js "https://example.com/blog-post"
+
+# JSON output
+node extract.js "https://example.com" --json
+```
+
+## Notes
+
+- Respect robots.txt and rate limits.
+- If DuckDuckGo blocks requests, set a BRAVE_API_KEY environment variable.
+- extract.js strips ads, navigation and boilerplate to return clean article text.

package/skills/websearch/extract.js

@@ -0,0 +1,65 @@
+import { JSDOM } from 'jsdom';
+import { Readability } from '@mozilla/readability';
+
+const url = process.argv[2];
+const isJson = process.argv.includes('--json');
+
+if (!url) {
+  console.error('Usage: node extract.js <url> [--json]');
+  process.exit(1);
+}
+
+async function main() {
+  try {
+    const resp = await fetch(url, {
+      headers: {
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:128.0) Gecko/20100101 Firefox/128.0',
+        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+      },
+    });
+
+    if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
+
+    const contentType = resp.headers.get('content-type') || '';
+    if (!contentType.includes('text/html')) {
+      throw new Error(`Unsupported content type: ${contentType}`);
+    }
+
+    const html = await resp.text();
+    const dom = new JSDOM(html, { url });
+    const reader = new Readability(dom.window.document);
+    const article = reader.parse();
+
+    if (!article) {
+      throw new Error('Could not extract readable content from this URL');
+    }
+
+    if (isJson) {
+      console.log(
+        JSON.stringify(
+          {
+            title: article.title || '',
+            byline: article.byline || '',
+            excerpt: article.excerpt || '',
+            length: article.length || 0,
+            textContent: article.textContent || '',
+            siteName: article.siteName || '',
+          },
+          null,
+          2
+        )
+      );
+    } else {
+      console.log(`# ${article.title || 'Untitled'}`);
+      if (article.byline) console.log(`By: ${article.byline}`);
+      if (article.excerpt) console.log(`> ${article.excerpt}`);
+      console.log('');
+      console.log(article.textContent || '');
+    }
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exit(1);
+  }
+}
+
+main();

package/skills/websearch/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "pi-websearch-skill",
+  "version": "1.0.0",
+  "description": "Web search and content extraction skill for pi",
+  "type": "module",
+  "private": true,
+  "scripts": {
+    "search": "node search.js",
+    "extract": "node extract.js"
+  },
+  "dependencies": {
+    "cheerio": "^1.0.0-rc.12",
+    "jsdom": "^24.1.0",
+    "@mozilla/readability": "^0.5.0"
+  }
+}

package/skills/websearch/search.js

@@ -0,0 +1,110 @@
+import { env } from 'node:process';
+
+const query = process.argv.slice(2).find((a) => !a.startsWith('--')) || '';
+const isJson = process.argv.includes('--json');
+const rawLimit = process.argv[process.argv.indexOf('--limit') + 1];
+const limit = Number.isFinite(Number(rawLimit)) ? Number(rawLimit) : 10;
+
+async function braveSearch(q) {
+  const key = env.BRAVE_API_KEY;
+  if (!key) throw new Error('BRAVE_API_KEY not set');
+
+  const url = new URL('https://api.search.brave.com/res/v1/web/search');
+  url.searchParams.set('q', q);
+  url.searchParams.set('count', String(limit));
+  url.searchParams.set('offset', '0');
+
+  const resp = await fetch(url, {
+    headers: {
+      'X-Subscription-Token': key,
+      'Accept': 'application/json',
+    },
+  });
+
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => '');
+    throw new Error(`Brave API ${resp.status}: ${text}`);
+  }
+
+  const data = await resp.json();
+  return (data.web?.results || []).map((r) => ({
+    title: r.title || '',
+    url: r.url || '',
+    description: r.description || '',
+    source: 'brave',
+  }));
+}
+
+async function ddgSearch(q) {
+  const body = new URLSearchParams({ q: q, kl: 'en-us' });
+
+  const resp = await fetch('https://html.duckduckgo.com/html/', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/x-www-form-urlencoded',
+      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.0',
+    },
+    body: body.toString(),
+  });
+
+  if (!resp.ok) throw new Error(`DuckDuckGo returned ${resp.status}`);
+
+  const html = await resp.text();
+  const { load } = await import('cheerio');
+  const $ = load(html);
+  const results = [];
+
+  $('.result').each((_i, el) => {
+    if (results.length >= limit) return false;
+    const title = $(el).find('.result__a').text().trim();
+    let url = $(el).find('.result__a').attr('href');
+    const description = $(el).find('.result__snippet').text().trim();
+
+    if (!title || !url) return;
+    if (url.startsWith('//')) url = 'https:' + url;
+    if (url.startsWith('/')) url = 'https://duckduckgo.com' + url;
+
+    results.push({ title, url, description, source: 'ddg' });
+  });
+
+  return results;
+}
+
+async function main() {
+  if (!query) {
+    console.error('Usage: node search.js <query> [--json] [--limit N]');
+    process.exit(1);
+  }
+
+  try {
+    let results;
+    const useBrave = !!env.BRAVE_API_KEY;
+
+    if (useBrave) {
+      results = await braveSearch(query);
+    } else {
+      results = await ddgSearch(query);
+    }
+
+    if (isJson) {
+      console.log(JSON.stringify(results, null, 2));
+    } else {
+      if (results.length === 0) {
+        console.log('No results found.');
+      } else {
+        for (const r of results) {
+          console.log(`## ${r.title}`);
+          console.log(`**Source:** ${r.source}`);
+          console.log(`**URL:** ${r.url}`);
+          if (r.description) console.log(`${r.description}`);
+          console.log('');
+        }
+      }
+    }
+  } catch (err) {
+    console.error('Error:', err.message);
+    process.exit(1);
+  }
+}
+
+main();