team-chat 0.0.0-stage → 0.3.1

package/host/knowledge/card.js

@@ -0,0 +1,43 @@
+// Карточка опыта — то, что остаётся от запуска агента: с каким стеком он работал, как шёл
+// к ответу и чем кончилось. Без кода и содержимого проекта — см. docs/plan-2026-10-24-knowledge.md.
+//
+// Здесь — часть без нейросети: факты из файлов проекта и записи запуска. Смысловая часть
+// (problem, solution) — урок от нейросети, шаг K2; пока она пустая.
+
+import { summarizeRun } from './process.js';
+import { detectStack } from './stack.js';
+
+export const CARD_FORMAT = 1;
+
+/**
+ * @param {object} p
+ * @param {object} p.run run.json записи запуска (run-archive.js)
+ * @param {string} p.output ход работы агента — stdout записи
+ * @param {string|null} p.workdir каталог, где работал агент
+ */
+export function buildCard({ run, output, workdir }) {
+  const process = summarizeRun(run.runtime, output);
+  const mentions = run.mentions ?? [];
+  return {
+    format: CARD_FORMAT,
+    stack: detectStack(workdir, process.touched),
+    process: {
+      engine: run.runtime,
+      role: mentions[0]?.agent_role ?? null,
+      steps: process.steps,
+      duration_s: run.duration_ms == null ? null : Math.round(run.duration_ms / 1000),
+      attempt: Math.max(1, ...mentions.map(m => m.attempt ?? 1)),
+      tools: process.tools,
+      errors: process.errors,
+      tokens: process.tokens,
+    },
+    problem: null,
+    solution: null,
+    outcome: {
+      answered: mentions.length > 0 && mentions.every(m => m.outcome === 'answered'),
+      exit_code: run.exit_code,
+      owner_reaction: null,
+      became_decision: false,
+    },
+  };
+}

package/host/knowledge/errors.js

@@ -0,0 +1,50 @@
+// С какими ошибками столкнулся агент — сигнатурами, без путей и значений: «SQLSTATE 42S02 —
+// table not found», а не строка лога целиком.
+
+import { scrub } from './scrub.js';
+
+const MAX_ERRORS = 10;
+const MAX_TEXT = 120;
+
+/** Сигнатуры по убыванию точности. → [вид, отрезок текста, по которому опознали]. */
+const SIGNATURES = [
+  [/SQLSTATE\[?([0-9A-Z]{5})\]?/, m => `SQLSTATE ${m[1]}`],
+  [/\b(ERR_[A-Z0-9_]{3,})\b/, m => m[1]],
+  [/\b(E(?:CONNREFUSED|NOENT|ACCES|ADDRINUSE|TIMEDOUT|PERM|EXIST|NOTFOUND|PIPE))\b/, m => m[1]],
+  [/\b([A-Z][A-Za-z]*(?:Error|Exception))\b/, m => m[1]],
+  [/\bcommand not found\b/i, () => 'command not found'],
+  [/\b(?:Fatal error|Segmentation fault|panic:)/, m => m[0].replace(/:$/, '')],
+  [/(?:ℹ\s*fail\s+[1-9]|\b[1-9]\d*\s+(?:failed|failing)\b|Tests:.*\b[1-9]\d*\s+failed|\bFAILED\b|^FAIL\b)/m, () => 'tests failed'],
+];
+
+/** Сигнатура ошибки в выводе команды или null, если ошибки не видно. */
+export function errorSignature(output) {
+  const text = String(output ?? '');
+  for (const [pattern, kind] of SIGNATURES) {
+    const match = pattern.exec(text);
+    if (match) return { kind: kind(match), text: lineAround(text, match.index) };
+  }
+  return null;
+}
+
+/** Собиратель ошибок запуска: без повторов и не больше десяти. */
+export class ErrorLog {
+  #seen = new Set();
+  list = [];
+
+  add(error) {
+    if (!error || this.list.length >= MAX_ERRORS) return;
+    const key = `${error.kind}|${error.text}`;
+    if (this.#seen.has(key)) return;
+    this.#seen.add(key);
+    this.list.push(error);
+  }
+}
+
+/** Строка, где нашлась сигнатура, — очищенная от секретов и путей и обрезанная. */
+function lineAround(text, index) {
+  const start = text.lastIndexOf('\n', index) + 1;
+  const end = text.indexOf('\n', index);
+  const line = scrub(text.slice(start, end === -1 ? undefined : end).trim()).replace(/\s+/g, ' ');
+  return line.length > MAX_TEXT ? `${line.slice(0, MAX_TEXT - 1)}…` : line;
+}

package/host/knowledge/lesson.js

@@ -0,0 +1,153 @@
+// Урок из запуска — смысловая часть карточки опыта: что за задача, в чём была причина,
+// какой подход сработал, где был тупик, какое правило отсюда следует. Пишет нейросеть по
+// жёсткой схеме; ответ проверяется и проходит фильтр секретов. Не прошёл — урока нет:
+// карточка без урока лучше карточки с мусором.
+
+import { spawn } from 'node:child_process';
+import { scrub } from './scrub.js';
+import { splitWords } from '../lib/shell-words.js';
+
+/** Тип задачи — по нему уроки разбираются и ищутся. Пояснения уходят модели вместе со схемой. */
+const CATEGORY_MEANINGS = {
+  bug: 'исправление ошибки',
+  task: 'новая возможность или доработка',
+  search: 'поиск и разбор: найти причину, место в коде, ответ в документации',
+  review: 'ревью кода или результата чужой работы',
+  refactor: 'переделка без смены поведения',
+  test: 'тесты',
+  config: 'настройка',
+  infra: 'сборка, выкладка, окружение',
+  performance: 'скорость и ресурсы',
+  security: 'безопасность',
+  question: 'ответ на вопрос без изменений',
+  other: 'ничего из перечисленного',
+};
+
+export const CATEGORIES = Object.keys(CATEGORY_MEANINGS);
+
+const MAX_FIELD = 300;
+const MAX_ITEMS = 8;
+
+export const LESSON_PROMPT = `Ниже — запись работы ИИ-агента над задачей в программном проекте. Извлеки из неё опыт,
+который пригодится в похожей задаче в другом проекте.
+
+Правила:
+- Без кода, без имён файлов и путей, без названий проекта, компаний, людей, без данных и ключей.
+- Технологии называй (Laravel, PostgreSQL, React — можно), предметную область обобщай
+  («модель заказа» → «модель предметной области»).
+- Пиши на языке задачи, коротко и по существу: каждое поле — одна-две фразы.
+- Если агент не решал техническую задачу (только поговорил или ничего не сделал) — ответь {"skip": true}.
+- category — тип задачи:
+${Object.entries(CATEGORY_MEANINGS).map(([name, meaning]) => `  ${name} — ${meaning}`).join('\n')}
+
+Ответ — только JSON, без пояснений, строго по схеме:
+{
+  "problem": {
+    "category": "${CATEGORIES.join('|')}",
+    "area": "область: база данных / миграции, сборка, API, интерфейс…",
+    "symptom": "как проявлялась задача или проблема",
+    "root_cause": "в чём была причина (null, если это не поиск причины)"
+  },
+  "solution": {
+    "approach": ["шаги, которые привели к результату"],
+    "dead_ends": ["что пробовал и не сработало (пустой список, если ничего)"],
+    "verified_by": "как проверено, что решено (null, если не проверялось)",
+    "rule": "одно правило, которое стоит применить в похожей задаче",
+    "applies_when": "когда это правило применимо: стек, условия"
+  }
+}
+
+Запись работы:
+`;
+
+/**
+ * Запустить команду урока (distill из runner.json) и разобрать ответ.
+ * @returns {Promise<{problem: object, solution: object} | null>} null — урока нет (пустяк, сбой, мусор)
+ */
+export async function distillLesson(command, transcript, { timeoutMs = 120_000, env, cwd } = {}) {
+  const [cmd, ...args] = splitWords(command);
+  const output = await run(cmd, args, LESSON_PROMPT + transcript, { timeoutMs, env, cwd });
+  return parseLesson(output);
+}
+
+/** Разобрать ответ модели: первый объект JSON в тексте, проверка схемы, фильтр секретов. */
+export function parseLesson(text) {
+  const data = firstJson(text);
+  if (!data || data.skip === true) return null;
+  const { problem, solution } = data;
+  if (!isObject(problem) || !isObject(solution)) return null;
+
+  const lesson = {
+    problem: {
+      category: CATEGORIES.includes(problem.category) ? problem.category : 'other',
+      area: field(problem.area),
+      symptom: field(problem.symptom),
+      root_cause: field(problem.root_cause),
+    },
+    solution: {
+      approach: list(solution.approach),
+      dead_ends: list(solution.dead_ends),
+      verified_by: field(solution.verified_by),
+      rule: field(solution.rule),
+      applies_when: field(solution.applies_when),
+    },
+  };
+  // Без симптома и правила урок пустой — его нечем применить.
+  return lesson.problem.symptom && lesson.solution.rule ? lesson : null;
+}
+
+function field(value) {
+  if (typeof value !== 'string' || !value.trim()) return null;
+  const clean = scrub(value.trim()).replace(/`+/g, '');
+  return clean.length > MAX_FIELD ? `${clean.slice(0, MAX_FIELD - 1)}…` : clean;
+}
+
+function list(value) {
+  return Array.isArray(value) ? value.map(field).filter(Boolean).slice(0, MAX_ITEMS) : [];
+}
+
+function isObject(value) {
+  return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+
+/** Модели любят оборачивать JSON в ```json … ``` и пояснения — берём первый объект. */
+function firstJson(text) {
+  const source = String(text ?? '');
+  for (let start = source.indexOf('{'); start !== -1; start = source.indexOf('{', start + 1)) {
+    let depth = 0;
+    let inString = false;
+    for (let i = start; i < source.length; i++) {
+      const c = source[i];
+      if (inString) {
+        if (c === '\\') i++;
+        else if (c === '"') inString = false;
+      } else if (c === '"') inString = true;
+      else if (c === '{') depth++;
+      else if (c === '}' && --depth === 0) {
+        try {
+          return JSON.parse(source.slice(start, i + 1));
+        } catch {
+          break;
+        }
+      }
+    }
+  }
+  return null;
+}
+
+/** Команда с заданием на stdin; ответ — stdout. Не уложилась во время — убита, урока нет. */
+function run(cmd, args, input, { timeoutMs, env, cwd }) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(cmd, args, { env, cwd, stdio: ['pipe', 'pipe', 'ignore'] });
+    let out = '';
+    const timer = setTimeout(() => child.kill('SIGKILL'), timeoutMs);
+    child.stdout.on('data', chunk => { out += chunk; });
+    child.stdin.on('error', () => {}); // команда могла выйти, не дочитав задание
+    child.on('error', e => { clearTimeout(timer); reject(e); });
+    child.on('close', code => {
+      clearTimeout(timer);
+      code === 0 ? resolve(out) : reject(new Error(`команда урока завершилась с кодом ${code}`));
+    });
+    child.stdin.end(input);
+  });
+}

package/host/knowledge/process.js

@@ -0,0 +1,160 @@
+// Ход работы агента — из его построчного вывода: сколько шагов, какие виды работы, с
+// какими ошибками столкнулся, какие файлы трогал. У каждого движка свой формат, разбор —
+// свой; результат один.
+
+import { ErrorLog, errorSignature } from './errors.js';
+import { scrub } from './scrub.js';
+import { classifyCommand } from './shell.js';
+
+/** Виды работы, в выводе которых ошибка — это сбой, а не текст прочитанного файла. */
+const CHECKED = new Set(['test', 'build', 'run', 'deps', 'db', 'infra', 'shell']);
+
+/** Инструменты Claude Code → вид работы. Служебные (поиск инструментов) — не шаги. */
+const CLAUDE_TOOLS = {
+  Read: 'read', Glob: 'search', Grep: 'search', LS: 'read',
+  Edit: 'edit', MultiEdit: 'edit', Write: 'edit', NotebookEdit: 'edit',
+  WebFetch: 'web', WebSearch: 'web', Task: 'delegate', Agent: 'delegate', TodoWrite: 'plan',
+};
+const CLAUDE_META = new Set(['ToolSearch']);
+
+/** Разборщик на каждый запуск: у Claude он помнит вызовы, чтобы связать их с результатами. */
+const PARSERS = { claude: () => new ClaudeParser(), codex: () => new CodexParser() };
+
+/**
+ * @param {string} engine движок (claude, codex)
+ * @param {string} output построчный JSON-вывод агента (stdout записи запуска)
+ * @returns {{steps: number, tools: Record<string, number>, errors: {kind: string, text: string}[],
+ *   touched: string[], tokens: {input: number, output: number} | null, cost_usd: number | null}}
+ *   touched — пути файлов; в карточку не попадают, нужны, чтобы понять, чей это стек
+ */
+export function summarizeRun(engine, output) {
+  const run = new RunSummary();
+  const parser = PARSERS[engine]?.();
+  if (parser) for (const event of events(output)) parser.feed(event, run);
+  return run.result();
+}
+
+class RunSummary {
+  steps = 0;
+  tools = {};
+  errors = new ErrorLog();
+  touched = new Set();
+  tokens = null;
+  cost = null;
+
+  step(kinds) {
+    this.steps++;
+    for (const kind of kinds) this.tools[kind] = (this.tools[kind] ?? 0) + 1;
+  }
+
+  /** Вывод шага: явный сбой — всегда ошибка; у проверяющих команд — если видна сигнатура. */
+  outcome(kinds, output, failed) {
+    const signature = errorSignature(output);
+    if (failed) this.errors.add(signature ?? { kind: 'error', text: firstLine(output) });
+    else if (signature && kinds.some(k => CHECKED.has(k))) this.errors.add(signature);
+  }
+
+  result() {
+    return {
+      steps: this.steps, tools: this.tools, errors: this.errors.list,
+      touched: [...this.touched], tokens: this.tokens, cost_usd: this.cost,
+    };
+  }
+}
+
+// --------------------------------------------------------------- claude --output-format stream-json
+
+class ClaudeParser {
+  #calls = new Map(); // id вызова → виды работы: результат приходит отдельным событием
+
+  feed(event, run) {
+    for (const part of event.message?.content ?? []) {
+      if (part.type === 'tool_use' && !CLAUDE_META.has(part.name)) this.#call(part, run);
+      if (part.type === 'tool_result' && this.#calls.has(part.tool_use_id)) {
+        run.outcome(this.#calls.get(part.tool_use_id), text(part.content), part.is_error === true);
+      }
+    }
+    if (event.type === 'result') {
+      const u = event.usage ?? {};
+      run.tokens = {
+        input: (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0),
+        output: u.output_tokens ?? 0,
+      };
+      run.cost = typeof event.total_cost_usd === 'number' ? event.total_cost_usd : null;
+    }
+  }
+
+  #call(part, run) {
+    const kinds = part.name === 'Bash' ? classifyCommand(part.input?.command ?? '')
+      : part.name.startsWith('mcp__') ? [part.name.includes('chat') ? 'chat' : 'mcp']
+        : [CLAUDE_TOOLS[part.name] ?? 'other'];
+    this.#calls.set(part.id, kinds);
+    run.step(kinds);
+    for (const key of ['file_path', 'path', 'notebook_path']) if (part.input?.[key]) run.touched.add(part.input[key]);
+  }
+}
+
+// --------------------------------------------------------------- codex exec --json
+
+class CodexParser {
+  feed(event, run) {
+    if (event.type === 'turn.completed' && event.usage) {
+      const u = event.usage;
+      run.tokens = {
+        input: (run.tokens?.input ?? 0) + (u.input_tokens ?? 0),
+        output: (run.tokens?.output ?? 0) + (u.output_tokens ?? 0) + (u.reasoning_output_tokens ?? 0),
+      };
+    }
+    if (event.type === 'item.completed') this.#item(event.item ?? {}, run);
+  }
+
+  #item(item, run) {
+    switch (item.type) {
+      case 'command_execution': {
+        const kinds = classifyCommand(item.command ?? '');
+        run.step(kinds);
+        run.outcome(kinds, item.aggregated_output, typeof item.exit_code === 'number' && item.exit_code !== 0);
+        break;
+      }
+      case 'file_change':
+        run.step(['edit']);
+        for (const change of item.changes ?? []) if (change.path) run.touched.add(change.path);
+        break;
+      case 'mcp_tool_call':
+        run.step([String(item.server ?? '').includes('chat') ? 'chat' : 'mcp']);
+        if (item.error) run.outcome(['mcp'], JSON.stringify(item.error), true);
+        break;
+      case 'web_search':
+        run.step(['web']);
+        break;
+      case 'todo_list':
+        run.step(['plan']);
+        break;
+      default:
+        break; // рассуждения и реплики агента — не шаги
+    }
+  }
+}
+
+// ---------------------------------------------------------------
+
+function* events(output) {
+  for (const line of String(output ?? '').split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      yield JSON.parse(line);
+    } catch {
+      // не JSON — служебная строка движка, пропускаем
+    }
+  }
+}
+
+function text(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) return content.map(c => (typeof c === 'string' ? c : c?.text ?? '')).join('\n');
+  return '';
+}
+
+function firstLine(output) {
+  return scrub(String(output ?? '').trim().split('\n')[0] ?? '').slice(0, 120);
+}

package/host/knowledge/scrub.js

@@ -0,0 +1,29 @@
+// Фильтр перед тем, как текст попадёт в карточку опыта: секреты и пути не должны покинуть
+// машину. Срабатывает с запасом — лучше вырезать лишнее, чем пропустить ключ.
+
+const SECRETS = [
+  /\b(?:gl(?:pat|dt|rt|ptt)|ghp|gho|ghu|ghs|ghr|github_pat)[-_][A-Za-z0-9_-]{10,}/g, // GitLab, GitHub
+  /\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{16,}/g, // Anthropic, OpenAI
+  /\bxox[abprs]-[A-Za-z0-9-]{10,}/g, // Slack
+  /\bAKIA[0-9A-Z]{16}\b/g, // AWS
+  /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g, // JWT
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----/g,
+  /\b[A-Za-z0-9+/_-]{40,}={0,2}/g, // длинные случайные строки — токены, хеши, ключи
+];
+
+/** ключ=значение, где ключ звучит как секрет: PASSWORD=…, "api_key": "…", token: … */
+const SECRET_ASSIGNMENT = /\b((?:[A-Za-z_][\w.-]*)?(?:pass(?:word)?|secret|token|api[_-]?key|private[_-]?key|credential)[\w.-]*)\b(["']?\s*[:=]\s*["']?)([^\s"',;]+)/gi;
+
+/** URL со вписанными логином и паролем: scheme://user:pass@host */
+const URL_CREDENTIALS = /\b([a-z][a-z0-9+.-]*:\/\/)[^\s/@:]+:[^\s/@]+@/gi;
+
+/** Абсолютные пути: в них имя пользователя и устройство его машины. */
+const PATHS = /(?:\/(?:home|Users|root|tmp|var|opt|mnt|srv|workspace|work)\/[^\s"'`:,;)]+|[A-Z]:\\[^\s"'`:,;)]+)/g;
+
+export function scrub(text) {
+  let out = String(text);
+  out = out.replace(URL_CREDENTIALS, '$1[скрыто]@');
+  out = out.replace(SECRET_ASSIGNMENT, '$1$2[скрыто]');
+  for (const pattern of SECRETS) out = out.replace(pattern, '[скрыто]');
+  return out.replace(PATHS, '<путь>');
+}

package/host/knowledge/shell.js

@@ -0,0 +1,74 @@
+// Что агент делал командой оболочки: читал, искал, гонял тесты, ставил зависимости…
+// Сама команда в карточку не попадает — только вид работы.
+
+/** Вид работы → признаки: первое слово команды или начало команды целиком. */
+const KINDS = [
+  ['test', [
+    /^(?:npm|yarn|pnpm|bun)\s+(?:run\s+)?test\b/, /^npx\s+(?:jest|vitest|mocha|playwright\s+test|cypress)\b/,
+    /^(?:jest|vitest|mocha|pytest|phpunit|pest|rspec|tox)\b/, /(?:^|\/)vendor\/bin\/(?:phpunit|pest)\b/,
+    /^php\s+artisan\s+test\b/, /^(?:go|cargo|dotnet|mvn|gradle|deno)\s+test\b/, /^node\s+--test\b/, /^python\d?\s+-m\s+(?:pytest|unittest)\b/,
+  ]],
+  ['build', [/^(?:npm|yarn|pnpm|bun)\s+run\s+build\b/, /^(?:tsc|make|webpack|vite\s+build)\b/, /^(?:go|cargo|dotnet)\s+build\b/, /^docker\s+(?:compose\s+)?build\b/]],
+  ['deps', [/^(?:npm|pnpm|bun)\s+(?:install|i|ci|add|update|remove)\b/, /^yarn(?:\s+(?:add|install|remove|upgrade))?$/, /^yarn\s+(?:add|install|remove|upgrade)\b/,
+    /^composer\s+(?:install|require|update|remove)\b/, /^pip\d?\s+install\b/, /^(?:go\s+get|cargo\s+add|bundle(?:\s+install)?)\b/, /^(?:poetry|uv)\s+(?:add|install|sync)\b/]],
+  ['db', [/^(?:mysql|psql|sqlite3|mongosh|redis-cli)\b/, /^php\s+artisan\s+(?:migrate|db:|tinker)/, /^(?:npx\s+)?(?:prisma|drizzle-kit|knex|sequelize)\b/, /^(?:alembic|flyway|liquibase)\b/]],
+  ['infra', [/^(?:docker|docker-compose|kubectl|helm|systemctl|journalctl|terraform)\b/]],
+  ['vcs', [/^git\b/, /^gh\b/, /^glab\b/]],
+  ['edit', [/^sed\s+(?:-\w*\s+)*-i/, /^(?:tee|patch|perl\s+-pi)\b/]],
+  ['search', [/^(?:grep|rg|ag|ack|find|fd|locate)\b/]],
+  ['read', [/^(?:cat|head|tail|less|more|sed|awk|ls|tree|wc|stat|file|jq|diff|nl|bat)\b/]],
+  ['net', [/^(?:curl|wget|http|ping|nc|ssh|scp)\b/]],
+  ['run', [/^(?:node|php|python\d?|ruby|go\s+run|cargo\s+run|deno|bun|npx|npm\s+run|yarn|pnpm)\b/]],
+];
+
+/** Виды работы в команде; склеенная команда («ls; cat x; npm test») — по частям, без повторов. */
+export function classifyCommand(command) {
+  const kinds = new Set();
+  for (const part of segments(unwrap(command))) {
+    const kind = KINDS.find(([, patterns]) => patterns.some(p => p.test(part)))?.[0] ?? 'shell';
+    kinds.add(kind);
+  }
+  return kinds.size ? [...kinds] : ['shell'];
+}
+
+/** «/bin/bash -lc "…"» — так Codex оборачивает каждую команду. */
+function unwrap(command) {
+  const match = /^(?:\/(?:usr\/)?bin\/)?(?:ba|z)?sh\s+-l?c\s+(['"])([\s\S]*)\1$/.exec(command.trim());
+  return match ? match[2] : command;
+}
+
+/** Части команды по ; && || | и переводам строк — вне кавычек; без cd, sudo и присваиваний впереди. */
+function segments(command) {
+  return splitOutsideQuotes(command)
+    .map(part => part.trim()
+      .replace(/^(?:sudo\s+|time\s+|(?:[A-Z_][A-Z0-9_]*=\S*\s+)+)+/, '')
+      .replace(/\s*[12]?>&?\s*\S+$/, ''))
+    .filter(part => part && !/^(?:cd|pwd|export|set|echo|true|false|sleep|printf|:)\b/.test(part));
+}
+
+function splitOutsideQuotes(command) {
+  const parts = [];
+  let current = '';
+  let quote = null;
+  for (let i = 0; i < command.length; i++) {
+    const c = command[i];
+    if (quote) {
+      if (c === quote) quote = null;
+      // \" внутри двойных кавычек не закрывает их
+      current += c === '\\' && quote === '"' ? c + (command[++i] ?? '') : c;
+      continue;
+    }
+    if (c === "'" || c === '"') {
+      quote = c;
+      current += c;
+    } else if (c === ';' || c === '\n' || c === '|' || (c === '&' && command[i + 1] === '&')) {
+      if (command[i + 1] === c) i++; // && и ||
+      parts.push(current);
+      current = '';
+    } else {
+      current += c;
+    }
+  }
+  parts.push(current);
+  return parts;
+}