@thegitai/cli 1.0.0-beta.1 → 1.0.0-beta.10

package/dist/src/client-environment.js

@@ -0,0 +1,127 @@
+import { accessSync, constants, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const PACKAGE_MANAGER_CANDIDATES = [
+    'apt',
+    'apt-get',
+    'dnf',
+    'yum',
+    'pacman',
+    'zypper',
+    'apk',
+    'brew',
+    'nix',
+    'snap',
+    'flatpak',
+    'winget',
+    'choco',
+    'scoop',
+];
+function detectShell(platform, env) {
+    if (platform === 'win32') {
+        const comspec = env.COMSPEC;
+        return comspec ? path.win32.basename(comspec) : 'unknown';
+    }
+    const shell = env.SHELL;
+    return shell ? path.basename(shell) : 'unknown';
+}
+function unquoteOsReleaseValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const quote = trimmed[0];
+    if ((quote !== '"' && quote !== "'") || trimmed.at(-1) !== quote) {
+        return trimmed;
+    }
+    return trimmed
+        .slice(1, -1)
+        .replace(/\\(["'`$\\])/g, '$1')
+        .trim();
+}
+export function parseLinuxOsRelease(text) {
+    const values = {};
+    for (const line of text.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const index = trimmed.indexOf('=');
+        if (index <= 0)
+            continue;
+        const key = trimmed.slice(0, index);
+        const value = unquoteOsReleaseValue(trimmed.slice(index + 1));
+        values[key] = value;
+    }
+    return {
+        distroId: values.ID,
+        distroName: values.PRETTY_NAME ?? values.NAME,
+        distroVersion: values.VERSION_ID ?? values.VERSION,
+    };
+}
+function readLinuxOsReleaseText(options) {
+    if ('osReleaseText' in options) {
+        return options.osReleaseText ?? '';
+    }
+    try {
+        return readFileSync('/etc/os-release', 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function pathEnv(env) {
+    return env.PATH ?? env.Path ?? env.path ?? '';
+}
+function windowsExecutableNames(command, env) {
+    if (path.extname(command))
+        return [command];
+    const extensions = (env.PATHEXT ?? '.COM;.EXE;.BAT;.CMD')
+        .split(';')
+        .map((extension) => extension.trim())
+        .filter(Boolean);
+    return [command, ...extensions.map((extension) => `${command}${extension}`)];
+}
+function defaultExecutableExists(command, env, platform) {
+    const searchPath = pathEnv(env);
+    if (!searchPath)
+        return false;
+    const names = platform === 'win32' ? windowsExecutableNames(command, env) : [command];
+    for (const dir of searchPath.split(path.delimiter)) {
+        if (!dir.trim())
+            continue;
+        for (const name of names) {
+            try {
+                accessSync(path.join(dir, name), constants.X_OK);
+                return true;
+            }
+            catch {
+                try {
+                    accessSync(path.join(dir, name));
+                    return platform === 'win32';
+                }
+                catch {
+                    continue;
+                }
+            }
+        }
+    }
+    return false;
+}
+function detectPackageManagers(env, platform, executableExists) {
+    return PACKAGE_MANAGER_CANDIDATES.filter((command) => executableExists(command, env, platform));
+}
+export function collectClientEnvironment(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const executableExists = options.executableExists ?? defaultExecutableExists;
+    const linuxDistro = platform === 'linux'
+        ? parseLinuxOsRelease(readLinuxOsReleaseText(options))
+        : {};
+    return {
+        platform,
+        arch: options.arch ?? process.arch,
+        release: options.release ?? os.release(),
+        shell: detectShell(platform, env),
+        ...linuxDistro,
+        packageManagers: detectPackageManagers(env, platform, executableExists),
+    };
+}

package/dist/src/colors.js

@@ -0,0 +1,59 @@
+// Dependency-free ANSI styler with a chalk-compatible surface, imported as
+// `chalk` at call sites. Color gating (NO_COLOR / FORCE_COLOR / non-TTY) lives
+// in colorEnabled() below.
+const STYLE_NAMES = ['bold', 'dim', 'red', 'green', 'yellow', 'cyan'];
+// SGR open/close codes. Bold and dim share the 22 reset; colors share 39, so a
+// nested inner style restores exactly its own attribute without clearing the
+// outer one.
+const OPEN = {
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+};
+const CLOSE = {
+    bold: '\x1b[22m',
+    dim: '\x1b[22m',
+    red: '\x1b[39m',
+    green: '\x1b[39m',
+    yellow: '\x1b[39m',
+    cyan: '\x1b[39m',
+};
+function colorEnabled() {
+    const force = process.env.FORCE_COLOR;
+    if (force !== undefined)
+        return force !== '0' && force !== 'false';
+    if (process.env.NO_COLOR !== undefined && process.env.NO_COLOR !== '') {
+        return false;
+    }
+    return Boolean(process.stdout.isTTY);
+}
+function applyStyle(name, text) {
+    const open = OPEN[name];
+    const close = CLOSE[name];
+    // Re-open this style after any inner close of the same code, so a nested
+    // style (e.g. chalk.red(`a ${chalk.bold('b')} c`)) doesn't terminate it early.
+    const body = text.includes(close) ? text.split(close).join(close + open) : text;
+    return open + body + close;
+}
+function createStyler(styles) {
+    const fn = ((text) => {
+        const value = String(text);
+        if (!colorEnabled() || styles.length === 0)
+            return value;
+        // Apply right-to-left so the first style in the chain is outermost.
+        return styles.reduceRight((acc, name) => applyStyle(name, acc), value);
+    });
+    for (const name of STYLE_NAMES) {
+        Object.defineProperty(fn, name, {
+            configurable: true,
+            enumerable: false,
+            get: () => createStyler([...styles, name]),
+        });
+    }
+    return fn;
+}
+const colors = createStyler([]);
+export default colors;

package/dist/src/core/clipboard.js

@@ -21,6 +21,14 @@ export function isSupportedImageMimeType(mime) {
 }
 function whichSync(cmd) {
     try {
+        if (process.platform === 'win32') {
+            execFileSync('where.exe', [cmd], {
+                stdio: 'ignore',
+                timeout: 2000,
+                windowsHide: true,
+            });
+            return true;
+        }
         execFileSync('which', [cmd], { stdio: 'ignore', timeout: 2000 });
         return true;
     }
@@ -93,6 +101,52 @@ function readClipboardLinux() {
     }
     throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
 }
+const WINDOWS_CLIPBOARD_IMAGE_PS = [
+    '[Console]::OutputEncoding = [System.Text.Encoding]::UTF8;',
+    '$ErrorActionPreference = "Stop";',
+    'Add-Type -AssemblyName System.Drawing;',
+    '$img = Get-Clipboard -Format Image;',
+    'if ($null -eq $img) { exit 2 }',
+    '$ms = New-Object System.IO.MemoryStream;',
+    '$img.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png);',
+    '[Convert]::ToBase64String($ms.ToArray())',
+].join(' ');
+function readClipboardWindows() {
+    try {
+        const b64 = execFileSync('powershell.exe', ['-NoProfile', '-Command', WINDOWS_CLIPBOARD_IMAGE_PS], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            maxBuffer: MAX_IMAGE_SIZE_BYTES * 2,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+        }).trim();
+        if (!b64) {
+            throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
+        }
+        const buf = Buffer.from(b64, 'base64');
+        if (!buf.length) {
+            throw new ClipboardError('Clipboard contains no image data.', 'NO_IMAGE');
+        }
+        if (buf.length > MAX_IMAGE_SIZE_BYTES) {
+            throw new ClipboardError('Clipboard image exceeds 10MB size limit.', 'READ_FAILED');
+        }
+        return { base64Data: b64, mimeType: 'image/png' };
+    }
+    catch (err) {
+        if (err instanceof ClipboardError)
+            throw err;
+        if (err?.status === 2) {
+            throw new ClipboardError('Clipboard contains no image data. Copy an image first (Win+Shift+S), then press Alt+V.', 'NO_IMAGE');
+        }
+        if (isMaxBufferError(err)) {
+            throw new ClipboardError('Clipboard image exceeds 10MB size limit.', 'READ_FAILED');
+        }
+        const detail = [err?.message, err?.stderr?.toString?.()?.trim()]
+            .filter(Boolean)
+            .join(' — ');
+        throw new ClipboardError(`Failed to read clipboard image on Windows: ${detail || 'unknown error'}`, 'READ_FAILED');
+    }
+}
 function readClipboardDarwin() {
     if (whichSync('pngpaste')) {
         try {
@@ -123,6 +177,8 @@ export function readClipboardImage(platform = process.platform) {
             return readClipboardLinux();
         case 'darwin':
             return readClipboardDarwin();
+        case 'win32':
+            return readClipboardWindows();
         default:
             throw new ClipboardError(`Clipboard image paste is not supported on ${platform}.`, 'NO_TOOL');
     }

package/dist/src/edit-journal.js

@@ -1,33 +1,64 @@
 import { execFileSync } from 'node:child_process';
 import { createHash } from 'node:crypto';
 import { existsSync, lstatSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import { BINARY_ARTIFACT_EXTENSIONS } from './artifact-policy.js';
 import { resolveProjectPath } from './patcher.js';
 export const MAX_EDIT_JOURNAL_RECORDS = 50;
-const MAX_STORED_CONTENT_CHARS = 1_000_000;
-export function hashContent(content) {
+const MAX_STORED_CONTENT_CHARS = 8_000_000;
+export function hashBytes(content) {
     return `sha256:${createHash('sha256').update(content).digest('hex')}`;
 }
+export function hashContent(content) {
+    return hashBytes(Buffer.from(content, 'utf8'));
+}
+export function hashStoredContent(content, encoding = 'utf8') {
+    return encoding === 'base64'
+        ? hashBytes(Buffer.from(content, 'base64'))
+        : hashContent(content);
+}
+export function storedContentBuffer(content, encoding = 'utf8') {
+    return encoding === 'base64'
+        ? Buffer.from(content, 'base64')
+        : Buffer.from(content, 'utf8');
+}
+function snapshotEncoding(filePath, content) {
+    const ext = path.extname(filePath).toLowerCase();
+    if (BINARY_ARTIFACT_EXTENSIONS.has(ext))
+        return 'base64';
+    if (content.includes(0))
+        return 'base64';
+    return 'utf8';
+}
 export function readFileEditSnapshot(rootDir, filePath) {
     try {
         const absPath = resolveProjectPath(rootDir, filePath);
         if (!existsSync(absPath)) {
-            return { exists: false, content: null, hash: null };
+            return { exists: false, content: null, contentEncoding: 'utf8', hash: null };
         }
         if (lstatSync(absPath).isSymbolicLink()) {
             return {
                 exists: true,
                 content: null,
+                contentEncoding: 'utf8',
                 hash: null,
                 error: `Refusing to snapshot symbolic link: ${filePath}`,
             };
         }
-        const content = readFileSync(absPath, 'utf-8');
-        return { exists: true, content, hash: hashContent(content) };
+        const content = readFileSync(absPath);
+        const encoding = snapshotEncoding(filePath, content);
+        return {
+            exists: true,
+            content: encoding === 'base64' ? content.toString('base64') : content.toString('utf8'),
+            contentEncoding: encoding,
+            hash: hashBytes(content),
+        };
     }
     catch (err) {
         return {
             exists: false,
             content: null,
+            contentEncoding: 'utf8',
             hash: null,
             error: err?.message ? String(err.message) : String(err),
         };
@@ -46,7 +77,8 @@ export function isEditToolName(toolName) {
     return (toolName === 'write_file' ||
         toolName === 'patch_file' ||
         toolName === 'str_replace' ||
-        toolName === 'delete_file');
+        toolName === 'delete_file' ||
+        toolName === 'replace_document_text');
 }
 export function operationFromSnapshots(before, after) {
     if (before.hash === after.hash)
@@ -102,6 +134,7 @@ export function normalizeAssistantEditJournal(value) {
                 ? entry.afterHash
                 : null,
             beforeContent: typeof entry.beforeContent === 'string' ? entry.beforeContent : null,
+            beforeContentEncoding: entry.beforeContentEncoding === 'base64' ? 'base64' : 'utf8',
             createdAt: typeof entry.createdAt === 'string' && entry.createdAt
                 ? entry.createdAt
                 : new Date().toISOString(),

package/dist/src/executor.js

@@ -1,11 +1,28 @@
-import chalk from 'chalk';
-import * as pty from '@homebridge/node-pty-prebuilt-multiarch';
+import chalk from './colors.js';
 import { execFileSync, spawn } from 'child_process';
 import { existsSync, statSync } from 'fs';
+import { createRequire } from 'node:module';
 import os from 'os';
 import path from 'path';
 import { ARTIFACT_INSPECT_BLOCK_DIRS, getBlockedArtifactInspectDir, relativeProjectPath, } from './artifact-policy.js';
 import { emitCommandOutput, isTuiMode } from './runtime-mode.js';
+const requireFromHere = createRequire(import.meta.url);
+let nodePtyCache;
+// @lydell/node-pty ships its native binding as platform-specific optional
+// packages. If none is installed for this OS/arch the require throws; we cache
+// the failure and fall back to the non-interactive child_process path. A pty is
+// only needed to answer interactive sudo prompts.
+function loadNodePty() {
+    if (nodePtyCache !== undefined)
+        return nodePtyCache;
+    try {
+        nodePtyCache = requireFromHere('@lydell/node-pty');
+    }
+    catch {
+        nodePtyCache = null;
+    }
+    return nodePtyCache;
+}
 const COMMON_TOOLCHAIN_BIN_DIRS = ['/usr/local/go/bin'];
 function detectVenvBin(dir) {
     for (const name of ['.venv', 'venv', 'env']) {
@@ -607,7 +624,7 @@ function buildCommandEnv(cwd) {
 function sanitizePtyOutput(command, output, cwd, secrets) {
     return sanitizeCommandText(command, stripSudoPromptText(redactSecrets(output, secrets)), cwd);
 }
-async function runPtyCommand(command, cwd, effectiveTimeout, exploratory, requestSudoPassword) {
+async function runPtyCommand(command, cwd, effectiveTimeout, exploratory, requestSudoPassword, nodePty) {
     return new Promise((resolve) => {
         let output = '';
         let timedOut = false;
@@ -623,7 +640,7 @@ async function runPtyCommand(command, cwd, effectiveTimeout, exploratory, reques
         const args = process.platform === 'win32'
             ? ['/d', '/s', '/c', command]
             : ['-lc', command];
-        const child = pty.spawn(shell, args, {
+        const child = nodePty.spawn(shell, args, {
             cols: 120,
             rows: 30,
             cwd,
@@ -776,7 +793,13 @@ export async function runCommand(command, cwd, { requestSudoPassword, timeout, }
     }
     const exploratory = isExploratoryCommand(command);
     if (requestSudoPassword && commandUsesSudo(command)) {
-        return runPtyCommand(command, cwd, effectiveTimeout, exploratory, requestSudoPassword);
+        const nodePty = loadNodePty();
+        if (nodePty) {
+            return runPtyCommand(command, cwd, effectiveTimeout, exploratory, requestSudoPassword, nodePty);
+        }
+        // No pty binding installed for this platform — fall through to the
+        // non-interactive spawn path. The command still runs; an interactive sudo
+        // prompt simply can't be answered here.
     }
     return new Promise((resolve) => {
         let stdout = '';

package/dist/src/help-text.js

@@ -1,4 +1,5 @@
-import chalk from 'chalk';
+import chalk from './colors.js';
+import { getCliVersion, getPlatformTag } from './version.js';
 // The bound keys (Enter/Esc/Ctrl+C/Tab/arrows) are identical across platforms in
 // a terminal. The one thing that genuinely differs is the terminal's paste
 // shortcut, so surface the one for the host OS (right-click paste works
@@ -45,6 +46,7 @@ const HELP_MARKDOWN = [
     '',
     '- `-y, --yes` — start in Auto-Accept mode',
     '- `-h, --help` — show this help',
+    '- `-v, --version` — print the version and exit',
     '',
     '## Modes',
     '',
@@ -70,6 +72,7 @@ const HELP_MARKDOWN = [
     '## Chat commands',
     '',
     '- `/help` — show this help',
+    '- `/about` — show version and platform info',
     '- `/usage` — show account usage percentage and reset times',
     '- `/model` — list supported models and pick one',
     '- `/model <id>` — switch the active model without clearing history',
@@ -100,6 +103,17 @@ const HELP_MARKDOWN = [
     '- For anything else, re-run the command and report the printed error',
     '  message — there is no client-side debug mode by design.',
 ].join('\n');
+export function formatAboutCard() {
+    // Fenced so the column alignment survives terminal markdown rendering.
+    return [
+        '```',
+        'TheGitAI',
+        `  Version   ${getCliVersion()}`,
+        `  Platform  ${getPlatformTag()}`,
+        `  Node      ${process.version}`,
+        '```',
+    ].join('\n');
+}
 export function formatHelpMarkdown() {
     return HELP_MARKDOWN;
 }

package/dist/src/markdown-renderer.js

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from './colors.js';
 function renderInline(text) {
     const parts = String(text ?? '').split(/(`[^`]+`)/g);
     return parts

package/dist/src/patcher.js

@@ -1,4 +1,4 @@
-import chalk from 'chalk';
+import chalk from './colors.js';
 import { existsSync, lstatSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from 'fs';
 import path from 'path';
 import { createInterface } from 'readline';
@@ -169,6 +169,23 @@ export function writeProjectFile(rootDir, filePath, content) {
     writeFileSync(absPath, content, 'utf-8');
     return { absPath, changed: true };
 }
+export function writeProjectFileBuffer(rootDir, filePath, content) {
+    const absPath = resolveProjectPath(rootDir, filePath);
+    if (existsSync(absPath)) {
+        try {
+            const existingContent = readFileSync(absPath);
+            if (existingContent.equals(content)) {
+                return { absPath, changed: false };
+            }
+        }
+        catch {
+            // If we can't read it for some reason, proceed with write
+        }
+    }
+    mkdirSync(path.dirname(absPath), { recursive: true });
+    writeFileSync(absPath, content);
+    return { absPath, changed: true };
+}
 export function deleteProjectFile(rootDir, filePath) {
     const absPath = resolveProjectPath(rootDir, filePath);
     if (!existsSync(absPath)) {

package/dist/src/scanner.js

@@ -1,14 +1,12 @@
 import { execSync } from 'child_process';
-import { readFileSync, statSync } from 'fs';
-import { glob } from 'glob';
+import { readdirSync, readFileSync, statSync } from 'fs';
 import path from 'path';
 import { getNodePrimarySignature, getStructuralChildren, parseRepoSource, } from './tree-sitter-runtime.js';
-import { ARTIFACT_FALLBACK_IGNORE_GLOBS, ARTIFACT_IGNORE_DIRS, ARTIFACT_IGNORE_FILES, ARTIFACT_INSPECT_BLOCK_DIRS, BINARY_ARTIFACT_EXTENSIONS, isSensitiveProjectPath, shouldIgnoreArtifactPath, } from './artifact-policy.js';
+import { ARTIFACT_IGNORE_DIRS, ARTIFACT_IGNORE_FILES, ARTIFACT_INSPECT_BLOCK_DIRS, BINARY_ARTIFACT_EXTENSIONS, isSensitiveProjectPath, shouldIgnoreArtifactPath, } from './artifact-policy.js';
 const BINARY_EXTENSIONS = BINARY_ARTIFACT_EXTENSIONS;
 const ALWAYS_IGNORE_FILES = ARTIFACT_IGNORE_FILES;
 export const ALWAYS_IGNORE_DIRS = ARTIFACT_IGNORE_DIRS;
 export const BLOCKED_PATH_INSPECT_DIRS = ARTIFACT_INSPECT_BLOCK_DIRS;
-const FALLBACK_IGNORE = ARTIFACT_FALLBACK_IGNORE_GLOBS;
 export const SCANNER_MAX_SOURCE_FILE_BYTES = 100 * 1024;
 const MAX_FILE_SIZE = SCANNER_MAX_SOURCE_FILE_BYTES;
 const MAX_CHUNKS = 2000;
@@ -16,26 +14,78 @@ const TARGET_CHUNK_CHARS = 1800;
 const MAX_CHUNK_CHARS = 2800;
 const FALLBACK_OVERLAP_LINES = 10;
 const MAX_STRUCTURE_DEPTH = 2;
+function parseGitLsFilesOutput(output) {
+    return String(output)
+        .split('\0')
+        .filter(Boolean)
+        .filter((filePath) => !shouldIgnorePath(filePath));
+}
 function getFiles(rootDir, { limit = Infinity } = {}) {
     try {
-        const output = execSync('git ls-files --cached --others --exclude-standard', { cwd: rootDir, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'pipe'] });
-        const files = output
-            .split('\n')
-            .filter(Boolean)
-            .filter((filePath) => !shouldIgnorePath(filePath));
+        const output = execSync('git ls-files -z --cached --others --exclude-standard', { cwd: rootDir, stdio: ['pipe', 'pipe', 'pipe'] });
+        const files = parseGitLsFilesOutput(output);
         return Number.isFinite(limit) ? files.slice(0, limit) : files;
     }
     catch {
-        return glob
-            .sync('**/*', {
-            cwd: rootDir,
-            nodir: true,
-            dot: false,
-            ignore: FALLBACK_IGNORE,
-        })
-            .slice(0, Number.isFinite(limit) ? limit : undefined);
+        return walkProjectFilesFallback(rootDir, Number.isFinite(limit) ? limit : Infinity);
     }
 }
+const FALLBACK_LOCKFILES = new Set([
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+]);
+function isFallbackIgnoredFile(relPath, fileName) {
+    if (shouldIgnorePath(relPath))
+        return true;
+    if (fileName.endsWith('.lock'))
+        return true;
+    return FALLBACK_LOCKFILES.has(fileName);
+}
+// Local stand-in for the previous glob('**/*', { nodir: true, dot: false,
+// ignore: FALLBACK_IGNORE }) call, used only when `git ls-files` fails (e.g. a
+// non-git directory). Walks the tree depth-first, skips dotfiles and
+// dot-directories (glob's dot: false), prunes ignored artifact dirs, and drops
+// lockfiles plus sensitive/ignored paths — reproducing the old fallback without
+// the glob dependency.
+function walkProjectFilesFallback(rootDir, limit) {
+    const results = [];
+    const visit = (relDir) => {
+        if (results.length >= limit)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(path.join(rootDir, relDir), {
+                withFileTypes: true,
+            });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (results.length >= limit)
+                return;
+            const name = entry.name;
+            if (name.startsWith('.'))
+                continue;
+            const relPath = relDir ? `${relDir}/${name}` : name;
+            if (entry.isDirectory()) {
+                // Only the prefix-based artifact rule is safe to prune a directory by;
+                // the sensitive-basename check must stay at the file level so a dir
+                // merely named e.g. `secret` doesn't hide non-sensitive files under it.
+                if (ALWAYS_IGNORE_DIRS.has(name) || shouldIgnoreArtifactPath(relPath)) {
+                    continue;
+                }
+                visit(relPath);
+            }
+            else if (entry.isFile() && !isFallbackIgnoredFile(relPath, name)) {
+                results.push(relPath);
+            }
+        }
+    };
+    visit('');
+    return results;
+}
 function shouldSkipFile(relPath, stat) {
     if (shouldIgnorePath(relPath))
         return true;