diff --git a/README.md b/README.md
index 5997dc6..d3094f7 100644
--- a/README.md
+++ b/README.md
@@ -43,8 +43,8 @@ npx i18n-scan <directory>
 # If installed globally
 i18n-scan <directory>
 
-# Run locally during development
-npm run dev <directory>
+# Run locally during development (note the -- before flags)
+npm run dev <directory> -- [options]
 
 # Run built version locally
 npm start <directory>
@@ -57,16 +57,31 @@ npm start <directory>
 npm run dev ./src
 
 # Scan with custom file extensions
-npm run dev ./src --ext .tsx,.jsx,.ts,.js
+npm run dev ./src -- --ext .tsx,.jsx,.ts,.js
 
 # Scan with custom attributes
-npm run dev ./src --attributes title,alt,placeholder,aria-label
+npm run dev ./src -- --attributes title,alt,placeholder,aria-label
+
+# Filter out non-alphabetic text (symbols, emojis, numbers only)
+npm run dev ./src -- --filter-non-alpha
+
+# Extract from objects, function calls, and schemas
+npm run dev ./src -- --include-literals
+
+# Combine options
+npm run dev ./src -- --filter-non-alpha --truncate 50
+
+# When using npx or installed globally, no -- needed:
+npx i18n-scan ./src --filter-non-alpha --truncate 50
 ```
 
 ### Options
 
 - `-e, --ext <extensions>`: Comma-separated list of file extensions (default: `.tsx,.jsx`)
 - `-a, --attributes <names>`: Comma-separated list of attribute names to extract (default: `title,alt,placeholder`)
+- `-t, --truncate <limit>`: Truncate text to this length, 0 to disable (default: `30`)
+- `-f, --filter-non-alpha`: Filter out text containing only non-alphabetic characters (e.g., `$`, `123`, `🎉`)
+- `-l, --include-literals`: Include string literals from objects, function calls, and validation schemas
 
 ## Example Output
 
@@ -77,6 +92,17 @@ npm run dev ./src --attributes title,alt,placeholder,aria-label
 [src/components/Form.tsx:13] This field is required
 ```
 
+**With `--filter-non-alpha` enabled:**
+
+```
+# Without filter:
+[src/components/ProductCard.tsx:30] $
+[src/components/ProductCard.tsx:33] In Stock
+
+# With filter ($ is filtered out):
+[src/components/ProductCard.tsx:33] In Stock
+```
+
 ## Development
 
 - `npm run dev <directory>`: Run from TypeScript source
@@ -85,6 +111,8 @@ npm run dev ./src --attributes title,alt,placeholder,aria-label
 
 ## What it extracts
 
+### By default (JSX only):
+
 1. **JSX Text Content**: Any text between JSX tags
 
    ```jsx
@@ -99,6 +127,50 @@ npm run dev ./src --attributes title,alt,placeholder,aria-label
    <button title="Close dialog" />        // Extracts: "Close dialog"
    ```
 
+### With `--include-literals` flag:
+
+Extracts additional string literals that are commonly user-facing:
+
+3. **Object Properties**: Strings from objects with keys like `message`, `error`, `label`, `title`, `description`, etc.
+
+   ```typescript
+   const errors = {
+     required: "This field is required", // Extracts
+     invalid: "Invalid email address", // Extracts
+   };
+
+   const config = {
+     className: "btn-primary", // Skips (technical)
+     title: "Welcome back", // Extracts
+     apiUrl: "/api/users", // Skips (technical)
+   };
+   ```
+
+4. **Zod Schema Messages**: Validation messages and descriptions
+
+   ```typescript
+   z.string().email("Invalid email")
+   z.string().min(5, "Too short")
+   z.string().max(100, { message: "Too long"
+   z.string().describe("Your username")
+   ```
+
+5. **Function Calls**: Common user-facing function calls
+
+   ```typescript
+   toast.success("Saved successfully!");
+   toast.error("Failed to save");
+   console.error("Something went wrong");
+   throw new Error("Invalid input");
+   ```
+
+**Smart Filtering**: The tool automatically skips technical strings like:
+
+- Import paths, URLs, API endpoints
+- CSS class names, IDs
+- camelCase identifiers, CONSTANTS
+- Single characters and code patterns
+
 ## Github Repo
 
 https://github.com/hexxt-git/i18n-scan
diff --git a/example/src/App.tsx b/example/src/App.jsx
similarity index 100%
rename from example/src/App.tsx
rename to example/src/App.jsx
diff --git a/example/src/test-literals.tsx b/example/src/test-literals.tsx
new file mode 100644
index 0000000..d2e68a2
--- /dev/null
+++ b/example/src/test-literals.tsx
@@ -0,0 +1,68 @@
+import { z } from "zod";
+
+// Test 1: Object with user-facing strings
+const errorMessages = {
+  required: "This field is required",
+  invalid: "Invalid input provided",
+  tooShort: "Must be at least 5 characters",
+};
+
+const config = {
+  title: "Welcome to our platform",
+  description: "Start your journey today",
+  buttonText: "Get Started Now",
+};
+
+// Test 2: Zod schemas
+const userSchema = z.object({
+  email: z.string().email("Please enter a valid email address"),
+  password: z
+    .string()
+    .min(8, "Password must be at least 8 characters")
+    .max(100, { message: "Password is too long" }),
+  username: z.string().describe("Your unique username"),
+});
+
+const ageSchema = z.number().min(18, "You must be 18 or older");
+
+// Test 3: Toast/Error calls
+function handleSubmit() {
+  toast.success("Form submitted successfully!");
+  toast.error("Failed to submit form");
+  console.error("Something went wrong");
+  console.warn("This action cannot be undone");
+}
+
+// Test 4: Error throwing
+function validateInput(value: string) {
+  if (!value) {
+    throw new Error("Input cannot be empty");
+  }
+  if (value.length < 3) {
+    throw new Error("Input must be at least 3 characters long");
+  }
+}
+
+// Test 5: Should NOT extract (technical strings)
+const technicalStrings = {
+  className: "flex items-center", // Should skip
+  apiUrl: "/api/users", // Should skip
+  method: "POST", // Should skip
+};
+
+// Test 6: Mixed object (should extract some, skip others)
+const mixedConfig = {
+  endpoint: "/api/submit", // Should skip
+  message: "Your data has been saved", // Should extract
+  className: "button-primary", // Should skip
+  label: "Save Changes", // Should extract
+};
+
+export function TestComponent() {
+  return (
+    <div>
+      <h1>Test Component</h1>
+      <p>Regular JSX text should still work</p>
+    </div>
+  );
+}
diff --git a/index.ts b/index.ts
index fe9da62..f3af872 100644
--- a/index.ts
+++ b/index.ts
@@ -31,6 +31,16 @@ program
     "Truncate text to this length, 0 to disable",
     "30"
   )
+  .option(
+    "-f, --filter-non-alpha",
+    "Filter out text containing only non-alphabetic characters",
+    false
+  )
+  .option(
+    "-l, --include-literals",
+    "Include string literals from objects, function calls, and schemas",
+    false
+  )
   .parse();
 
 const dir = path.resolve(program.args[0] as string);
@@ -40,6 +50,77 @@ const attributes = options.attributes
   .split(",")
   .map((attr: string) => attr.trim());
 const truncate = options.truncate ? parseInt(options.truncate) : 0;
+const filterNonAlpha = options.filterNonAlpha || false;
+const includeLiterals = options.includeLiterals || false;
+
+// Keys that typically contain user-facing text
+const USER_FACING_KEYS = new Set([
+  "message",
+  "error",
+  "label",
+  "title",
+  "description",
+  "text",
+  "placeholder",
+  "tooltip",
+  "hint",
+  "content",
+  "name",
+  "displayName",
+]);
+
+// Function/method names that typically contain user-facing text
+const USER_FACING_FUNCTIONS = new Set([
+  "toast",
+  "error",
+  "warn",
+  "message",
+  "alert",
+  "notify",
+  "success",
+  "info",
+]);
+
+// Keys to always skip (technical/code values)
+const SKIP_KEYS = new Set([
+  "className",
+  "class",
+  "id",
+  "key",
+  "ref",
+  "style",
+  "type",
+  "href",
+  "src",
+  "path",
+  "url",
+  "api",
+  "endpoint",
+  "method",
+  "mode",
+  "variant",
+]);
+
+function hasAlphabeticChar(text: string): boolean {
+  return /[a-zA-Z]/.test(text);
+}
+
+function isUserFacingText(text: string): boolean {
+  // Skip empty or very short strings
+  if (!text || text.length < 2) return false;
+
+  // Skip strings that look like code patterns
+  if (/^[a-z][a-zA-Z]*$/.test(text)) return false; // camelCase
+  if (/^[A-Z_]+$/.test(text)) return false; // CONSTANTS
+  if (text.startsWith("/") || text.startsWith("./")) return false; // paths
+  if (text.includes("://")) return false; // URLs
+
+  if (!hasAlphabeticChar(text)) {
+    return filterNonAlpha ? false : true;
+  }
+
+  return true;
+}
 
 function extractTextWithLocation(filePath: string, code: string) {
   const ast = babelParser.parse(code, {
@@ -53,6 +134,10 @@ function extractTextWithLocation(filePath: string, code: string) {
     JSXText(path: any) {
       const text = path.node.value.trim();
       if (text) {
+        // Skip text with only non-alphabetic characters if filter is enabled
+        if (filterNonAlpha && !hasAlphabeticChar(text)) {
+          return;
+        }
         results.push({
           line: path.node.loc?.start.line || 0,
           text,
@@ -68,14 +153,171 @@ function extractTextWithLocation(filePath: string, code: string) {
         value &&
         t.isStringLiteral(value)
       ) {
+        const text = value.value.trim();
+        // Skip text with only non-alphabetic characters if filter is enabled
+        if (filterNonAlpha && !hasAlphabeticChar(text)) {
+          return;
+        }
         results.push({
           line: value.loc?.start.line || 0,
-          text: value.value.trim(),
+          text,
         });
       }
     },
   });
 
+  // Extended extraction for literals (objects, function calls, schemas)
+  if (includeLiterals) {
+    traverse(ast, {
+      // Extract from object properties with user-facing keys
+      ObjectProperty(path: any) {
+        const key = path.node.key;
+        const value = path.node.value;
+
+        // Get the key name
+        let keyName = "";
+        if (t.isIdentifier(key)) {
+          keyName = key.name;
+        } else if (t.isStringLiteral(key)) {
+          keyName = key.value;
+        }
+
+        if (SKIP_KEYS.has(keyName)) return;
+
+        // Check if it's a user-facing key or extract all strings
+        if (USER_FACING_KEYS.has(keyName) || true) {
+          if (t.isStringLiteral(value)) {
+            const text = value.value.trim();
+            if (isUserFacingText(text)) {
+              results.push({
+                line: value.loc?.start.line || 0,
+                text,
+              });
+            }
+          }
+        }
+      },
+
+      NewExpression(path: any) {
+        const callee = path.node.callee;
+        if (t.isIdentifier(callee, { name: "Error" })) {
+          const arg = path.node.arguments[0];
+          if (t.isStringLiteral(arg)) {
+            const text = arg.value.trim();
+            if (isUserFacingText(text)) {
+              results.push({
+                line: arg.loc?.start.line || 0,
+                text,
+              });
+            }
+          }
+        }
+      },
+
+      // Extract from function calls (toast, error, etc.)
+      CallExpression(path: any) {
+        const callee = path.node.callee;
+
+        let functionName = "";
+        if (t.isIdentifier(callee)) {
+          functionName = callee.name;
+        } else if (t.isMemberExpression(callee)) {
+          // Handle toast.error(), console.warn(), etc.
+          if (
+            t.isIdentifier(callee.object) &&
+            t.isIdentifier(callee.property)
+          ) {
+            const obj = callee.object.name;
+            const prop = callee.property.name;
+            functionName = prop;
+
+            // Common patterns
+            if (
+              (obj === "toast" || obj === "console") &&
+              USER_FACING_FUNCTIONS.has(prop)
+            ) {
+              const arg = path.node.arguments[0];
+              if (t.isStringLiteral(arg)) {
+                const text = arg.value.trim();
+                if (isUserFacingText(text)) {
+                  results.push({
+                    line: arg.loc?.start.line || 0,
+                    text,
+                  });
+                }
+              }
+            }
+          }
+          // Handle Zod: .message(), .min(), .max(), etc.
+          if (t.isIdentifier(callee.property)) {
+            const methodName = callee.property.name;
+            if (methodName === "message" || methodName === "describe") {
+              const arg = path.node.arguments[0];
+              if (t.isStringLiteral(arg)) {
+                const text = arg.value.trim();
+                if (isUserFacingText(text)) {
+                  results.push({
+                    line: arg.loc?.start.line || 0,
+                    text,
+                  });
+                }
+              }
+            }
+            // Zod validation with error message as second arg
+            if (
+              ["min", "max", "length", "email", "url", "regex"].includes(
+                methodName
+              )
+            ) {
+              const arg = path.node.arguments[1];
+              if (t.isStringLiteral(arg)) {
+                const text = arg.value.trim();
+                if (isUserFacingText(text)) {
+                  results.push({
+                    line: arg.loc?.start.line || 0,
+                    text,
+                  });
+                }
+              } else if (t.isObjectExpression(arg)) {
+                // .min(5, { message: "..." })
+                const messageProp = arg.properties.find(
+                  (prop: any) =>
+                    t.isObjectProperty(prop) &&
+                    t.isIdentifier(prop.key, { name: "message" })
+                );
+                if (
+                  messageProp &&
+                  t.isStringLiteral((messageProp as any).value)
+                ) {
+                  const text = ((messageProp as any).value as any).value.trim();
+                  if (isUserFacingText(text)) {
+                    results.push({
+                      line:
+                        ((messageProp as any).value as any).loc?.start.line ||
+                        0,
+                      text,
+                    });
+                  }
+                }
+              }
+            }
+          }
+        } else if (USER_FACING_FUNCTIONS.has(functionName)) {
+          const arg = path.node.arguments[0];
+          if (t.isStringLiteral(arg)) {
+            const text = arg.value.trim();
+            if (isUserFacingText(text)) {
+              results.push({
+                line: arg.loc?.start.line || 0,
+                text,
+              });
+            }
+          }
+        }
+      },
+    });
+  }
+
   results.forEach(({ line, text }) => {
     const truncatedText = truncate
       ? text.length > truncate
diff --git a/package-lock.json b/package-lock.json
index ecf2643..daacbca 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "i18n-scan",
-  "version": "1.0.0",
+  "version": "1.1.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "i18n-scan",
-      "version": "1.0.0",
+      "version": "1.1.1",
       "license": "MIT",
       "dependencies": {
         "@babel/parser": "^7.23.0",