autosnippet 3.0.0 → 3.0.2

package/lib/core/discovery/PythonDiscoverer.js

@@ -0,0 +1,338 @@
+/**
+ * @module PythonDiscoverer
+ * @description Python 项目结构发现器
+ *
+ * 检测信号: pyproject.toml, setup.py, setup.cfg, requirements.txt, *.py
+ * 支持: pyproject.toml (PEP 621), setup.py, src 布局, 平铺布局
+ */
+
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { ProjectDiscoverer } from './ProjectDiscoverer.js';
+
+const EXCLUDE_DIRS = new Set([
+  '__pycache__',
+  '.venv',
+  'venv',
+  '.tox',
+  '.git',
+  '.mypy_cache',
+  '.pytest_cache',
+  '.eggs',
+  'dist',
+  'build',
+  'node_modules',
+  '.nox',
+  '.ruff_cache',
+]);
+
+export class PythonDiscoverer extends ProjectDiscoverer {
+  #projectRoot = null;
+  #targets = [];
+  #depGraph = { nodes: [], edges: [] };
+  #projectName = null;
+
+  get id() {
+    return 'python';
+  }
+  get displayName() {
+    return 'Python (pip/poetry/pdm)';
+  }
+
+  async detect(projectRoot) {
+    let confidence = 0;
+    const reasons = [];
+
+    if (existsSync(join(projectRoot, 'pyproject.toml'))) {
+      confidence = 0.9;
+      reasons.push('pyproject.toml exists');
+    }
+    if (existsSync(join(projectRoot, 'setup.py'))) {
+      confidence = Math.max(confidence, 0.8);
+      reasons.push('setup.py exists');
+    }
+    if (existsSync(join(projectRoot, 'setup.cfg'))) {
+      confidence = Math.max(confidence, 0.8);
+      reasons.push('setup.cfg exists');
+    }
+    if (existsSync(join(projectRoot, 'requirements.txt'))) {
+      confidence = Math.max(confidence, 0.6);
+      reasons.push('requirements.txt exists');
+    }
+
+    // 检查是否有 .py 文件
+    if (confidence === 0) {
+      try {
+        const entries = readdirSync(projectRoot);
+        if (entries.some((e) => e.endsWith('.py'))) {
+          confidence = 0.4;
+          reasons.push('*.py files found at root');
+        }
+      } catch {
+        /* skip */
+      }
+    }
+
+    return {
+      match: confidence > 0,
+      confidence: Math.min(confidence, 1.0),
+      reason: reasons.join(', ') || 'No Python markers found',
+    };
+  }
+
+  async load(projectRoot) {
+    this.#projectRoot = projectRoot;
+    this.#targets = [];
+    this.#depGraph = { nodes: [], edges: [] };
+
+    // 解析 pyproject.toml（简易 TOML 解析）
+    const pyprojectPath = join(projectRoot, 'pyproject.toml');
+    let pyproject = null;
+    if (existsSync(pyprojectPath)) {
+      pyproject = this.#parsePyprojectToml(readFileSync(pyprojectPath, 'utf8'));
+    }
+
+    this.#projectName = pyproject?.project?.name || basename(projectRoot);
+
+    // 发现包目录
+    const packages = this.#discoverPackages(projectRoot, pyproject);
+
+    for (const pkg of packages) {
+      const framework = this.#detectFramework(projectRoot, pyproject);
+      this.#targets.push({
+        name: pkg.name,
+        path: pkg.path,
+        type: pkg.isTest ? 'test' : 'library',
+        language: 'python',
+        framework,
+        metadata: { pyproject },
+      });
+      this.#depGraph.nodes.push(pkg.name);
+    }
+
+    // 如果没有发现任何包, 以项目根为兜底
+    if (this.#targets.length === 0) {
+      this.#targets.push({
+        name: this.#projectName,
+        path: projectRoot,
+        type: 'library',
+        language: 'python',
+        framework: this.#detectFramework(projectRoot, pyproject),
+        metadata: { pyproject },
+      });
+      this.#depGraph.nodes.push(this.#projectName);
+    }
+
+    // 解析依赖
+    this.#parseDependencies(projectRoot, pyproject);
+  }
+
+  async listTargets() {
+    return this.#targets;
+  }
+
+  async getTargetFiles(target) {
+    const targetPath =
+      typeof target === 'string'
+        ? this.#targets.find((t) => t.name === target)?.path || this.#projectRoot
+        : target.path;
+
+    if (!targetPath || !existsSync(targetPath)) {
+      return [];
+    }
+
+    const files = [];
+    this.#collectPyFiles(targetPath, targetPath, files);
+    return files;
+  }
+
+  async getDependencyGraph() {
+    return this.#depGraph;
+  }
+
+  // ── 内部实现 ──
+
+  #discoverPackages(projectRoot, pyproject) {
+    const packages = [];
+
+    // src/ 布局优先
+    const srcDir = join(projectRoot, 'src');
+    if (existsSync(srcDir)) {
+      try {
+        const entries = readdirSync(srcDir, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith('.') && !entry.name.startsWith('_')) {
+            const pkgDir = join(srcDir, entry.name);
+            if (existsSync(join(pkgDir, '__init__.py'))) {
+              packages.push({ name: entry.name, path: pkgDir, isTest: false });
+            }
+          }
+        }
+      } catch {
+        /* skip */
+      }
+    }
+
+    // 平铺布局: 含 __init__.py 的顶层目录
+    if (packages.length === 0) {
+      try {
+        const entries = readdirSync(projectRoot, { withFileTypes: true });
+        for (const entry of entries) {
+          if (entry.isDirectory() && !entry.name.startsWith('.') && !EXCLUDE_DIRS.has(entry.name)) {
+            const pkgDir = join(projectRoot, entry.name);
+            if (existsSync(join(pkgDir, '__init__.py'))) {
+              const isTest = /^tests?$/.test(entry.name);
+              packages.push({ name: entry.name, path: pkgDir, isTest });
+            }
+          }
+        }
+      } catch {
+        /* skip */
+      }
+    }
+
+    // 检测 tests/ 目录
+    for (const testDir of ['tests', 'test']) {
+      const testPath = join(projectRoot, testDir);
+      if (existsSync(testPath) && !packages.some((p) => p.name === testDir)) {
+        packages.push({ name: testDir, path: testPath, isTest: true });
+      }
+    }
+
+    return packages;
+  }
+
+  #detectFramework(projectRoot, pyproject) {
+    const deps = this.#extractDependencyNames(projectRoot, pyproject);
+
+    if (deps.has('django')) {
+      return 'django';
+    }
+    if (deps.has('flask')) {
+      return 'flask';
+    }
+    if (deps.has('fastapi')) {
+      return 'fastapi';
+    }
+    if (deps.has('torch') || deps.has('tensorflow')) {
+      return 'ml';
+    }
+    if (deps.has('scrapy')) {
+      return 'scrapy';
+    }
+    if (deps.has('celery')) {
+      return 'celery';
+    }
+    return null;
+  }
+
+  #extractDependencyNames(projectRoot, pyproject) {
+    const names = new Set();
+
+    // From pyproject.toml
+    if (pyproject?.project?.dependencies) {
+      for (const dep of pyproject.project.dependencies) {
+        const name = dep
+          .replace(/[>=<![\]~;@\s].*/g, '')
+          .trim()
+          .toLowerCase();
+        if (name) {
+          names.add(name);
+        }
+      }
+    }
+
+    // From requirements.txt
+    const reqPath = join(projectRoot, 'requirements.txt');
+    if (existsSync(reqPath)) {
+      try {
+        const content = readFileSync(reqPath, 'utf8');
+        for (const line of content.split('\n')) {
+          const trimmed = line.trim();
+          if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('-')) {
+            const name = trimmed
+              .replace(/[>=<![\]~;@\s].*/g, '')
+              .trim()
+              .toLowerCase();
+            if (name) {
+              names.add(name);
+            }
+          }
+        }
+      } catch {
+        /* skip */
+      }
+    }
+
+    return names;
+  }
+
+  #parseDependencies(projectRoot, pyproject) {
+    const names = this.#extractDependencyNames(projectRoot, pyproject);
+    const rootTarget = this.#targets[0]?.name;
+    if (!rootTarget) {
+      return;
+    }
+
+    for (const dep of names) {
+      this.#depGraph.edges.push({ from: rootTarget, to: dep, type: 'depends_on' });
+    }
+  }
+
+  #collectPyFiles(dir, rootDir, files, depth = 0) {
+    if (depth > 15) {
+      return;
+    }
+    try {
+      const entries = readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.name.startsWith('.')) {
+          continue;
+        }
+        if (EXCLUDE_DIRS.has(entry.name)) {
+          continue;
+        }
+
+        const fullPath = join(dir, entry.name);
+        if (entry.isDirectory()) {
+          this.#collectPyFiles(fullPath, rootDir, files, depth + 1);
+        } else if (entry.isFile() && entry.name.endsWith('.py')) {
+          files.push({
+            name: entry.name,
+            path: fullPath,
+            relativePath: relative(rootDir, fullPath),
+            language: 'python',
+          });
+        }
+      }
+    } catch {
+      /* skip */
+    }
+  }
+
+  /**
+   * 简易 TOML 解析器 — 仅提取本项目需要的字段
+   * 不做完整 TOML 解析, 只用正则提取关键信息
+   */
+  #parsePyprojectToml(content) {
+    const result = { project: {} };
+
+    // [project] name
+    const nameMatch = content.match(/\[project\][\s\S]*?name\s*=\s*["']([^"']+)["']/);
+    if (nameMatch) {
+      result.project.name = nameMatch[1];
+    }
+
+    // [project] dependencies — 简化提取数组
+    const depsMatch = content.match(/\[project\][\s\S]*?dependencies\s*=\s*\[([\s\S]*?)\]/);
+    if (depsMatch) {
+      result.project.dependencies = [];
+      const items = depsMatch[1].matchAll(/["']([^"']+)["']/g);
+      for (const m of items) {
+        result.project.dependencies.push(m[1]);
+      }
+    }
+
+    return result;
+  }
+}

package/lib/core/discovery/SpmDiscoverer.js

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Moved to lib/platform/ios/spm/SpmDiscoverer.js
+ * This re-export shim maintains backward compatibility.
+ */
+export { SpmDiscoverer } from '../../platform/ios/spm/SpmDiscoverer.js';

package/lib/core/discovery/index.js

@@ -0,0 +1,53 @@
+/**
+ * @module discovery/index
+ * @description ProjectDiscoverer 系统入口 — 初始化 Registry 并注册所有 Discoverer
+ */
+
+import { DartDiscoverer } from './DartDiscoverer.js';
+import { DiscovererRegistry } from './DiscovererRegistry.js';
+import { GenericDiscoverer } from './GenericDiscoverer.js';
+import { GoDiscoverer } from './GoDiscoverer.js';
+import { JvmDiscoverer } from './JvmDiscoverer.js';
+import { NodeDiscoverer } from './NodeDiscoverer.js';
+import { PythonDiscoverer } from './PythonDiscoverer.js';
+import { SpmDiscoverer } from './SpmDiscoverer.js';
+
+/** @type {DiscovererRegistry|null} */
+let _registry = null;
+
+/**
+ * 获取全局 DiscovererRegistry 单例
+ * @returns {DiscovererRegistry}
+ */
+export function getDiscovererRegistry() {
+  if (!_registry) {
+    _registry = new DiscovererRegistry();
+    _registry
+      .register(new SpmDiscoverer())
+      .register(new NodeDiscoverer())
+      .register(new PythonDiscoverer())
+      .register(new JvmDiscoverer())
+      .register(new GoDiscoverer())
+      .register(new DartDiscoverer())
+      .register(new GenericDiscoverer());
+  }
+  return _registry;
+}
+
+/**
+ * 重置 Registry（仅用于测试）
+ */
+export function resetDiscovererRegistry() {
+  _registry = null;
+}
+
+export { DartDiscoverer } from './DartDiscoverer.js';
+export { DiscovererRegistry } from './DiscovererRegistry.js';
+export { GenericDiscoverer } from './GenericDiscoverer.js';
+export { GoDiscoverer } from './GoDiscoverer.js';
+export { JvmDiscoverer } from './JvmDiscoverer.js';
+export { NodeDiscoverer } from './NodeDiscoverer.js';
+// Re-exports
+export { ProjectDiscoverer } from './ProjectDiscoverer.js';
+export { PythonDiscoverer } from './PythonDiscoverer.js';
+export { SpmDiscoverer } from './SpmDiscoverer.js';

package/lib/core/enhancement/EnhancementPack.js

@@ -0,0 +1,71 @@
+/**
+ * @module EnhancementPack
+ * @description 语言/框架特有增强能力包 — 接口定义
+ *
+ * 每个增强包负责:
+ * - 额外的 Bootstrap 维度
+ * - 额外的 Guard 规则
+ * - 额外的设计模式检测
+ * - SFC 预处理（.vue → 提取 <script>）
+ * - Reference Skill 路径
+ */
+
+export class EnhancementPack {
+  /** 增强包 ID @returns {string} */
+  get id() {
+    throw new Error('Not implemented');
+  }
+
+  /** 适用条件 @returns {{ languages: string[], frameworks?: string[] }} */
+  get conditions() {
+    throw new Error('Not implemented');
+  }
+
+  /** 人类可读名称 @returns {string} */
+  get displayName() {
+    return this.id;
+  }
+
+  /**
+   * 额外的 Bootstrap 维度定义
+   * @returns {Array<object>}
+   */
+  getExtraDimensions() {
+    return [];
+  }
+
+  /**
+   * 额外的 Guard 规则
+   * @returns {Array<object>}
+   */
+  getGuardRules() {
+    return [];
+  }
+
+  /**
+   * 额外的设计模式检测
+   * @param {object} astSummary — analyzeFile/analyzeProject 的返回值
+   * @returns {Array<{ type: string, className?: string, line?: number, confidence: number }>}
+   */
+  detectPatterns(astSummary) {
+    return [];
+  }
+
+  /**
+   * SFC 预处理器 — 将非标准文件转换为可解析的脚本内容
+   * @param {string} content — 原始文件内容
+   * @param {string} ext — 文件扩展名 (含 .)
+   * @returns {{ content: string, lang: string } | null}
+   */
+  preprocessFile(content, ext) {
+    return null;
+  }
+
+  /**
+   * Reference Skill 路径（Bootstrap 时自动加载，相对于 skills/ 目录）
+   * @returns {string|null}
+   */
+  getReferenceSkillPath() {
+    return null;
+  }
+}

package/lib/core/enhancement/EnhancementRegistry.js

@@ -0,0 +1,47 @@
+/**
+ * @module EnhancementRegistry
+ * @description 增强包注册与自动选择
+ *
+ * Bootstrap 完成 Phase 1 后，根据主语言 + 检测到的框架自动筛选增强包。
+ */
+
+export class EnhancementRegistry {
+  /** @type {import('./EnhancementPack.js').EnhancementPack[]} */
+  #packs = [];
+
+  /**
+   * 注册增强包
+   * @param {import('./EnhancementPack.js').EnhancementPack} pack
+   */
+  register(pack) {
+    this.#packs.push(pack);
+    return this;
+  }
+
+  /**
+   * 根据语言和框架筛选适用的增强包
+   * @param {string} primaryLang
+   * @param {string[]} detectedFrameworks
+   * @returns {import('./EnhancementPack.js').EnhancementPack[]}
+   */
+  resolve(primaryLang, detectedFrameworks = []) {
+    return this.#packs.filter((pack) => {
+      const cond = pack.conditions;
+      if (!cond) {
+        return false;
+      }
+      const langMatch = !cond.languages || cond.languages.includes(primaryLang);
+      const fwMatch =
+        !cond.frameworks || cond.frameworks.some((f) => detectedFrameworks.includes(f));
+      return langMatch && (cond.frameworks ? fwMatch : true);
+    });
+  }
+
+  /**
+   * 获取所有已注册的增强包
+   * @returns {import('./EnhancementPack.js').EnhancementPack[]}
+   */
+  all() {
+    return [...this.#packs];
+  }
+}

package/lib/core/enhancement/android-enhancement.js

@@ -0,0 +1,102 @@
+/**
+ * Android Enhancement Pack
+ * 条件: { languages: ['kotlin', 'java'], frameworks: ['android'] }
+ */
+
+import { EnhancementPack } from './EnhancementPack.js';
+
+class AndroidEnhancement extends EnhancementPack {
+  get id() {
+    return 'android';
+  }
+  get displayName() {
+    return 'Android (Kotlin/Java) Enhancement';
+  }
+  get conditions() {
+    return { languages: ['kotlin', 'java'], frameworks: ['android'] };
+  }
+
+  getExtraDimensions() {
+    return [
+      {
+        id: 'android-lifecycle-scan',
+        label: 'Activity/Fragment 生命周期',
+        guide:
+          'Activity/Fragment 生命周期方法合规检查、ViewModel 使用、LiveData/StateFlow 状态管理',
+        knowledgeTypes: ['architecture', 'best-practice'],
+        skillWorthy: true,
+        dualOutput: true,
+        skillMeta: {
+          name: 'project-android-lifecycle',
+          description:
+            'Android lifecycle compliance and ViewModel patterns (auto-generated by enhancement)',
+        },
+      },
+      {
+        id: 'android-compose-scan',
+        label: 'Jetpack Compose 分析',
+        guide: '@Composable 函数组织与状态管理、remember/rememberSaveable 使用、Side Effect API',
+        knowledgeTypes: ['code-pattern'],
+        skillWorthy: true,
+        dualOutput: true,
+        skillMeta: {
+          name: 'project-android-compose',
+          description:
+            'Jetpack Compose patterns and state management (auto-generated by enhancement)',
+        },
+      },
+    ];
+  }
+
+  detectPatterns(astSummary) {
+    const patterns = [];
+    for (const cls of astSummary.classes || []) {
+      // ViewModel
+      if (cls.superclass && /ViewModel$/.test(cls.superclass)) {
+        patterns.push({
+          type: 'android-viewmodel',
+          className: cls.name,
+          line: cls.line,
+          confidence: 0.9,
+        });
+      }
+      // Activity / Fragment
+      if (
+        cls.superclass &&
+        /Activity$|AppCompatActivity$|ComponentActivity$/.test(cls.superclass)
+      ) {
+        patterns.push({
+          type: 'android-activity',
+          className: cls.name,
+          line: cls.line,
+          confidence: 0.9,
+        });
+      }
+      if (cls.superclass && /Fragment$/.test(cls.superclass)) {
+        patterns.push({
+          type: 'android-fragment',
+          className: cls.name,
+          line: cls.line,
+          confidence: 0.9,
+        });
+      }
+      // Hilt DI
+      const annos = cls.annotations || [];
+      if (annos.some((a) => /@HiltAndroidApp|@AndroidEntryPoint/.test(a))) {
+        patterns.push({ type: 'hilt-di', className: cls.name, line: cls.line, confidence: 0.95 });
+      }
+      // Composable (class-level)
+      if (annos.some((a) => /@Composable/.test(a))) {
+        patterns.push({
+          type: 'composable',
+          className: cls.name,
+          line: cls.line,
+          confidence: 0.95,
+        });
+      }
+    }
+    return patterns;
+  }
+}
+
+export const pack = new AndroidEnhancement();

package/lib/core/enhancement/django-enhancement.js

@@ -0,0 +1,70 @@
+/**
+ * Django Enhancement Pack
+ * 条件: { languages: ['python'], frameworks: ['django'] }
+ */
+
+import { EnhancementPack } from './EnhancementPack.js';
+
+class DjangoEnhancement extends EnhancementPack {
+  get id() {
+    return 'django';
+  }
+  get displayName() {
+    return 'Django Enhancement';
+  }
+  get conditions() {
+    return { languages: ['python'], frameworks: ['django'] };
+  }
+
+  getExtraDimensions() {
+    return [
+      {
+        id: 'django-model-scan',
+        label: 'Django Model 扫描',
+        guide:
+          'Model 字段与关系扫描（ForeignKey/ManyToMany/OneToOne）、Manager 自定义、QuerySet 链路',
+        knowledgeTypes: ['architecture', 'code-pattern'],
+        skillWorthy: true,
+        dualOutput: true,
+        skillMeta: {
+          name: 'project-django-models',
+          description:
+            'Django Model definitions, field relationships and custom managers (auto-generated by enhancement)',
+        },
+      },
+    ];
+  }
+
+  detectPatterns(astSummary) {
+    const patterns = [];
+    for (const cls of astSummary.classes || []) {
+      if (cls.superclass && /Model$/.test(cls.superclass)) {
+        patterns.push({
+          type: 'django-model',
+          className: cls.name,
+          line: cls.line,
+          confidence: 0.9,
+        });
+      }
+      if (cls.superclass && /View$|ViewSet$/.test(cls.superclass)) {
+        patterns.push({
+          type: 'django-view',
+          className: cls.name,
+          line: cls.line,
+          confidence: 0.85,
+        });
+      }
+      if (cls.superclass && /BaseCommand/.test(cls.superclass)) {
+        patterns.push({
+          type: 'django-management-command',
+          className: cls.name,
+          line: cls.line,
+          confidence: 0.9,
+        });
+      }
+    }
+    return patterns;
+  }
+}
+
+export const pack = new DjangoEnhancement();