claudenv 1.3.0 → 1.3.1

package/bin/cli.js

@@ -469,6 +469,108 @@ canonCmd
     }
   });
 
+// =============================================
+// Workspaces (isolated per-company/context memory)
+// =============================================
+const wsCmd = program.command('workspace').description('Isolated memory spaces (~/.claudenv/workspaces/)');
+
+wsCmd
+  .command('add')
+  .argument('<id>', 'Workspace id (slug: a-z0-9-_)')
+  .option('--name <name>', 'Human-readable name')
+  .option('--desc <description>', 'Description')
+  .option('--path <path...>', 'Project path(s) bound to this workspace')
+  .action(async (id, opts) => {
+    const { createWorkspace } = await import('../src/workspaces.js');
+    try {
+      await createWorkspace(id, { name: opts.name, description: opts.desc, paths: opts.path });
+      console.log(`  + workspace "${id}" created`);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(2);
+    }
+  });
+
+wsCmd
+  .command('list')
+  .action(async () => {
+    const { listWorkspaces } = await import('../src/workspaces.js');
+    const list = await listWorkspaces();
+    if (list.length === 0) {
+      console.log('  No workspaces yet — create one with `claudenv workspace add <id>`');
+      return;
+    }
+    for (const w of list) {
+      console.log(`  ${w.active ? '*' : ' '} ${w.id}${w.name && w.name !== w.id ? ` — ${w.name}` : ''}`);
+    }
+  });
+
+wsCmd
+  .command('use')
+  .argument('<id>', 'Workspace id to activate')
+  .action(async (id) => {
+    const { useWorkspace } = await import('../src/workspaces.js');
+    try {
+      await useWorkspace(id);
+      console.log(`  active workspace → ${id}`);
+    } catch (err) {
+      console.error(err.message);
+      process.exit(2);
+    }
+  });
+
+wsCmd
+  .command('show')
+  .action(async () => {
+    const { showActive } = await import('../src/workspaces.js');
+    const w = await showActive();
+    if (!w) {
+      console.log('  No active workspace (set CLAUDENV_WORKSPACE or run `claudenv workspace use <id>`)');
+      return;
+    }
+    console.log(`  active: ${w.id} (${w.source})`);
+    if (w.name && w.name !== w.id) console.log(`  name:   ${w.name}`);
+    if (w.description) console.log(`  desc:   ${w.description}`);
+    if (w.paths && w.paths.length) console.log(`  paths:  ${w.paths.join(', ')}`);
+  });
+
+// =============================================
+// Sources (connectors in the active workspace)
+// =============================================
+const srcCmd = program.command('source').description('Data-source connectors in the active workspace');
+
+srcCmd
+  .command('list')
+  .action(async () => {
+    const { listConnectors } = await import('../src/sources.js');
+    const { workspace, connectors } = await listConnectors();
+    if (!workspace) {
+      console.log('  No active workspace — set one first (`claudenv workspace use <id>`)');
+      return;
+    }
+    if (connectors.length === 0) {
+      console.log(`  [${workspace}] no connectors yet — add one via /add-source in Claude Code`);
+      return;
+    }
+    console.log(`  [${workspace}]`);
+    for (const c of connectors) {
+      console.log(`    ${c.name}  (${c.type}, ${c.status})${c.host ? `  ${c.host}` : ''}`);
+    }
+  });
+
+srcCmd
+  .command('show')
+  .argument('<name>', 'Connector name')
+  .action(async (name) => {
+    const { showConnector } = await import('../src/sources.js');
+    const text = await showConnector(name);
+    if (!text) {
+      console.error(`  Connector "${name}" not found in active workspace`);
+      process.exit(2);
+    }
+    console.log(text);
+  });
+
 // --- doctor ---
 program
   .command('doctor')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claudenv",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "One command to integrate Claude Code into any project — installs /claudenv command for AI-powered documentation generation",
   "type": "module",
   "bin": {

package/scaffold/global/.claude/commands/add-source.md

@@ -0,0 +1,31 @@
+---
+description: Добавить коннектор к источнику данных (SQL/REST/вики/Redash) с изоляцией по workspace
+allowed-tools: Bash, Read, Write, Edit, Skill
+argument-hint: [<описание источника>]
+---
+
+# /add-source - подключить источник данных
+
+Запускает skill `source-connector`: опрашивает тебя, генерирует рабочий коннектор,
+кладёт секреты в `.env.local`, кэширует знание о коннекторе (параметры + provenance)
+в память активного workspace.
+
+## Routing
+
+1. Активируй skill `source-connector`.
+2. Если в `$ARGUMENTS` есть описание источника (тип/хост/система) - передай его как
+   стартовый контекст, остальное доспроси.
+3. Если аргументов нет - начни с вопроса, к какому источнику подключаемся.
+
+## Перед стартом
+
+- Определи активный workspace (env `CLAUDENV_WORKSPACE` -> файл
+  `~/.claudenv/active-workspace`). Нет активного - предложи выбрать/создать,
+  не пиши в глобальную память.
+- Напомни инвариант: секреты идут только в `.env.local` (gitignored), в память -
+  только имена переменных.
+
+## Когда НЕ создавать коннектор
+
+Если для источника есть готовый MCP-сервер - предложи путь через `/setup-mcp`
+(`.mcp.json`), коннектор нужен только для источников без MCP.

package/scaffold/global/.claude/skills/source-connector/SKILL.md

@@ -0,0 +1,128 @@
+---
+name: source-connector
+description: |
+  Trigger when the user wants to connect to a data source that has no ready
+  MCP server - internal SQL/DWH behind VPN, corporate wiki (Confluence),
+  Redash, YouTrack, a custom REST API - or says "добавь источник",
+  "подключись к <система>", "/add-source". The skill interviews the user,
+  generates a working connector script, stores credentials in .env.local
+  (gitignored, never in memory), and caches connector knowledge (params +
+  provenance) in the ACTIVE workspace memory, isolated from other workspaces.
+  Do NOT trigger for sources that already have an MCP server (prefer MCP),
+  or for trivial local file reads.
+---
+
+# Source connector
+
+Создаёт коннектор к источнику данных без готового MCP: внутренний SQL/DWH,
+корпоративная вики, Redash, YouTrack, самописный REST. Опрашивает юзера,
+генерирует рабочий скрипт, кладёт секреты в `.env.local`, кэширует знание о
+коннекторе (параметры + provenance) в память АКТИВНОГО workspace.
+
+## Step 0 - Workspace resolution (FIRST, every time)
+
+Память изолирована по пространствам (workspaces). Прежде чем что-либо писать:
+
+1. Определи активный workspace:
+   - env `CLAUDENV_WORKSPACE`, иначе файл `~/.claudenv/active-workspace`.
+   - если есть `claudenv` CLI: `claudenv workspace show`.
+2. Если активного нет - предложи выбрать из `~/.claudenv/workspaces/` или создать
+   новый. НИКОГДА не подтягивай и не пиши в «глобальную» память доступы/коннекторы.
+3. Все записи коннектора пиши ТОЛЬКО в активный workspace:
+   `~/.claudenv/workspaces/<id>/memories/connectors/`.
+4. НИКОГДА не читай чужие workspaces - это барьер от ликов между компаниями.
+
+## Security invariants (нарушать нельзя)
+
+- **Секреты (пароли, токены, ключи) - только в `<project>/.env.local`** и только
+  значениями там. Убедись, что `.env.local` есть в `.gitignore` (добавь, если нет).
+- **В память коннектора - НИКОГДА значения секретов.** Только `secret_refs` -
+  имена переменных из `.env.local`.
+- **Не эхай секреты** в вывод/логи/коммиты.
+- Память активного workspace изолирована: не смешивай контекст разных компаний.
+
+## Trigger criteria
+
+Триггерь, если юзеру нужно регулярно/программно ходить в источник:
+- БД (MSSQL/Postgres/ClickHouse), DWH за VPN
+- корпоративная вики (Confluence), Redash, YouTrack, Grafana
+- самописный REST/GraphQL API
+
+НЕ триггерь:
+- если для источника есть MCP-сервер - предложи MCP (см. ниже)
+- разовое чтение локального файла
+- источник уже подключён (тогда это обновление, см. Step 6)
+
+## Step 1 - MCP vs connector
+
+Сначала проверь, нет ли готового MCP для источника (claudenv умеет настраивать MCP
+в `.mcp.json`). Если есть - предложи MCP-путь. Коннектор - для источников БЕЗ MCP.
+
+## Step 2 - Interview (спроси у юзера, кратко)
+
+Собери минимум для подключения:
+- тип источника (mssql / postgres / clickhouse / rest / confluence / redash / youtrack)
+- хост и порт, база/endpoint
+- метод аутентификации (sql login / domain / token / trusted)
+- что нужно достать (таблицы/эндпоинты) - для первого запроса
+- как зовутся переменные кред в `.env.local` (или предложи имена)
+
+Не выдумывай параметры - спрашивай. Если юзер уже дал часть (вики/git/переписка) -
+зафиксируй это в provenance.
+
+## Step 3 - Generate connector script
+
+Сгенерируй рабочий скрипт из шаблона (`templates/connector-*.ejs`):
+- MSSQL -> pymssql/pyodbc, строка `mssql+pymssql://{user}:{pwd}@{host}:{port}/{db}`
+  (СУЗ - логин без домена; экранируй пароль через urllib `quote_plus`).
+- REST -> requests + Bearer-токен из env.
+Скрипт читает креды из `.env.local` (через env), не хардкодит.
+
+## Step 4 - Secrets to .env.local
+
+- Запиши значения в `<project>/.env.local` (создай при отсутствии).
+- Проверь/добавь `.env.local` в `.gitignore`.
+- В память пойдут только имена этих переменных (`secret_refs`).
+
+## Step 5 - Write connector record (в активный workspace)
+
+Создай `~/.claudenv/workspaces/<id>/memories/connectors/<name>.md`:
+
+```markdown
+---
+name: <name>
+type: <mssql|rest|...>
+status: <draft|working|blocked>
+host: <host>
+database: <db|->
+port: <port|->
+auth: <sql|domain|token|trusted>
+secret_refs: {user: <ENV_VAR>, password: <ENV_VAR>}   # ИМЕНА, не значения
+connector_script: <path в проекте>
+provenance:                                            # откуда собрана инфа
+  - {source: <wiki|git|chat|docs>, ref: <url|путь>, note: <кратко>}
+verified_at: <YYYY-MM-DD|->
+updated_at: <YYYY-MM-DD>
+---
+
+Детали: как устроено подключение, что блокирует, как обновлять.
+```
+
+**Provenance обязателен** - фиксируй, откуда взял каждый факт (вики-страница, файл
+в git, сообщение в чате). Это позволяет потом перепроверить и обновить.
+
+## Step 6 - Test and iterate
+
+Протестируй подключение, если возможно. Зафиксируй `status` и `verified_at`.
+При ошибке - запиши симптом в запись (раздел деталей) и предложи следующий шаг.
+
+## Step 7 - Updating an existing connector
+
+Если коннектор уже есть в активном workspace:
+- найди запись, обнови `status`/`host`/`secret_refs`, допиши `provenance`,
+  обнови `updated_at`. Запись - единый источник правды по коннектору.
+
+## После создания
+
+Предложи дальнейшую автоматизацию через коннектор (регулярная выгрузка, отчёт,
+интеграция в пайплайн). Язык общения - русский.

package/src/doctor.js

@@ -13,7 +13,10 @@ import {
   memoriesDir,
   globalDecisionsDir,
   indexMdPath,
+  activeWorkspaceId,
+  workspaceConnectorsDir,
 } from './memory-paths.js';
+import { scanForSecretLeaks } from './sources.js';
 
 const OK = '[OK]  ';
 const WARN = '[WARN]';
@@ -151,6 +154,28 @@ async function countDecisionsCheck() {
   return { status: OK, msg: `${count} global decisions logged` };
 }
 
+async function workspaceLeakCheck() {
+  const id = activeWorkspaceId();
+  if (!id) return { status: OK, msg: 'no active workspace — secret-leak scan skipped' };
+  let files;
+  try {
+    files = (await readdir(workspaceConnectorsDir(id))).filter((f) => f.endsWith('.md'));
+  } catch {
+    return { status: OK, msg: `workspace "${id}": no connectors to scan` };
+  }
+  const leaks = [];
+  for (const f of files) {
+    try {
+      const found = scanForSecretLeaks(await readFile(join(workspaceConnectorsDir(id), f), 'utf-8'));
+      if (found.length) leaks.push(`${f}:${found[0].line}`);
+    } catch { /* skip */ }
+  }
+  if (leaks.length) {
+    return { status: FAIL, msg: `secret values in workspace memory: ${leaks.join(', ')} — move to .env.local` };
+  }
+  return { status: OK, msg: `workspace "${id}": connector memory clean (no secret values)` };
+}
+
 export async function runDoctor() {
   const checks = [
     await nodeVersionCheck(),
@@ -162,6 +187,7 @@ export async function runDoctor() {
     await projectHooksCheck(),
     await pythonModuleCheck(),
     await countDecisionsCheck(),
+    await workspaceLeakCheck(),
   ];
 
   let hasFail = false;

package/src/installer.js

@@ -135,8 +135,10 @@ export async function uninstallGlobal(options = {}) {
     join(targetBase, 'commands', 'decisions.md'),
     join(targetBase, 'commands', 'canon.md'),
     join(targetBase, 'commands', 'just-code.md'),
+    join(targetBase, 'commands', 'add-source.md'),
     join(targetBase, 'skills', 'claudenv'),
     join(targetBase, 'skills', 'vibe-decisions'),
+    join(targetBase, 'skills', 'source-connector'),
   ];
 
   for (const target of targets) {

package/src/memory-paths.js

@@ -8,6 +8,7 @@
 
 import { join } from 'node:path';
 import { homedir } from 'node:os';
+import { readFileSync } from 'node:fs';
 
 export function claudenvHome() {
   return process.env.CLAUDENV_HOME || join(homedir(), '.claudenv');
@@ -41,6 +42,47 @@ export function projectDecisionsDir(cwd) {
   return join(cwd, '.claude', 'memories', 'decisions');
 }
 
+// --- Workspace layer (isolated per-company/context memory) ---
+
+export function workspacesDir() {
+  return join(claudenvHome(), 'workspaces');
+}
+
+export function activeWorkspaceFile() {
+  return join(claudenvHome(), 'active-workspace');
+}
+
+export function workspaceDir(id) {
+  return join(workspacesDir(), id);
+}
+
+export function workspaceManifestPath(id) {
+  return join(workspaceDir(id), 'workspace.yaml');
+}
+
+export function workspaceConnectorsDir(id) {
+  return join(workspaceDir(id), 'memories', 'connectors');
+}
+
+export function workspaceContextDir(id) {
+  return join(workspaceDir(id), 'memories', 'context');
+}
+
+/**
+ * Resolve the active workspace id. Priority: env CLAUDENV_WORKSPACE, then the
+ * pointer file ~/.claudenv/active-workspace. Returns null if none set.
+ * Intentionally does NOT scan all workspaces - isolation barrier.
+ */
+export function activeWorkspaceId() {
+  if (process.env.CLAUDENV_WORKSPACE) return process.env.CLAUDENV_WORKSPACE.trim();
+  try {
+    const id = readFileSync(activeWorkspaceFile(), 'utf-8').trim();
+    return id || null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Minimal YAML frontmatter parser. Returns null when no frontmatter is present.
  * Handles `key: value` and inline arrays `[a, b, c]`. Heavier structures fall

package/src/sources.js

@@ -0,0 +1,78 @@
+/**
+ * CLI: `claudenv source list|show`
+ *
+ * Connectors are knowledge records (params + provenance) stored in the ACTIVE
+ * workspace: ~/.claudenv/workspaces/<id>/memories/connectors/<name>.md.
+ *
+ * Records hold connection metadata and secret_refs (env-var NAMES) only.
+ * Actual secret values live in <project>/.env.local and must never appear here.
+ * The skill `source-connector` is the primary author; CLI is for listing and
+ * for the doctor leak-lint.
+ */
+
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { workspaceConnectorsDir, activeWorkspaceId, parseFrontmatter } from './memory-paths.js';
+
+export async function listConnectors() {
+  const id = activeWorkspaceId();
+  if (!id) return { workspace: null, connectors: [] };
+  let files;
+  try {
+    files = (await readdir(workspaceConnectorsDir(id))).filter((f) => f.endsWith('.md'));
+  } catch {
+    return { workspace: id, connectors: [] };
+  }
+  const connectors = [];
+  for (const f of files) {
+    let fm = null;
+    try {
+      fm = parseFrontmatter(await readFile(join(workspaceConnectorsDir(id), f), 'utf-8'));
+    } catch { /* skip unreadable */ }
+    connectors.push({
+      name: (fm && fm.name) || f.replace(/\.md$/, ''),
+      type: (fm && fm.type) || '?',
+      status: (fm && fm.status) || '?',
+      host: (fm && fm.host) || '',
+    });
+  }
+  return { workspace: id, connectors };
+}
+
+export async function showConnector(name) {
+  const id = activeWorkspaceId();
+  if (!id) return null;
+  try {
+    return await readFile(join(workspaceConnectorsDir(id), `${name}.md`), 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Heuristic leak scan for the doctor. Flags lines that look like a secret VALUE
+ * rather than a reference. Connector records should only carry env-var names.
+ *
+ * Returns an array of { line, reason } findings (empty = clean).
+ */
+export function scanForSecretLeaks(text) {
+  const findings = [];
+  const lines = text.split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    // secret_refs хранит ИМЕНА env-переменных по определению - не сканируем
+    if (/secret_refs/i.test(line)) continue;
+    // `password: <value>` / `token: <value>` with a non-placeholder, non-env value
+    const m = /\b(password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key)\b\s*[:=]\s*(\S+)/i.exec(line);
+    if (m) {
+      // снять кавычки и хвостовую пунктуацию inline-структур ({ } , ; )
+      const val = m[2].replace(/['"]/g, '').replace(/[},;)]+$/, '');
+      const placeholder = /^(<.*>|\.\.\.|x+|\*+|null|none|env:|\$\{|secret_refs)/i.test(val);
+      const looksEnvName = /^[A-Z][A-Z0-9_]*$/.test(val) || /_(env|token|login|password)$/i.test(val);
+      if (!placeholder && !looksEnvName && val.length >= 6) {
+        findings.push({ line: i + 1, reason: `похоже на значение секрета: ${m[1]}` });
+      }
+    }
+  }
+  return findings;
+}

package/src/workspaces.js

@@ -0,0 +1,129 @@
+/**
+ * CLI: `claudenv workspace add|list|use|show`
+ *
+ * Workspaces are isolated per-company/context memory spaces under
+ * ~/.claudenv/workspaces/<id>/. Only the ACTIVE workspace is ever loaded -
+ * this is the isolation barrier that prevents access/context from one company
+ * leaking into another project on the same device.
+ *
+ * Secrets NEVER live here - they belong in <project>/.env.local (gitignored).
+ * Workspace memory holds connector metadata + provenance only.
+ */
+
+import { readFile, writeFile, mkdir, readdir, stat } from 'node:fs/promises';
+import {
+  workspacesDir,
+  workspaceDir,
+  workspaceManifestPath,
+  workspaceConnectorsDir,
+  workspaceContextDir,
+  activeWorkspaceFile,
+  activeWorkspaceId,
+} from './memory-paths.js';
+
+const SLUG_RE = /^[a-z0-9][a-z0-9_-]*$/;
+
+export function validateId(id) {
+  if (!id || !SLUG_RE.test(id)) {
+    throw new Error(`Invalid workspace id "${id}" - use lowercase letters, digits, - or _`);
+  }
+  return id;
+}
+
+/**
+ * Render a flat workspace.yaml. Minimal by design (human-editable), like canon.
+ */
+function renderManifest({ name, description, paths }) {
+  const lines = [];
+  lines.push(`name: ${name || ''}`);
+  lines.push(`description: ${description || ''}`);
+  lines.push('paths:');
+  for (const p of paths || []) lines.push(`  - ${p}`);
+  return lines.join('\n') + '\n';
+}
+
+/** Tolerant parser for the flat workspace.yaml above. */
+function parseManifest(text) {
+  const out = { name: '', description: '', paths: [] };
+  let inPaths = false;
+  for (const raw of text.split('\n')) {
+    const line = raw.replace(/\s+$/, '');
+    if (!line || line.startsWith('#')) continue;
+    const kv = /^([a-zA-Z_]+):\s*(.*)$/.exec(line);
+    if (kv && kv[1] === 'paths') { inPaths = true; continue; }
+    if (kv) {
+      inPaths = false;
+      if (kv[1] === 'name') out.name = kv[2];
+      else if (kv[1] === 'description') out.description = kv[2];
+      continue;
+    }
+    const item = /^\s+-\s+(.*)$/.exec(line);
+    if (item && inPaths) out.paths.push(item[1].trim());
+  }
+  return out;
+}
+
+export async function createWorkspace(id, { name, description, paths } = {}) {
+  validateId(id);
+  const dir = workspaceDir(id);
+  try {
+    await stat(dir);
+    throw new Error(`Workspace "${id}" already exists`);
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e;
+  }
+  await mkdir(workspaceConnectorsDir(id), { recursive: true });
+  await mkdir(workspaceContextDir(id), { recursive: true });
+  await writeFile(
+    workspaceManifestPath(id),
+    renderManifest({ name: name || id, description, paths }),
+    'utf-8'
+  );
+  // секреты сюда не кладём - явный gitignore на случай, если папку положат в git
+  await writeFile(workspaceDir(id) + '/.gitignore', '.env\n.env.local\n*.secret\n', 'utf-8');
+  return dir;
+}
+
+export async function listWorkspaces() {
+  let entries;
+  try {
+    entries = await readdir(workspacesDir(), { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const active = activeWorkspaceId();
+  const result = [];
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    let manifest = { name: ent.name, description: '', paths: [] };
+    try {
+      manifest = parseManifest(await readFile(workspaceManifestPath(ent.name), 'utf-8'));
+    } catch { /* нет манифеста - покажем по id */ }
+    result.push({ id: ent.name, active: ent.name === active, ...manifest });
+  }
+  return result;
+}
+
+export async function useWorkspace(id) {
+  validateId(id);
+  try {
+    await stat(workspaceDir(id));
+  } catch {
+    throw new Error(`Workspace "${id}" does not exist - create it with 'claudenv workspace add ${id}'`);
+  }
+  await writeFile(activeWorkspaceFile(), id + '\n', 'utf-8');
+  return id;
+}
+
+export async function showActive() {
+  const id = activeWorkspaceId();
+  if (!id) return null;
+  let manifest = { name: id, description: '', paths: [] };
+  try {
+    manifest = parseManifest(await readFile(workspaceManifestPath(id), 'utf-8'));
+  } catch { /* активный указан, но манифеста нет */ }
+  const source = process.env.CLAUDENV_WORKSPACE ? 'env CLAUDENV_WORKSPACE' : 'active-workspace file';
+  return { id, source, ...manifest };
+}
+
+export { parseManifest };

package/templates/connector-mssql.ejs

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Коннектор к MSSQL: <%= name %> (host <%= host %>, db <%= database %>).
+Сгенерирован claudenv (skill source-connector).
+
+Креды читаются из .env.local (gitignored), НЕ хардкодятся:
+  <%= userEnv %>=<логин>
+  <%= passwordEnv %>=<пароль>
+
+Зависимости: pip install pymssql sqlalchemy pandas
+"""
+
+import os
+import sys
+from urllib.parse import quote_plus
+
+import pandas as pd
+from sqlalchemy import create_engine
+
+HOST = os.getenv("<%= name.toUpperCase().replace(/[^A-Z0-9]/g, '_') %>_HOST", "<%= host %>")
+PORT = os.getenv("<%= name.toUpperCase().replace(/[^A-Z0-9]/g, '_') %>_PORT", "<%= port || 1433 %>")
+DATABASE = os.getenv("<%= name.toUpperCase().replace(/[^A-Z0-9]/g, '_') %>_DB", "<%= database %>")
+
+
+def load_env_local(path=".env.local"):
+    env = {}
+    if os.path.exists(path):
+        with open(path, encoding="utf-8") as fh:
+            for line in fh:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    k, _, v = line.partition("=")
+                    env[k.strip()] = v.strip()
+    return env
+
+
+_env = load_env_local()
+USER = _env.get("<%= userEnv %>") or os.getenv("<%= userEnv %>")
+PASSWORD = _env.get("<%= passwordEnv %>") or os.getenv("<%= passwordEnv %>")
+
+if not USER or not PASSWORD:
+    sys.exit("Нет кред в .env.local: <%= userEnv %> / <%= passwordEnv %>")
+
+
+def engine():
+    # пароль экранируем - в нём могут быть спецсимволы (@ : ~ и т.п.)
+    url = f"mssql+pymssql://{quote_plus(USER)}:{quote_plus(PASSWORD)}@{HOST}:{PORT}/{DATABASE}"
+    return create_engine(url)
+
+
+def query(sql):
+    """Выполнить SELECT, вернуть DataFrame."""
+    return pd.read_sql(sql, engine())
+
+
+if __name__ == "__main__":
+    sql = sys.argv[1] if len(sys.argv) > 1 else "SELECT 1 AS ok"
+    df = query(sql)
+    print(f"Строк: {len(df)}")
+    with pd.option_context("display.max_columns", None, "display.width", 200):
+        print(df.head(20).to_string(index=False))

package/templates/connector-rest.ejs

@@ -0,0 +1,59 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Коннектор к REST API: <%= name %> (base <%= host %>).
+Сгенерирован claudenv (skill source-connector).
+
+Токен читается из .env.local (gitignored), НЕ хардкодится:
+  <%= tokenEnv %>=<токен>
+
+Зависимости: pip install requests
+"""
+
+import os
+import sys
+
+import requests
+
+BASE = os.getenv("<%= name.toUpperCase().replace(/[^A-Z0-9]/g, '_') %>_BASE", "<%= host %>")
+
+
+def load_env_local(path=".env.local"):
+    env = {}
+    if os.path.exists(path):
+        with open(path, encoding="utf-8") as fh:
+            for line in fh:
+                line = line.strip()
+                if line and not line.startswith("#") and "=" in line:
+                    k, _, v = line.partition("=")
+                    env[k.strip()] = v.strip()
+    return env
+
+
+_env = load_env_local()
+TOKEN = _env.get("<%= tokenEnv %>") or os.getenv("<%= tokenEnv %>")
+
+if not TOKEN:
+    sys.exit("Нет токена в .env.local: <%= tokenEnv %>")
+
+
+def client():
+    s = requests.Session()
+    s.headers.update({
+        "Authorization": f"Bearer {TOKEN}",
+        "Accept": "application/json",
+    })
+    return s
+
+
+def get(path, **params):
+    """GET к API, вернуть JSON. path - относительный (/api/...)."""
+    r = client().get(f"{BASE}{path}", params=params, timeout=30)
+    r.raise_for_status()
+    return r.json()
+
+
+if __name__ == "__main__":
+    path = sys.argv[1] if len(sys.argv) > 1 else "/"
+    import json
+    print(json.dumps(get(path), ensure_ascii=False, indent=2)[:2000])