@krishivpb60/aether-ai-cli 1.1.4 → 1.1.6

package/README.md

@@ -46,7 +46,7 @@
 
 ## 🚀 Quick Start
 
-### Install globally
+### Install globally via npm
 
 ```bash
 npm install -g @krishivpb60/aether-ai-cli
@@ -58,6 +58,14 @@ npm install -g @krishivpb60/aether-ai-cli
 npx @krishivpb60/aether-ai-cli chat
 ```
 
+### Or install via pip (Python wrapper)
+
+```bash
+pip install aether-ai-agent-cli
+# Run via terminal:
+aether-pip chat
+```
+
 ### Setup (Interactive Wizard)
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@krishivpb60/aether-ai-cli",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "Aether Core AI — A cyberpunk command-line AI assistant with multi-mode reasoning, 12-node failover mesh, file context injection, and offline fallbacks.",
   "main": "src/cli.js",
   "bin": {

package/setup.py

@@ -1,19 +1,30 @@
 from setuptools import setup, find_packages
 import os
 import shutil
+import json
+
+# Read version from package.json
+pkg_json_path = 'package.json'
+if not os.path.exists(pkg_json_path):
+    pkg_json_path = os.path.join('aether_pip', 'node_project', 'package.json')
+
+with open(pkg_json_path, 'r', encoding='utf-8') as f:
+    pkg_data = json.load(f)
+version = pkg_data.get('version', '1.0.0')
 
 # Copy Node project files into aether_pip/node_project for clean packaging
-dest_dir = os.path.join('aether_pip', 'node_project')
-if os.path.exists(dest_dir):
-    shutil.rmtree(dest_dir)
-os.makedirs(dest_dir)
+if os.path.exists('bin') and os.path.exists('src'):
+    dest_dir = os.path.join('aether_pip', 'node_project')
+    if os.path.exists(dest_dir):
+        shutil.rmtree(dest_dir)
+    os.makedirs(dest_dir)
 
-# Copy directories
-shutil.copytree('bin', os.path.join(dest_dir, 'bin'))
-shutil.copytree('src', os.path.join(dest_dir, 'src'))
-shutil.copyfile('package.json', os.path.join(dest_dir, 'package.json'))
-if os.path.exists('package-lock.json'):
-    shutil.copyfile('package-lock.json', os.path.join(dest_dir, 'package-lock.json'))
+    # Copy directories
+    shutil.copytree('bin', os.path.join(dest_dir, 'bin'))
+    shutil.copytree('src', os.path.join(dest_dir, 'src'))
+    shutil.copyfile('package.json', os.path.join(dest_dir, 'package.json'))
+    if os.path.exists('package-lock.json'):
+        shutil.copyfile('package-lock.json', os.path.join(dest_dir, 'package-lock.json'))
 
 def package_files(directory):
     paths = []
@@ -24,8 +35,8 @@ def package_files(directory):
     return paths
 
 setup(
-    name="aether-ai-cli",
-    version="1.0.0",
+    name="aether-ai-agent-cli",
+    version=version,
     author="Krishiv PB",
     author_email="krylobloxyt@gmail.com",
     description="Aether Core AI v110 — Universal AI Gateway CLI (Python Wrapper)",

package/src/chat.js

@@ -20,6 +20,8 @@ import {
   bullet,
   modeBadge,
   clearStreamedText,
+  StreamFilter,
+  stripCodeFences,
   getActiveTheme,
   setTheme,
   getThemesList
@@ -228,19 +230,21 @@ export async function startChat(options = {}) {
 
     let hasStartedStreaming = false;
     let streamedText = "";
+    const filter = new StreamFilter(process.stdout.write.bind(process.stdout));
     const onToken = (token) => {
       if (!hasStartedStreaming) {
         hasStartedStreaming = true;
         firstTokenTime = Date.now();
         spinner.stop();
       }
-      process.stdout.write(token);
+      filter.write(token);
       streamedText += token;
     };
 
     try {
       const result = await routePrompt(fullPrompt, currentMode.systemPrompt, aiConfig, onToken, history);
       spinner.stop();
+      filter.flush();
 
       // Store in history
       history.push({ role: "user", content: originalInput, timestamp: new Date() });
@@ -257,7 +261,7 @@ export async function startChat(options = {}) {
       await saveHistory(history);
 
       if (hasStartedStreaming) {
-        clearStreamedText(streamedText);
+        clearStreamedText(filter.filteredText);
       }
 
       // Display response
@@ -302,7 +306,7 @@ export async function startChat(options = {}) {
       let match;
       const fileWrites = [];
       while ((match = writeRegex.exec(result.text)) !== null) {
-        fileWrites.push({ path: match[1].trim(), content: match[2] });
+        fileWrites.push({ path: match[1].trim(), content: stripCodeFences(match[2]) });
       }
 
       if (fileWrites.length > 0) {

package/src/cli.js

@@ -18,6 +18,8 @@ import {
   keyValue,
   bullet,
   clearStreamedText,
+  StreamFilter,
+  stripCodeFences,
   getActiveTheme,
   setTheme,
   getThemesList,
@@ -253,19 +255,27 @@ async function handleAsk(prompt, opts) {
 
   let hasStartedStreaming = false;
   let streamedText = "";
+  const filter = !opts.raw ? new StreamFilter(process.stdout.write.bind(process.stdout)) : null;
   const onToken = (token) => {
     if (!hasStartedStreaming) {
       hasStartedStreaming = true;
       firstTokenTime = Date.now();
       spinner.stop();
     }
-    process.stdout.write(token);
+    if (filter) {
+      filter.write(token);
+    } else {
+      process.stdout.write(token);
+    }
     streamedText += token;
   };
 
   try {
     const result = await routePrompt(fullPrompt, mode.systemPrompt, aiConfig, onToken);
     spinner.stop();
+    if (filter) {
+      filter.flush();
+    }
 
     if (opts.raw) {
       if (!hasStartedStreaming) {
@@ -277,7 +287,7 @@ async function handleAsk(prompt, opts) {
       }
     } else {
       if (hasStartedStreaming) {
-        clearStreamedText(streamedText);
+        clearStreamedText(filter ? filter.filteredText : streamedText);
       }
       console.log("");
       console.log(label.aether + " " + colors.dim(`via ${result.provider}${result.model ? ` (${result.model})` : ""} • Node ${result.node}`));
@@ -319,7 +329,7 @@ async function handleAsk(prompt, opts) {
       let match;
       const fileWrites = [];
       while ((match = writeRegex.exec(result.text)) !== null) {
-        fileWrites.push({ path: match[1].trim(), content: match[2] });
+        fileWrites.push({ path: match[1].trim(), content: stripCodeFences(match[2]) });
       }
 
       if (fileWrites.length > 0) {

package/src/ui/theme.js

@@ -148,6 +148,107 @@ export function clearStreamedText(text) {
   }
 }
 
+/**
+ * Filter stream tokens on the fly to suppress file write blocks
+ * and print a cleaner placeholder badge in real-time instead of raw code.
+ */
+export class StreamFilter {
+  constructor(writeFn) {
+    this.writeFn = writeFn;
+    this.buffer = "";
+    this.cursor = 0;
+    this.state = "NORMAL"; // "NORMAL", "COLLECTING_FILENAME", "SUPPRESSING"
+    this.filenameBuffer = "";
+    this.filteredText = "";
+  }
+
+  _write(text) {
+    this.writeFn(text);
+    this.filteredText += text;
+  }
+
+  write(token) {
+    this.buffer += token;
+    this.process();
+  }
+
+  process() {
+    const writeTag = "[WRITE_FILE:";
+    const endTag = "[END_WRITE]";
+
+    while (this.cursor < this.buffer.length) {
+      if (this.state === "NORMAL") {
+        const nextIndex = this.buffer.indexOf(writeTag, this.cursor);
+        if (nextIndex !== -1) {
+          if (nextIndex > this.cursor) {
+            this._write(this.buffer.slice(this.cursor, nextIndex));
+          }
+          this.cursor = nextIndex + writeTag.length;
+          this.state = "COLLECTING_FILENAME";
+          this.filenameBuffer = "";
+        } else {
+          // Check for partial match of writeTag at the end of the buffer
+          let partialMatchLength = 0;
+          for (let i = 1; i < writeTag.length; i++) {
+            const part = writeTag.slice(0, i);
+            if (this.buffer.endsWith(part)) {
+              partialMatchLength = i;
+              break;
+            }
+          }
+          const safeEnd = this.buffer.length - partialMatchLength;
+          if (safeEnd > this.cursor) {
+            this._write(this.buffer.slice(this.cursor, safeEnd));
+            this.cursor = safeEnd;
+          }
+          break; // Wait for more tokens
+        }
+      } else if (this.state === "COLLECTING_FILENAME") {
+        const closeIndex = this.buffer.indexOf("]", this.cursor);
+        if (closeIndex !== -1) {
+          this.filenameBuffer += this.buffer.slice(this.cursor, closeIndex);
+          const filename = this.filenameBuffer.trim();
+          this._write(`\n\n${colors.brand("⚡ [File creation request: " + filename + "]")}\n\n`);
+          this.cursor = closeIndex + 1;
+          this.state = "SUPPRESSING";
+        } else {
+          this.filenameBuffer += this.buffer.slice(this.cursor);
+          this.cursor = this.buffer.length;
+          break; // Wait for more tokens
+        }
+      } else if (this.state === "SUPPRESSING") {
+        const nextIndex = this.buffer.indexOf(endTag, this.cursor);
+        if (nextIndex !== -1) {
+          this.cursor = nextIndex + endTag.length;
+          this.state = "NORMAL";
+        } else {
+          // Check for partial match of endTag at the end of the buffer
+          let partialMatchLength = 0;
+          for (let i = 1; i < endTag.length; i++) {
+            const part = endTag.slice(0, i);
+            if (this.buffer.endsWith(part)) {
+              partialMatchLength = i;
+              break;
+            }
+          }
+          const safeEnd = this.buffer.length - partialMatchLength;
+          if (safeEnd > this.cursor) {
+            this.cursor = safeEnd;
+          }
+          break; // Wait for more tokens
+        }
+      }
+    }
+  }
+
+  flush() {
+    if (this.state === "NORMAL" && this.cursor < this.buffer.length) {
+      this._write(this.buffer.slice(this.cursor));
+      this.cursor = this.buffer.length;
+    }
+  }
+}
+
 // ── Theme State Management ────────────────────────────────
 
 export function getActiveTheme() {
@@ -167,3 +268,24 @@ export function setTheme(themeName) {
 export function getThemesList() {
   return Object.keys(THEMES);
 }
+
+/**
+ * Strips markdown code block fences (```lang ... ```) from a string if present.
+ * @param {string} content - Raw content extracted from file write blocks
+ * @returns {string} Cleaned content
+ */
+export function stripCodeFences(content) {
+  let cleaned = content.trim();
+  if (cleaned.startsWith("```")) {
+    const firstNewline = cleaned.indexOf("\n");
+    if (firstNewline !== -1) {
+      cleaned = cleaned.slice(firstNewline + 1);
+    } else {
+      cleaned = cleaned.slice(3);
+    }
+    if (cleaned.endsWith("```")) {
+      cleaned = cleaned.slice(0, -3);
+    }
+  }
+  return cleaned.trim();
+}

package/test/ux.test.js

@@ -1,6 +1,6 @@
 import { test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert";
-import { separator, clearStreamedText, getActiveTheme, setTheme, getThemesList } from "../src/ui/theme.js";
+import { separator, clearStreamedText, StreamFilter, stripCodeFences, getActiveTheme, setTheme, getThemesList } from "../src/ui/theme.js";
 import { createSpinner } from "../src/ui/spinner.js";
 import { routePrompt } from "../src/ai/router.js";
 import { getModeByName, MODES } from "../src/modes.js";
@@ -148,4 +148,34 @@ test("Cyberpunk UX and Streaming Suite", async (t) => {
     const unknown = getModeByName("nonexistent-mode");
     assert.strictEqual(unknown, null);
   });
+
+  await t.test("StreamFilter should suppress file blocks but output other text", () => {
+    let output = "";
+    const filter = new StreamFilter((chunk) => {
+      output += chunk;
+    });
+
+    filter.write("Hello ");
+    filter.write("world! [WRITE_");
+    filter.write("FILE: test.txt]");
+    filter.write("This content is hidden\n");
+    filter.write("[END_WRITE] After block");
+    filter.flush();
+
+    assert.ok(output.includes("Hello world!"));
+    assert.ok(output.includes("After block"));
+    assert.ok(output.includes("File creation request: test.txt"));
+    assert.ok(!output.includes("This content is hidden"));
+  });
+
+  await t.test("stripCodeFences should clean code blocks with backticks", () => {
+    const jsBlock = "```javascript\nconsole.log('hi');\n```";
+    assert.strictEqual(stripCodeFences(jsBlock), "console.log('hi');");
+
+    const htmlBlock = "```html\n<div>hello</div>\n```";
+    assert.strictEqual(stripCodeFences(htmlBlock), "<div>hello</div>");
+
+    const noFenceBlock = "console.log('hi');";
+    assert.strictEqual(stripCodeFences(noFenceBlock), "console.log('hi');");
+  });
 });