ai-pack-cli 0.1.1__tar.gz → 0.1.2__tar.gz

{ai_pack_cli-0.1.1 → ai_pack_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ai-pack-cli
-Version: 0.1.1
+Version: 0.1.2
 Home-page: https://github.com/iamraydoan/ai-pack
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{ai_pack_cli-0.1.1 → ai_pack_cli-0.1.2}/ai_pack.py

@@ -231,10 +231,16 @@ class SkeletonExtractor:
                 indent = len(line) - len(line.lstrip())
                 sig_lines = []
                 
-                # Consume multi-line signatures
+                # Consume multi-line signatures by tracking open parentheses/brackets
+                open_braces = 0
                 while i < n:
-                    sig_lines.append(lines[i])
-                    if lines[i].rstrip().endswith(":"):
+                    line_to_add = lines[i]
+                    sig_lines.append(line_to_add)
+                    open_braces += line_to_add.count('(') - line_to_add.count(')')
+                    open_braces += line_to_add.count('[') - line_to_add.count(']')
+                    open_braces += line_to_add.count('{') - line_to_add.count('}')
+                    
+                    if open_braces <= 0 and ":" in line_to_add:
                         break
                     i += 1
                     
@@ -360,15 +366,18 @@ class SkeletonExtractor:
                     is_func = True
                 elif any(x in prefix_str for x in ('fn ', 'func ')):
                     is_func = True
-                elif prefix_str.endswith(')'):
-                    words = [w for w in prefix_str.split() if w]
-                    clean_words = [w for w in words if w not in (
-                        'export', 'async', 'default', 'public', 'private', 'protected', 'static', 'readonly'
-                    )]
-                    if clean_words:
-                        first_word = clean_words[0].split('(')[0].strip()
-                        if first_word not in ('if', 'for', 'while', 'switch', 'catch'):
-                            is_func = True
+                elif '(' in prefix_str and ')' in prefix_str:
+                    first_paren = prefix_str.find('(')
+                    name_part = prefix_str[:first_paren].strip()
+                    words = name_part.split()
+                    if words:
+                        clean_words = [w for w in words if w not in (
+                            'export', 'async', 'default', 'public', 'private', 'protected', 'static', 'readonly'
+                        )]
+                        if clean_words:
+                            first_word = clean_words[0].strip()
+                            if first_word not in ('if', 'for', 'while', 'switch', 'catch'):
+                                is_func = True
                             
                 if is_func:
                     skip_until_brace_depth = brace_depth

{ai_pack_cli-0.1.1 → ai_pack_cli-0.1.2}/ai_pack_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ai-pack-cli
-Version: 0.1.1
+Version: 0.1.2
 Home-page: https://github.com/iamraydoan/ai-pack
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License

{ai_pack_cli-0.1.1 → ai_pack_cli-0.1.2}/ai_pack_cli.egg-info/SOURCES.txt

@@ -6,4 +6,8 @@ ai_pack_cli.egg-info/SOURCES.txt
 ai_pack_cli.egg-info/dependency_links.txt
 ai_pack_cli.egg-info/entry_points.txt
 ai_pack_cli.egg-info/requires.txt
-ai_pack_cli.egg-info/top_level.txt
+ai_pack_cli.egg-info/top_level.txt
+tests/test_binary.py
+tests/test_gitignore.py
+tests/test_skeleton_braces.py
+tests/test_skeleton_python.py

{ai_pack_cli-0.1.1 → ai_pack_cli-0.1.2}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="ai-pack-cli",
-    version="0.1.1",
+    version="0.1.2",
     py_modules=["ai_pack"],
     install_requires=[
         "pyperclip>=1.8.2",

ai_pack_cli-0.1.2/tests/test_binary.py

@@ -0,0 +1,33 @@
+import unittest
+import os
+import tempfile
+import shutil
+from ai_pack import is_binary
+
+class TestBinaryDetection(unittest.TestCase):
+    def setUp(self):
+        self.test_dir = tempfile.mkdtemp()
+
+    def tearDown(self):
+        shutil.rmtree(self.test_dir)
+
+    def test_text_file_is_not_binary(self):
+        file_path = os.path.join(self.test_dir, "text.txt")
+        with open(file_path, "w", encoding="utf-8") as f:
+            f.write("Hello, this is a plain text file with normal characters.")
+        self.assertFalse(is_binary(file_path))
+
+    def test_empty_file_is_not_binary(self):
+        file_path = os.path.join(self.test_dir, "empty.txt")
+        with open(file_path, "w") as f:
+            f.write("")
+        self.assertFalse(is_binary(file_path))
+
+    def test_binary_file_with_null_byte_is_binary(self):
+        file_path = os.path.join(self.test_dir, "binary.bin")
+        with open(file_path, "wb") as f:
+            f.write(b"PNG\x00\x00\x00\r\nIHDR")
+        self.assertTrue(is_binary(file_path))
+
+    def test_missing_file_is_treated_as_binary(self):
+        self.assertTrue(is_binary(os.path.join(self.test_dir, "does_not_exist.bin")))

ai_pack_cli-0.1.2/tests/test_gitignore.py

@@ -0,0 +1,38 @@
+import unittest
+import os
+import tempfile
+import shutil
+from ai_pack import GitignoreMatcher
+
+class TestGitignoreMatcher(unittest.TestCase):
+    def setUp(self):
+        self.test_dir = tempfile.mkdtemp()
+        
+    def tearDown(self):
+        shutil.rmtree(self.test_dir)
+
+    def test_standard_ignores(self):
+        matcher = GitignoreMatcher(self.test_dir)
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, "node_modules", "lodash", "index.js")))
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, "src", "__pycache__", "utils.cpython-38.pyc")))
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, ".git", "config")))
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, "venv", "lib", "python3.8", "site-packages")))
+
+    def test_matching_wildcard_patterns(self):
+        with open(os.path.join(self.test_dir, ".gitignore"), "w") as f:
+            f.write("*.log\ntemp*\n")
+        matcher = GitignoreMatcher(self.test_dir)
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, "error.log")))
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, "sub", "output.log")))
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, "temp_data.csv")))
+        self.assertFalse(matcher.is_ignored(os.path.join(self.test_dir, "item_temp.txt")))
+
+    def test_absolute_vs_relative_gitignore_paths(self):
+        with open(os.path.join(self.test_dir, ".gitignore"), "w") as f:
+            f.write("/root_only.txt\nsub/ignored.txt\n")
+        matcher = GitignoreMatcher(self.test_dir)
+        
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, "root_only.txt")))
+        self.assertFalse(matcher.is_ignored(os.path.join(self.test_dir, "nested", "root_only.txt")))
+        
+        self.assertTrue(matcher.is_ignored(os.path.join(self.test_dir, "sub", "ignored.txt")))

ai_pack_cli-0.1.2/tests/test_skeleton_braces.py

@@ -0,0 +1,139 @@
+import unittest
+from ai_pack import SkeletonExtractor
+
+class TestBraceSkeletonExtractor(unittest.TestCase):
+    def test_javascript_typescript(self):
+        js_code = """import { component } from 'framework';
+const PORT = 8080;
+
+export default class Widget extends Base {
+    constructor(config) {
+        super(config);
+        this.init();
+    }
+
+    render() {
+        return `<div>${this.config.title}</div>`;
+    }
+}
+
+const add = (a, b) => {
+    return a + b;
+};
+"""
+        expected = """import { component } from 'framework';
+const PORT = 8080;
+
+export default class Widget extends Base {
+    constructor(config)  { /* ... */ }
+
+    render()  { /* ... */ }
+}
+
+const add = (a, b) =>  { /* ... */ };"""
+        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(js_code).strip(), expected.strip())
+
+    def test_js_template_literals_with_braces(self):
+        js_code = """const render = (name) => {
+    return `Hello, ${name}! Your age is ${getAge({birth: 1990})}.`;
+};
+"""
+        expected = """const render = (name) =>  { /* ... */ };"""
+        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(js_code).strip(), expected.strip())
+
+    def test_golang_parser(self):
+        go_code = """package main
+import "fmt"
+
+type Server struct {
+    Port int
+}
+
+func NewServer(port int) *Server {
+    return &Server{Port: port}
+}
+
+func (s *Server) Start() error {
+    fmt.Println("Starting...")
+    return nil
+}
+"""
+        expected = """package main
+import "fmt"
+
+type Server struct {
+    Port int
+}
+
+func NewServer(port int) *Server  { /* ... */ }
+
+func (s *Server) Start() error  { /* ... */ }"""
+        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(go_code).strip(), expected.strip())
+
+    def test_rust_parser(self):
+        rust_code = """use std::io;
+
+pub struct Robot {
+    name: String,
+}
+
+impl Robot {
+    pub fn new(name: &str) -> Self {
+        Robot {
+            name: name.to_string(),
+        }
+    }
+
+    fn speak(&self) {
+        println!("Hello, my name is {}", self.name);
+    }
+}
+"""
+        expected = """use std::io;
+
+pub struct Robot {
+    name: String,
+}
+
+impl Robot {
+    pub fn new(name: &str) -> Self  { /* ... */ }
+
+    fn speak(&self)  { /* ... */ }
+}"""
+        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(rust_code).strip(), expected.strip())
+
+    def test_cpp_java_parser(self):
+        java_code = """public class App {
+    public static void main(String[] args) {
+        System.out.println("Hello World!");
+    }
+    
+    private int calc(int a) {
+        return a * 2;
+    }
+}
+"""
+        expected = """public class App {
+    public static void main(String[] args)  { /* ... */ }
+    
+    private int calc(int a)  { /* ... */ }
+}"""
+        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(java_code).strip(), expected.strip())
+
+    def test_typescript_return_types(self):
+        ts_code = """class Manager {
+    async getItems(req: Request): Promise<Item[]> {
+        return this.client.get();
+    }
+    
+    add(a: number, b: number): number {
+        return a + b;
+    }
+}
+"""
+        expected = """class Manager {
+    async getItems(req: Request): Promise<Item[]>  { /* ... */ }
+    
+    add(a: number, b: number): number  { /* ... */ }
+}"""
+        self.assertEqual(SkeletonExtractor.extract_brace_skeleton(ts_code).strip(), expected.strip())

ai_pack_cli-0.1.2/tests/test_skeleton_python.py

@@ -0,0 +1,63 @@
+import unittest
+from ai_pack import SkeletonExtractor
+
+class TestPythonSkeletonExtractor(unittest.TestCase):
+    def test_basic_functions_and_classes(self):
+        code = """class User:
+    def __init__(self, name):
+        self.name = name
+    def greet(self):
+        print("Hello " + self.name)
+"""
+        expected = """class User:
+    def __init__(self, name):
+        ...
+    def greet(self):
+        ..."""
+        self.assertEqual(SkeletonExtractor.extract_python_skeleton(code).strip(), expected.strip())
+
+    def test_decorators_and_async(self):
+        code = """@property
+@cache
+def value(self):
+    return self._val
+
+async def fetch_data(url):
+    res = await client.get(url)
+    return res.json()
+"""
+        expected = """@property
+@cache
+def value(self):
+    ...
+async def fetch_data(url):
+    ..."""
+        self.assertEqual(SkeletonExtractor.extract_python_skeleton(code).strip(), expected.strip())
+
+    def test_multiline_signatures(self):
+        code = """def complex_function(
+    a: int,
+    b: str,
+    c: float = 1.0
+) -> bool:
+    print(a, b, c)
+    return True
+"""
+        expected = """def complex_function(
+    a: int,
+    b: str,
+    c: float = 1.0
+) -> bool:
+    ..."""
+        self.assertEqual(SkeletonExtractor.extract_python_skeleton(code).strip(), expected.strip())
+
+    def test_single_line_and_comments(self):
+        code = """def simple_get(self): return self.x
+
+def comment_sig(a, b): # basic add
+    return a + b
+"""
+        expected = """def simple_get(self): return self.x
+def comment_sig(a, b): # basic add
+    ..."""
+        self.assertEqual(SkeletonExtractor.extract_python_skeleton(code).strip(), expected.strip())