gt 2.7.1 → 2.8.0-alpha.0

package/dist/cli/base.js

@@ -31,7 +31,7 @@ import { setupLocadex } from '../locadex/setupFlow.js';
 import { detectFramework } from '../setup/detectFramework.js';
 import { getFrameworkDisplayName, getReactFrameworkLibrary, } from '../setup/frameworkUtils.js';
 import { findAgentFiles, findAgentFilesWithInstructions, hasCursorRulesDir, CURSOR_GT_RULES_FILE, getAgentInstructions, appendAgentInstructions, } from '../setup/agentInstructions.js';
-import { determineLibrary } from '../fs/determineFramework.js';
+import { determineLibrary } from '../fs/determineFramework/index.js';
 import { INLINE_LIBRARIES } from '../types/libraries.js';
 import { handleEnqueue } from './commands/enqueue.js';
 export class BaseCLI {

package/dist/cli/inline.js

@@ -129,6 +129,8 @@ function fallbackToGtReact(library) {
         Libraries.GT_NEXT,
         Libraries.GT_NODE,
         Libraries.GT_REACT_NATIVE,
+        Libraries.GT_FLASK,
+        Libraries.GT_FASTAPI,
     ].includes(library)
         ? library
         : Libraries.GT_REACT;

package/dist/cli/python.d.ts

@@ -0,0 +1,10 @@
+import { Command } from 'commander';
+import { SupportedLibraries } from '../types/index.js';
+import { InlineCLI } from './inline.js';
+import { PythonLibrary } from '../types/libraries.js';
+/**
+ * CLI tool for managing translations with gt-flask and gt-fastapi
+ */
+export declare class PythonCLI extends InlineCLI {
+    constructor(command: Command, library: PythonLibrary, additionalModules?: SupportedLibraries[]);
+}

package/dist/cli/python.js

@@ -0,0 +1,9 @@
+import { InlineCLI } from './inline.js';
+/**
+ * CLI tool for managing translations with gt-flask and gt-fastapi
+ */
+export class PythonCLI extends InlineCLI {
+    constructor(command, library, additionalModules) {
+        super(command, library, additionalModules);
+    }
+}

package/dist/config/generateSettings.d.ts

@@ -1,5 +1,7 @@
 import { Settings } from '../types/index.js';
 export declare const DEFAULT_SRC_PATTERNS: string[];
+export declare const DEFAULT_PYTHON_SRC_PATTERNS: string[];
+export declare const DEFAULT_PYTHON_SRC_EXCLUDES: string[];
 /**
  * Generates settings from any
  * @param flags - The CLI flags to generate settings from

package/dist/config/generateSettings.js

@@ -18,6 +18,16 @@ export const DEFAULT_SRC_PATTERNS = [
     'pages/**/*.{js,jsx,ts,tsx}',
     'components/**/*.{js,jsx,ts,tsx}',
 ];
+export const DEFAULT_PYTHON_SRC_PATTERNS = ['**/*.py'];
+export const DEFAULT_PYTHON_SRC_EXCLUDES = [
+    'venv/**',
+    '.venv/**',
+    '__pycache__/**',
+    '**/migrations/**',
+    '**/tests/**',
+    '**/test_*.py',
+    '**/*_test.py',
+];
 /**
  * Generates settings from any
  * @param flags - The CLI flags to generate settings from
@@ -105,8 +115,8 @@ export async function generateSettings(flags, cwd = process.cwd()) {
     mergedOptions.stageTranslations = mergedOptions.stageTranslations ?? false;
     // Add publish if not provided
     mergedOptions.publish = (gtConfig.publish || flags.publish) ?? false;
-    // Populate src if not provided
-    mergedOptions.src = mergedOptions.src || DEFAULT_SRC_PATTERNS;
+    // Don't default src here — each pipeline (JS/Python) has its own defaults.
+    // Only set src if the user explicitly provided it via flags or config.
     // Resolve all glob patterns in the files object
     const compositePatterns = [
         ...Object.entries(mergedOptions.options?.jsonSchema || {}),

package/dist/extraction/index.d.ts

@@ -0,0 +1,3 @@
+export type { ExtractionResult, ExtractionMetadata } from './types.js';
+export { mapExtractionResultsToUpdates } from './mapToUpdates.js';
+export { calculateHashes, dedupeUpdates, linkStaticUpdates, } from './postProcess.js';

package/dist/extraction/index.js

@@ -0,0 +1,2 @@
+export { mapExtractionResultsToUpdates } from './mapToUpdates.js';
+export { calculateHashes, dedupeUpdates, linkStaticUpdates, } from './postProcess.js';

package/dist/extraction/mapToUpdates.d.ts

@@ -0,0 +1,6 @@
+import type { ExtractionResult } from '@generaltranslation/python-extractor';
+import type { Updates } from '../types/index.js';
+/**
+ * Maps ExtractionResult[] to Updates[] format used by the CLI pipeline
+ */
+export declare function mapExtractionResultsToUpdates(results: ExtractionResult[]): Updates;

package/dist/extraction/mapToUpdates.js

@@ -0,0 +1,20 @@
+/**
+ * Maps ExtractionResult[] to Updates[] format used by the CLI pipeline
+ */
+export function mapExtractionResultsToUpdates(results) {
+    return results.map((result) => ({
+        dataFormat: result.dataFormat,
+        source: result.source,
+        metadata: {
+            ...(result.metadata.id && { id: result.metadata.id }),
+            ...(result.metadata.context && { context: result.metadata.context }),
+            ...(result.metadata.maxChars != null && {
+                maxChars: result.metadata.maxChars,
+            }),
+            ...(result.metadata.filePaths && {
+                filePaths: result.metadata.filePaths,
+            }),
+            ...(result.metadata.staticId && { staticId: result.metadata.staticId }),
+        },
+    }));
+}

package/dist/extraction/postProcess.d.ts

@@ -0,0 +1,14 @@
+import { Updates } from '../types/index.js';
+/**
+ * Calculate hashes for all updates in parallel
+ */
+export declare function calculateHashes(updates: Updates): Promise<void>;
+/**
+ * Dedupe entries by hash, merging filePaths
+ */
+export declare function dedupeUpdates(updates: Updates): void;
+/**
+ * Mark static updates as related by attaching a shared id to static content.
+ * Id is calculated as the hash of the static children's combined hashes.
+ */
+export declare function linkStaticUpdates(updates: Updates): void;

package/dist/extraction/postProcess.js

@@ -0,0 +1,78 @@
+import { hashSource, hashString } from 'generaltranslation/id';
+/**
+ * Calculate hashes for all updates in parallel
+ */
+export async function calculateHashes(updates) {
+    await Promise.all(updates.map(async (update) => {
+        const hash = hashSource({
+            source: update.source,
+            ...(update.metadata.context && { context: update.metadata.context }),
+            ...(update.metadata.id && { id: update.metadata.id }),
+            ...(update.metadata.maxChars != null && {
+                maxChars: update.metadata.maxChars,
+            }),
+            dataFormat: update.dataFormat,
+        });
+        update.metadata.hash = hash;
+    }));
+}
+/**
+ * Dedupe entries by hash, merging filePaths
+ */
+export function dedupeUpdates(updates) {
+    const mergedByHash = new Map();
+    const noHashUpdates = [];
+    for (const update of updates) {
+        const hash = update.metadata.hash;
+        if (!hash) {
+            noHashUpdates.push(update);
+            continue;
+        }
+        const existing = mergedByHash.get(hash);
+        if (!existing) {
+            mergedByHash.set(hash, update);
+            continue;
+        }
+        const existingPaths = Array.isArray(existing.metadata.filePaths)
+            ? existing.metadata.filePaths.slice()
+            : [];
+        const newPaths = Array.isArray(update.metadata.filePaths)
+            ? update.metadata.filePaths
+            : [];
+        for (const p of newPaths) {
+            if (!existingPaths.includes(p)) {
+                existingPaths.push(p);
+            }
+        }
+        if (existingPaths.length) {
+            existing.metadata.filePaths = existingPaths;
+        }
+    }
+    const mergedUpdates = [...mergedByHash.values(), ...noHashUpdates];
+    updates.splice(0, updates.length, ...mergedUpdates);
+}
+/**
+ * Mark static updates as related by attaching a shared id to static content.
+ * Id is calculated as the hash of the static children's combined hashes.
+ */
+export function linkStaticUpdates(updates) {
+    const temporaryStaticIdToUpdates = updates.reduce((acc, update) => {
+        if (update.metadata.staticId) {
+            if (!acc[update.metadata.staticId]) {
+                acc[update.metadata.staticId] = [];
+            }
+            acc[update.metadata.staticId].push(update);
+        }
+        return acc;
+    }, {});
+    Object.values(temporaryStaticIdToUpdates).forEach((staticUpdates) => {
+        const hashes = staticUpdates
+            .map((update) => update.metadata.hash)
+            .sort()
+            .join('-');
+        const sharedStaticId = hashString(hashes);
+        staticUpdates.forEach((update) => {
+            update.metadata.staticId = sharedStaticId;
+        });
+    });
+}

package/dist/extraction/types.d.ts

@@ -0,0 +1 @@
+export type { ExtractionResult, ExtractionMetadata, } from '@generaltranslation/python-extractor';

package/dist/extraction/types.js

@@ -0,0 +1 @@
+export {};

package/dist/formats/files/aggregateFiles.js

@@ -5,7 +5,7 @@ import { SUPPORTED_FILE_EXTENSIONS } from './supportedFiles.js';
 import { parseJson } from '../json/parseJson.js';
 import parseYaml from '../yaml/parseYaml.js';
 import YAML from 'yaml';
-import { determineLibrary } from '../../fs/determineFramework.js';
+import { determineLibrary } from '../../fs/determineFramework/index.js';
 import { hashStringSync } from '../../utils/hash.js';
 import { preprocessContent } from './preprocessContent.js';
 export const SUPPORTED_DATA_FORMATS = ['JSX', 'ICU', 'I18NEXT'];

package/dist/fs/determineFramework/detectPythonLibrary.d.ts

@@ -0,0 +1,6 @@
+import { Libraries } from '../../types/libraries.js';
+/**
+ * Detect Python GT library from pyproject.toml, requirements.txt, or setup.py.
+ * Checks files in priority order: pyproject.toml → requirements.txt → setup.py.
+ */
+export declare function detectPythonLibrary(cwd: string): typeof Libraries.GT_FLASK | typeof Libraries.GT_FASTAPI | null;

package/dist/fs/determineFramework/detectPythonLibrary.js

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { matchPyprojectDependency } from './matchPyprojectDependency.js';
+import { matchRequirementsTxtDependency } from './matchRequirementsTxtDependency.js';
+import { matchSetupPyDependency } from './matchSetupPyDependency.js';
+/**
+ * Detect Python GT library from pyproject.toml, requirements.txt, or setup.py.
+ * Checks files in priority order: pyproject.toml → requirements.txt → setup.py.
+ */
+export function detectPythonLibrary(cwd) {
+    // Check pyproject.toml
+    const pyprojectPath = path.join(cwd, 'pyproject.toml');
+    if (fs.existsSync(pyprojectPath)) {
+        const content = fs.readFileSync(pyprojectPath, 'utf8');
+        const result = matchPyprojectDependency(content);
+        if (result)
+            return result;
+    }
+    // Check requirements.txt
+    const requirementsPath = path.join(cwd, 'requirements.txt');
+    if (fs.existsSync(requirementsPath)) {
+        const content = fs.readFileSync(requirementsPath, 'utf8');
+        const result = matchRequirementsTxtDependency(content);
+        if (result)
+            return result;
+    }
+    // Check setup.py
+    const setupPath = path.join(cwd, 'setup.py');
+    if (fs.existsSync(setupPath)) {
+        const content = fs.readFileSync(setupPath, 'utf8');
+        const result = matchSetupPyDependency(content);
+        if (result)
+            return result;
+    }
+    return null;
+}

package/dist/fs/{determineFramework.d.ts → determineFramework/index.d.ts}

@@ -1,4 +1,4 @@
-import { SupportedLibraries } from '../types/index.js';
+import { SupportedLibraries } from '../../types/index.js';
 export declare function determineLibrary(): {
     library: SupportedLibraries;
     additionalModules: SupportedLibraries[];

package/dist/fs/determineFramework/index.js

@@ -0,0 +1,62 @@
+import chalk from 'chalk';
+import path from 'node:path';
+import fs from 'node:fs';
+import { logger } from '../../console/logger.js';
+import { Libraries } from '../../types/libraries.js';
+import { detectPythonLibrary } from './detectPythonLibrary.js';
+export function determineLibrary() {
+    let library = 'base';
+    const additionalModules = [];
+    try {
+        // Get the current working directory (where the CLI is being run)
+        const cwd = process.cwd();
+        const packageJsonPath = path.join(cwd, 'package.json');
+        // Check if package.json exists
+        if (fs.existsSync(packageJsonPath)) {
+            // Read and parse package.json
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            const dependencies = {
+                ...packageJson.dependencies,
+                ...packageJson.devDependencies,
+            };
+            // Check for gt-next or gt-react in dependencies
+            if (dependencies[Libraries.GT_NEXT]) {
+                library = Libraries.GT_NEXT;
+            }
+            else if (dependencies[Libraries.GT_REACT]) {
+                library = Libraries.GT_REACT;
+            }
+            else if (dependencies[Libraries.GT_REACT_NATIVE]) {
+                library = Libraries.GT_REACT_NATIVE;
+            }
+            else if (dependencies[Libraries.GT_NODE]) {
+                library = Libraries.GT_NODE;
+            }
+            else if (dependencies['next-intl']) {
+                library = 'next-intl';
+            }
+            else if (dependencies['i18next']) {
+                library = 'i18next';
+            }
+            if (dependencies['i18next-icu']) {
+                additionalModules.push('i18next-icu');
+            }
+        }
+        // If no JS library found, check for Python project files
+        if (library === 'base') {
+            const pythonLibrary = detectPythonLibrary(cwd);
+            if (pythonLibrary) {
+                library = pythonLibrary;
+            }
+            else if (!fs.existsSync(path.join(cwd, 'package.json'))) {
+                logger.warn(chalk.yellow('No package.json or Python project file found in the current directory. Run this command from the root of your project.'));
+            }
+        }
+        // Fallback to base if neither is found
+        return { library, additionalModules };
+    }
+    catch (error) {
+        logger.error('Error determining framework: ' + String(error));
+        return { library: 'base', additionalModules: [] };
+    }
+}

package/dist/fs/determineFramework/matchPyprojectDependency.d.ts

@@ -0,0 +1,9 @@
+import { Libraries } from '../../types/libraries.js';
+/**
+ * Parse pyproject.toml for GT dependencies using a proper TOML parser.
+ *
+ * Checks the following locations:
+ * - PEP 621: project.dependencies, project.optional-dependencies.*
+ * - Poetry: tool.poetry.dependencies, tool.poetry.group.*.dependencies
+ */
+export declare function matchPyprojectDependency(content: string): typeof Libraries.GT_FLASK | typeof Libraries.GT_FASTAPI | null;

package/dist/fs/determineFramework/matchPyprojectDependency.js

@@ -0,0 +1,86 @@
+import { parse } from 'smol-toml';
+import { resolveGtDependency } from './resolveGtDependency.js';
+/**
+ * Parse pyproject.toml for GT dependencies using a proper TOML parser.
+ *
+ * Checks the following locations:
+ * - PEP 621: project.dependencies, project.optional-dependencies.*
+ * - Poetry: tool.poetry.dependencies, tool.poetry.group.*.dependencies
+ */
+export function matchPyprojectDependency(content) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    let parsed;
+    try {
+        parsed = parse(content);
+    }
+    catch {
+        return null;
+    }
+    // 1. PEP 621: project.dependencies = ["gt-flask>=1.0", ...]
+    const projectDeps = parsed?.project?.dependencies;
+    if (Array.isArray(projectDeps)) {
+        const result = matchDependencyArray(projectDeps);
+        if (result)
+            return result;
+    }
+    // 2. PEP 621: project.optional-dependencies.* = ["gt-flask", ...]
+    const optDeps = parsed?.project?.['optional-dependencies'];
+    if (optDeps && typeof optDeps === 'object') {
+        for (const group of Object.values(optDeps)) {
+            if (Array.isArray(group)) {
+                const result = matchDependencyArray(group);
+                if (result)
+                    return result;
+            }
+        }
+    }
+    // 3. Poetry: tool.poetry.dependencies = { gt-flask = "^1.0", ... }
+    const poetryDeps = parsed?.tool?.poetry?.dependencies;
+    if (poetryDeps && typeof poetryDeps === 'object') {
+        const result = matchDependencyKeys(poetryDeps);
+        if (result)
+            return result;
+    }
+    // 4. Poetry groups: tool.poetry.group.*.dependencies
+    const poetryGroups = parsed?.tool?.poetry?.group;
+    if (poetryGroups && typeof poetryGroups === 'object') {
+        for (const group of Object.values(poetryGroups)) {
+            if (group && typeof group === 'object' && 'dependencies' in group) {
+                const result = matchDependencyKeys(group.dependencies);
+                if (result)
+                    return result;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check a PEP 508 dependency array (e.g. ["gt-flask>=1.0", "flask[extra]"])
+ * for GT dependencies.
+ */
+function matchDependencyArray(deps) {
+    for (const dep of deps) {
+        if (typeof dep !== 'string')
+            continue;
+        // Extract package name before version specifiers, extras, or markers
+        const pkgName = dep.split(/[><=!~;@\s[]/)[0].trim();
+        if (pkgName) {
+            const result = resolveGtDependency(pkgName);
+            if (result)
+                return result;
+        }
+    }
+    return null;
+}
+/**
+ * Check Poetry-style dependency keys (e.g. { gt-flask = "^1.0" })
+ * for GT dependencies.
+ */
+function matchDependencyKeys(deps) {
+    for (const key of Object.keys(deps)) {
+        const result = resolveGtDependency(key);
+        if (result)
+            return result;
+    }
+    return null;
+}

package/dist/fs/determineFramework/matchRequirementsTxtDependency.d.ts

@@ -0,0 +1,6 @@
+import { Libraries } from '../../types/libraries.js';
+/**
+ * Parse requirements.txt for GT dependencies.
+ * Each line is a package specification: package[extras]>=version
+ */
+export declare function matchRequirementsTxtDependency(content: string): typeof Libraries.GT_FLASK | typeof Libraries.GT_FASTAPI | null;

package/dist/fs/determineFramework/matchRequirementsTxtDependency.js

@@ -0,0 +1,21 @@
+import { resolveGtDependency } from './resolveGtDependency.js';
+/**
+ * Parse requirements.txt for GT dependencies.
+ * Each line is a package specification: package[extras]>=version
+ */
+export function matchRequirementsTxtDependency(content) {
+    const lines = content.split('\n');
+    for (const line of lines) {
+        const trimmed = line.split('#')[0].trim();
+        if (!trimmed || trimmed.startsWith('-'))
+            continue;
+        // Extract package name before version specifiers, extras, or markers
+        const pkgName = trimmed.split(/[><=!~;@\s[]/)[0].trim();
+        if (pkgName) {
+            const result = resolveGtDependency(pkgName);
+            if (result)
+                return result;
+        }
+    }
+    return null;
+}

package/dist/fs/determineFramework/matchSetupPyDependency.d.ts

@@ -0,0 +1,7 @@
+import { Libraries } from '../../types/libraries.js';
+/**
+ * Parse setup.py for GT dependencies.
+ * Extracts quoted strings from install_requires or extras_require blocks
+ * and matches against GT packages.
+ */
+export declare function matchSetupPyDependency(content: string): typeof Libraries.GT_FLASK | typeof Libraries.GT_FASTAPI | null;

package/dist/fs/determineFramework/matchSetupPyDependency.js

@@ -0,0 +1,78 @@
+import { resolveGtDependency } from './resolveGtDependency.js';
+/**
+ * Parse setup.py for GT dependencies.
+ * Extracts quoted strings from install_requires or extras_require blocks
+ * and matches against GT packages.
+ */
+export function matchSetupPyDependency(content) {
+    // Find install_requires=[...] and extras_require={...:[...]} blocks
+    // and extract quoted dependency strings from within them.
+    // We search for the keyword, then collect quoted strings until the
+    // corresponding closing bracket.
+    const dependencyKeywords = ['install_requires', 'extras_require'];
+    for (const keyword of dependencyKeywords) {
+        const keywordIndex = content.indexOf(keyword);
+        if (keywordIndex === -1)
+            continue;
+        // Find the opening bracket after the keyword
+        const afterKeyword = content.slice(keywordIndex + keyword.length);
+        const bracketMatch = afterKeyword.match(/\s*=\s*[\[{]/);
+        if (!bracketMatch)
+            continue;
+        const openBracket = afterKeyword[bracketMatch.index + bracketMatch[0].length - 1];
+        const closeBracket = openBracket === '[' ? ']' : '}';
+        // Extract the content between brackets
+        const startIndex = keywordIndex +
+            keyword.length +
+            bracketMatch.index +
+            bracketMatch[0].length;
+        const closeIndex = findMatchingBracket(content, startIndex - 1, openBracket, closeBracket);
+        if (closeIndex === -1)
+            continue;
+        const blockContent = content.slice(startIndex, closeIndex);
+        // Extract all quoted strings from the block
+        const quotedStrings = blockContent.match(/["']([^"']+)["']/g);
+        if (!quotedStrings)
+            continue;
+        for (const match of quotedStrings) {
+            const value = match.slice(1, -1);
+            const pkgName = value.split(/[><=!~;@\s[]/)[0].trim();
+            if (pkgName) {
+                const result = resolveGtDependency(pkgName);
+                if (result)
+                    return result;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Find the matching closing bracket, handling nesting.
+ */
+function findMatchingBracket(content, startIndex, openBracket, closeBracket) {
+    let depth = 0;
+    let inString = false;
+    let stringChar = '';
+    for (let i = startIndex; i < content.length; i++) {
+        const ch = content[i];
+        // Track string boundaries to avoid counting brackets inside strings
+        if (!inString && (ch === '"' || ch === "'")) {
+            inString = true;
+            stringChar = ch;
+        }
+        else if (inString && ch === stringChar && content[i - 1] !== '\\') {
+            inString = false;
+        }
+        if (inString)
+            continue;
+        if (ch === openBracket) {
+            depth++;
+        }
+        else if (ch === closeBracket) {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    return -1;
+}

package/dist/fs/determineFramework/resolveGtDependency.d.ts

@@ -0,0 +1,7 @@
+import { Libraries } from '../../types/libraries.js';
+/**
+ * Resolve a dependency name (hyphenated or underscored) to a Python GT library.
+ * Per PEP 503, Python package names are normalized: hyphens, underscores, and
+ * periods are interchangeable. We match both gt-flask/gt_flask forms.
+ */
+export declare function resolveGtDependency(pkgName: string): typeof Libraries.GT_FLASK | typeof Libraries.GT_FASTAPI | null;

package/dist/fs/determineFramework/resolveGtDependency.js

@@ -0,0 +1,17 @@
+import { Libraries } from '../../types/libraries.js';
+import { PYTHON_GT_DEPENDENCIES } from '@generaltranslation/python-extractor';
+/**
+ * Resolve a dependency name (hyphenated or underscored) to a Python GT library.
+ * Per PEP 503, Python package names are normalized: hyphens, underscores, and
+ * periods are interchangeable. We match both gt-flask/gt_flask forms.
+ */
+export function resolveGtDependency(pkgName) {
+    // Normalize: replace underscores/periods with hyphens, lowercase
+    const normalized = pkgName.toLowerCase().replace(/[_.]/g, '-');
+    for (const dep of PYTHON_GT_DEPENDENCIES) {
+        if (normalized === dep) {
+            return dep === 'gt-flask' ? Libraries.GT_FLASK : Libraries.GT_FASTAPI;
+        }
+    }
+    return null;
+}

package/dist/generated/version.d.ts

@@ -1 +1 @@
-export declare const PACKAGE_VERSION = "2.7.1";
+export declare const PACKAGE_VERSION = "2.8.0-alpha.0";

package/dist/generated/version.js

@@ -1,2 +1,2 @@
 // This file is auto-generated. Do not edit manually.
-export const PACKAGE_VERSION = '2.7.1';
+export const PACKAGE_VERSION = '2.8.0-alpha.0';

package/dist/index.js

@@ -1,9 +1,10 @@
 import { BaseCLI } from './cli/base.js';
 import { NextCLI } from './cli/next.js';
 import { ReactCLI } from './cli/react.js';
-import { determineLibrary } from './fs/determineFramework.js';
+import { PythonCLI } from './cli/python.js';
+import { determineLibrary } from './fs/determineFramework/index.js';
 import { NodeCLI } from './cli/node.js';
-import { Libraries } from './types/libraries.js';
+import { Libraries, isPythonLibrary } from './types/libraries.js';
 export function main(program) {
     program.name('gt');
     const { library, additionalModules } = determineLibrary();
@@ -18,6 +19,9 @@ export function main(program) {
     else if (library === Libraries.GT_NODE) {
         cli = new NodeCLI(program, library, additionalModules);
     }
+    else if (isPythonLibrary(library)) {
+        cli = new PythonCLI(program, library, additionalModules);
+    }
     else {
         cli = new BaseCLI(program, library, additionalModules);
     }

package/dist/python/parse/createPythonInlineUpdates.d.ts

@@ -0,0 +1,6 @@
+import { Updates } from '../../types/index.js';
+export declare function createPythonInlineUpdates(filePatterns: string[] | undefined): Promise<{
+    updates: Updates;
+    errors: string[];
+    warnings: string[];
+}>;

package/dist/python/parse/createPythonInlineUpdates.js

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import { extractFromPythonSource } from '@generaltranslation/python-extractor';
+import { mapExtractionResultsToUpdates } from '../../extraction/mapToUpdates.js';
+import { calculateHashes, dedupeUpdates, linkStaticUpdates, } from '../../extraction/postProcess.js';
+import { matchFiles } from '../../fs/matchFiles.js';
+import { DEFAULT_PYTHON_SRC_PATTERNS, DEFAULT_PYTHON_SRC_EXCLUDES, } from '../../config/generateSettings.js';
+export async function createPythonInlineUpdates(filePatterns) {
+    const updates = [];
+    const errors = [];
+    const warnings = [];
+    // Match Python source files, excluding common non-source directories
+    const patterns = filePatterns || DEFAULT_PYTHON_SRC_PATTERNS;
+    const files = matchFiles(process.cwd(), [
+        ...patterns,
+        ...DEFAULT_PYTHON_SRC_EXCLUDES.map((p) => `!${p}`),
+    ]);
+    for (const file of files) {
+        const code = await fs.promises.readFile(file, 'utf8');
+        try {
+            const { results, errors: fileErrors, warnings: fileWarnings, } = await extractFromPythonSource(code, file);
+            updates.push(...mapExtractionResultsToUpdates(results));
+            errors.push(...fileErrors);
+            warnings.push(...fileWarnings);
+        }
+        catch (error) {
+            errors.push(`Error extracting from ${file}: ${String(error)}`);
+        }
+    }
+    // Post processing steps
+    await calculateHashes(updates);
+    dedupeUpdates(updates);
+    linkStaticUpdates(updates);
+    return { updates, errors, warnings };
+}

package/dist/react/parse/createInlineUpdates.d.ts

@@ -1,13 +1,10 @@
 import { Updates } from '../../types/index.js';
 import type { ParsingConfigOptions } from '../../types/parsing.js';
 import { GTLibrary } from '../../types/libraries.js';
+import { dedupeUpdates } from '../../extraction/postProcess.js';
 export declare function createInlineUpdates(pkg: GTLibrary, validate: boolean, filePatterns: string[] | undefined, parsingOptions: ParsingConfigOptions): Promise<{
     updates: Updates;
     errors: string[];
     warnings: string[];
 }>;
-/**
- * Dedupe entries
- */
-declare function dedupeUpdates(updates: Updates): void;
 export { dedupeUpdates as _test_dedupeUpdates };

package/dist/react/parse/createInlineUpdates.js

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import { parse } from '@babel/parser';
-import { hashSource, hashString } from 'generaltranslation/id';
 import { parseTranslationComponent } from '../jsx/utils/jsxParsing/parseJsx.js';
 import { parseStrings } from '../jsx/utils/parseStringFunction.js';
 import { logger } from '../../console/logger.js';
@@ -8,6 +7,7 @@ import { matchFiles } from '../../fs/matchFiles.js';
 import { DEFAULT_SRC_PATTERNS } from '../../config/generateSettings.js';
 import { getPathsAndAliases } from '../jsx/utils/getPathsAndAliases.js';
 import { GT_LIBRARIES_UPSTREAM, REACT_LIBRARIES, } from '../../types/libraries.js';
+import { calculateHashes, dedupeUpdates, linkStaticUpdates, } from '../../extraction/postProcess.js';
 export async function createInlineUpdates(pkg, validate, filePatterns, parsingOptions) {
     const updates = [];
     const errors = [];
@@ -78,84 +78,4 @@ export async function createInlineUpdates(pkg, validate, filePatterns, parsingOp
 function getUpstreamPackages(pkg) {
     return GT_LIBRARIES_UPSTREAM[pkg];
 }
-/**
- * Calculate hashes
- */
-async function calculateHashes(updates) {
-    // parallel calculation of hashes
-    await Promise.all(updates.map(async (update) => {
-        const hash = hashSource({
-            source: update.source,
-            ...(update.metadata.context && { context: update.metadata.context }),
-            ...(update.metadata.id && { id: update.metadata.id }),
-            ...(update.metadata.maxChars != null && {
-                maxChars: update.metadata.maxChars,
-            }),
-            dataFormat: update.dataFormat,
-        });
-        update.metadata.hash = hash;
-    }));
-}
-/**
- * Dedupe entries
- */
-function dedupeUpdates(updates) {
-    const mergedByHash = new Map();
-    const noHashUpdates = [];
-    for (const update of updates) {
-        const hash = update.metadata.hash;
-        if (!hash) {
-            noHashUpdates.push(update);
-            continue;
-        }
-        const existing = mergedByHash.get(hash);
-        if (!existing) {
-            mergedByHash.set(hash, update);
-            continue;
-        }
-        const existingPaths = Array.isArray(existing.metadata.filePaths)
-            ? existing.metadata.filePaths.slice()
-            : [];
-        const newPaths = Array.isArray(update.metadata.filePaths)
-            ? update.metadata.filePaths
-            : [];
-        for (const p of newPaths) {
-            if (!existingPaths.includes(p)) {
-                existingPaths.push(p);
-            }
-        }
-        if (existingPaths.length) {
-            existing.metadata.filePaths = existingPaths;
-        }
-    }
-    const mergedUpdates = [...mergedByHash.values(), ...noHashUpdates];
-    updates.splice(0, updates.length, ...mergedUpdates);
-}
-/**
- * Mark static updates as the related by attaching a shared id to static content
- * Id is calculated as the hash of the static children's combined hashes
- */
-function linkStaticUpdates(updates) {
-    // construct map of temporary static ids to updates
-    const temporaryStaticIdToUpdates = updates.reduce((acc, update) => {
-        if (update.metadata.staticId) {
-            if (!acc[update.metadata.staticId]) {
-                acc[update.metadata.staticId] = [];
-            }
-            acc[update.metadata.staticId].push(update);
-        }
-        return acc;
-    }, {});
-    // Calculate shared static ids
-    Object.values(temporaryStaticIdToUpdates).forEach((staticUpdates) => {
-        const hashes = staticUpdates
-            .map((update) => update.metadata.hash)
-            .sort()
-            .join('-');
-        const sharedStaticId = hashString(hashes);
-        staticUpdates.forEach((update) => {
-            update.metadata.staticId = sharedStaticId;
-        });
-    });
-}
 export { dedupeUpdates as _test_dedupeUpdates };

package/dist/translation/parse.js

@@ -3,9 +3,11 @@ import { logger } from '../console/logger.js';
 import loadJSON from '../fs/loadJSON.js';
 import { createDictionaryUpdates } from '../react/parse/createDictionaryUpdates.js';
 import { createInlineUpdates } from '../react/parse/createInlineUpdates.js';
+import { createPythonInlineUpdates } from '../python/parse/createPythonInlineUpdates.js';
 import createESBuildConfig from '../react/config/createESBuildConfig.js';
 import chalk from 'chalk';
 import { exitSync } from '../console/logging.js';
+import { isPythonLibrary } from '../types/libraries.js';
 /**
  * Searches for gt-react or gt-next dictionary files and creates updates for them,
  * as well as inline updates for <T> tags and useGT()/getGT() calls
@@ -48,8 +50,10 @@ export async function createUpdates(options, src, sourceDictionary, pkg, validat
             ];
         }
     }
-    // Scan through project for <T> tags
-    const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = await createInlineUpdates(pkg, validate, src, parsingOptions);
+    // Scan through project for translatable content
+    const { updates: newUpdates, errors: newErrors, warnings: newWarnings, } = isPythonLibrary(pkg)
+        ? await createPythonInlineUpdates(src)
+        : await createInlineUpdates(pkg, validate, src, parsingOptions);
     errors = [...errors, ...newErrors];
     warnings = [...warnings, ...newWarnings];
     updates = [...updates, ...newUpdates];

package/dist/types/index.d.ts

@@ -164,7 +164,7 @@ export type Settings = {
     _versionId?: string;
     version?: string;
     description?: string;
-    src: string[];
+    src?: string[];
     framework?: SupportedFrameworks;
     options?: AdditionalOptions;
     modelProvider?: string;

package/dist/types/libraries.d.ts

@@ -7,17 +7,19 @@ export declare enum Libraries {
     GT_REACT_NATIVE = "gt-react-native",
     GT_NODE = "gt-node",
     GT_I18N = "gt-i18n",
-    GT_REACT_CORE = "@generaltranslation/react-core"
+    GT_REACT_CORE = "@generaltranslation/react-core",
+    GT_FLASK = "gt-flask",
+    GT_FASTAPI = "gt-fastapi"
 }
 /**
  * A list of all the libraries that support the CLI
  */
-export declare const GT_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_REACT_NATIVE, Libraries.GT_NODE, Libraries.GT_I18N, Libraries.GT_REACT_CORE];
+export declare const GT_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_REACT_NATIVE, Libraries.GT_NODE, Libraries.GT_I18N, Libraries.GT_REACT_CORE, Libraries.GT_FLASK, Libraries.GT_FASTAPI];
 export type GTLibrary = (typeof GT_LIBRARIES)[number];
 /**
  * Libraries that support inline translation
  */
-export declare const INLINE_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_NODE, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE, Libraries.GT_I18N];
+export declare const INLINE_LIBRARIES: readonly [Libraries.GT_REACT, Libraries.GT_NEXT, Libraries.GT_NODE, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE, Libraries.GT_I18N, Libraries.GT_FLASK, Libraries.GT_FASTAPI];
 export type InlineLibrary = (typeof INLINE_LIBRARIES)[number];
 export declare function isInlineLibrary(lib: string): lib is InlineLibrary;
 /**
@@ -25,6 +27,12 @@ export declare function isInlineLibrary(lib: string): lib is InlineLibrary;
  */
 export declare const REACT_LIBRARIES: readonly [Libraries.GT_NEXT, Libraries.GT_REACT, Libraries.GT_REACT_NATIVE, Libraries.GT_REACT_CORE];
 export type ReactLibrary = (typeof REACT_LIBRARIES)[number];
+/**
+ * Python libraries
+ */
+export declare const PYTHON_LIBRARIES: readonly [Libraries.GT_FLASK, Libraries.GT_FASTAPI];
+export type PythonLibrary = (typeof PYTHON_LIBRARIES)[number];
+export declare function isPythonLibrary(lib: string): lib is PythonLibrary;
 /**
  * A mapping of each library to their upstream dependencies for filtering imports
  */

package/dist/types/libraries.js

@@ -9,6 +9,8 @@ export var Libraries;
     Libraries["GT_NODE"] = "gt-node";
     Libraries["GT_I18N"] = "gt-i18n";
     Libraries["GT_REACT_CORE"] = "@generaltranslation/react-core";
+    Libraries["GT_FLASK"] = "gt-flask";
+    Libraries["GT_FASTAPI"] = "gt-fastapi";
 })(Libraries || (Libraries = {}));
 /**
  * A list of all the libraries that support the CLI
@@ -20,6 +22,8 @@ export const GT_LIBRARIES = [
     Libraries.GT_NODE,
     Libraries.GT_I18N,
     Libraries.GT_REACT_CORE,
+    Libraries.GT_FLASK,
+    Libraries.GT_FASTAPI,
 ];
 /**
  * Libraries that support inline translation
@@ -31,6 +35,8 @@ export const INLINE_LIBRARIES = [
     Libraries.GT_REACT_NATIVE,
     Libraries.GT_REACT_CORE,
     Libraries.GT_I18N,
+    Libraries.GT_FLASK,
+    Libraries.GT_FASTAPI,
 ];
 export function isInlineLibrary(lib) {
     return INLINE_LIBRARIES.includes(lib);
@@ -44,6 +50,16 @@ export const REACT_LIBRARIES = [
     Libraries.GT_REACT_NATIVE,
     Libraries.GT_REACT_CORE,
 ];
+/**
+ * Python libraries
+ */
+export const PYTHON_LIBRARIES = [
+    Libraries.GT_FLASK,
+    Libraries.GT_FASTAPI,
+];
+export function isPythonLibrary(lib) {
+    return PYTHON_LIBRARIES.includes(lib);
+}
 /**
  * A mapping of each library to their upstream dependencies for filtering imports
  */
@@ -69,4 +85,6 @@ export const GT_LIBRARIES_UPSTREAM = {
     [Libraries.GT_NODE]: [Libraries.GT_I18N, Libraries.GT_NODE],
     [Libraries.GT_REACT_CORE]: [Libraries.GT_I18N, Libraries.GT_REACT_CORE],
     [Libraries.GT_I18N]: [Libraries.GT_I18N],
+    [Libraries.GT_FLASK]: [Libraries.GT_FLASK],
+    [Libraries.GT_FASTAPI]: [Libraries.GT_FASTAPI],
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gt",
-  "version": "2.7.1",
+  "version": "2.8.0-alpha.0",
   "main": "dist/index.js",
   "bin": "dist/main.js",
   "files": [
@@ -92,6 +92,7 @@
     "esbuild": "^0.27.2",
     "fast-glob": "^3.3.3",
     "fast-json-stable-stringify": "^2.1.0",
+    "@generaltranslation/python-extractor": "0.0.1-alpha.0",
     "html-entities": "^2.6.0",
     "json-pointer": "^0.6.2",
     "jsonpath-plus": "^10.3.0",
@@ -105,6 +106,7 @@
     "remark-parse": "^11.0.0",
     "remark-stringify": "^11.0.0",
     "resolve": "^1.22.10",
+    "smol-toml": "^1.3.1",
     "tsconfig-paths": "^4.2.0",
     "unified": "^11.0.5",
     "unist-util-visit": "^5.0.0",

package/dist/fs/determineFramework.js

@@ -1,53 +0,0 @@
-import chalk from 'chalk';
-import path from 'node:path';
-import fs from 'node:fs';
-import { logger } from '../console/logger.js';
-import { Libraries } from '../types/libraries.js';
-export function determineLibrary() {
-    let library = 'base';
-    const additionalModules = [];
-    try {
-        // Get the current working directory (where the CLI is being run)
-        const cwd = process.cwd();
-        const packageJsonPath = path.join(cwd, 'package.json');
-        // Check if package.json exists
-        if (!fs.existsSync(packageJsonPath)) {
-            logger.warn(chalk.yellow('No package.json found in the current directory. Run this command from the root of your project.'));
-            return { library: 'base', additionalModules: [] };
-        }
-        // Read and parse package.json
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-        const dependencies = {
-            ...packageJson.dependencies,
-            ...packageJson.devDependencies,
-        };
-        // Check for gt-next or gt-react in dependencies
-        if (dependencies[Libraries.GT_NEXT]) {
-            library = Libraries.GT_NEXT;
-        }
-        else if (dependencies[Libraries.GT_REACT]) {
-            library = Libraries.GT_REACT;
-        }
-        else if (dependencies[Libraries.GT_REACT_NATIVE]) {
-            library = Libraries.GT_REACT_NATIVE;
-        }
-        else if (dependencies[Libraries.GT_NODE]) {
-            library = Libraries.GT_NODE;
-        }
-        else if (dependencies['next-intl']) {
-            library = 'next-intl';
-        }
-        else if (dependencies['i18next']) {
-            library = 'i18next';
-        }
-        if (dependencies['i18next-icu']) {
-            additionalModules.push('i18next-icu');
-        }
-        // Fallback to base if neither is found
-        return { library, additionalModules };
-    }
-    catch (error) {
-        logger.error('Error determining framework: ' + String(error));
-        return { library: 'base', additionalModules: [] };
-    }
-}