archiver-ts 0.0.1

package/tests/commands/list-interactive.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, it } from 'vitest';
+import { ArchiveStatus } from '../../src/consts/index.js';
+import { isActionAvailable, type InteractiveListEntry } from '../../src/commands/list-interactive.js';
+
+function makeEntry(status: ArchiveStatus): InteractiveListEntry {
+  return {
+    id: 1,
+    status,
+    title: '@(0)/demo.txt',
+    path: '/tmp/demo.txt',
+  };
+}
+
+describe('list interactive', () => {
+  it('allows enter/restore actions for archived entries', () => {
+    const entry = makeEntry(ArchiveStatus.Archived);
+    expect(isActionAvailable(entry, 'enter')).toBe(true);
+    expect(isActionAvailable(entry, 'restore')).toBe(true);
+  });
+
+  it('disables enter/restore actions for restored entries', () => {
+    const entry = makeEntry(ArchiveStatus.Restored);
+    expect(isActionAvailable(entry, 'enter')).toBe(false);
+    expect(isActionAvailable(entry, 'restore')).toBe(false);
+  });
+});

package/tests/core/initialize.test.ts

@@ -0,0 +1,130 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { ensureArvShellWrapper } from '../../src/core/initialize.js';
+
+const tempDirs: string[] = [];
+
+async function makeHome(): Promise<string> {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'arv-init-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(async () => {
+  while (tempDirs.length > 0) {
+    const dir = tempDirs.pop();
+    if (dir) {
+      await fs.rm(dir, { recursive: true, force: true });
+    }
+  }
+});
+
+describe('shell wrapper initialize', () => {
+  it('creates bash wrapper when missing', async () => {
+    const homeDir = await makeHome();
+    const result = await ensureArvShellWrapper({
+      homeDir,
+      shellPath: '/bin/bash',
+      stdinIsTTY: true,
+      env: {},
+    });
+
+    expect(result.installed).toBe(true);
+    expect(result.shell).toBe('bash');
+    expect(result.reloadCommand).toContain('source');
+    const content = await fs.readFile(path.join(homeDir, '.bashrc'), 'utf8');
+    expect(content).toContain('# >>> archiver arv wrapper >>>');
+    expect(content).toContain('arv() {');
+    expect(content).toContain('command arv "$@"');
+  });
+
+  it('does not duplicate managed wrapper block and skips second install', async () => {
+    const homeDir = await makeHome();
+    const first = await ensureArvShellWrapper({
+      homeDir,
+      shellPath: '/bin/zsh',
+      stdinIsTTY: true,
+      env: {},
+    });
+    const second = await ensureArvShellWrapper({
+      homeDir,
+      shellPath: '/bin/zsh',
+      stdinIsTTY: true,
+      env: {},
+    });
+
+    expect(first.installed).toBe(true);
+    expect(second.installed).toBe(false);
+    const content = await fs.readFile(path.join(homeDir, '.zshrc'), 'utf8');
+    const markerCount = (content.match(/# >>> archiver arv wrapper >>>/g) ?? []).length;
+    expect(markerCount).toBe(1);
+  });
+
+  it('keeps user-defined arv function untouched', async () => {
+    const homeDir = await makeHome();
+    const rcPath = path.join(homeDir, '.bashrc');
+    await fs.writeFile(
+      rcPath,
+      `
+arv() {
+  echo "custom wrapper"
+}
+`,
+      'utf8',
+    );
+
+    const result = await ensureArvShellWrapper({
+      homeDir,
+      shellPath: '/bin/bash',
+      stdinIsTTY: true,
+      env: {},
+    });
+
+    expect(result.installed).toBe(false);
+    const content = await fs.readFile(rcPath, 'utf8');
+    expect(content).toContain('custom wrapper');
+    expect(content).not.toContain('# >>> archiver arv wrapper >>>');
+  });
+
+  it('creates fish function file for fish shell', async () => {
+    const homeDir = await makeHome();
+    const result = await ensureArvShellWrapper({
+      homeDir,
+      shellPath: '/usr/bin/fish',
+      stdinIsTTY: true,
+      env: {},
+    });
+
+    expect(result.installed).toBe(true);
+    expect(result.shell).toBe('fish');
+    const fishFunction = await fs.readFile(path.join(homeDir, '.config', 'fish', 'functions', 'arv.fish'), 'utf8');
+    expect(fishFunction).toContain('function arv');
+    expect(fishFunction).toContain('__ARCHIVER_CD__:');
+  });
+
+  it('creates powershell profile wrapper when missing', async () => {
+    const homeDir = await makeHome();
+    const result = await ensureArvShellWrapper({
+      homeDir,
+      shellPath: '/usr/bin/pwsh',
+      stdinIsTTY: true,
+      env: {},
+    });
+
+    expect(result.installed).toBe(true);
+    expect(result.shell).toBe('powershell');
+    expect(result.profilePath).toContain('Microsoft.PowerShell_profile.ps1');
+    expect(result.reloadCommand).toContain('. ');
+    expect(result.profilePath).toBeDefined();
+
+    const profilePath = result.profilePath ?? '';
+    const absoluteProfilePath = profilePath.startsWith('~')
+      ? path.join(homeDir, profilePath.slice(2))
+      : profilePath;
+    const profileContent = await fs.readFile(absoluteProfilePath, 'utf8');
+    expect(profileContent).toContain('function arv');
+    expect(profileContent).toContain('__ARCHIVER_CD__:');
+  });
+});

package/tests/e2e/cli.e2e.test.ts

@@ -0,0 +1,104 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { cleanDirs, mkTempDir, run } from './mock-cli.js';
+
+afterEach(() => {
+  cleanDirs();
+});
+
+describe('cli e2e', () => {
+  it('uses project-local root when NODE_ENV is not production', () => {
+    const projectDir = mkTempDir('archiver-e2e-dev-');
+    const prodRoot = mkTempDir('archiver-e2e-dev-prod-root-');
+    const filePath = path.join(projectDir, 'dev-file.txt');
+    fs.writeFileSync(filePath, 'dev data\n', 'utf8');
+
+    const env = {
+      NODE_ENV: 'development',
+      ARCHIVER_PATH: prodRoot,
+    };
+
+    run(['config', 'update-check', 'off'], { cwd: projectDir, env });
+    run(['put', filePath], { cwd: projectDir, env });
+
+    const rootDir = path.join(projectDir, '.archiver');
+    const archivedObjectPath = path.join(rootDir, 'vaults', '0', '1', 'dev-file.txt');
+    expect(fs.existsSync(archivedObjectPath)).toBe(true);
+    expect(fs.existsSync(path.join(prodRoot, 'vaults', '0', '1', 'dev-file.txt'))).toBe(false);
+
+    const cdOutput = run(['cd', '1', '--print'], { cwd: projectDir, env });
+    expect(cdOutput.trim()).toBe(path.join(rootDir, 'vaults', '0', '1'));
+
+    run(['restore', '1'], { cwd: projectDir, env });
+    expect(fs.existsSync(filePath)).toBe(true);
+    expect(fs.existsSync(path.join(rootDir, 'vaults', '0', '1'))).toBe(false);
+  });
+
+  it('uses ARCHIVER_PATH as root in production runtime', () => {
+    const projectDir = mkTempDir('archiver-e2e-prod-');
+    const fakeHome = mkTempDir('archiver-e2e-home-');
+    const customRoot = mkTempDir('archiver-e2e-custom-root-');
+    const filePath = path.join(projectDir, 'prod-file.txt');
+    fs.writeFileSync(filePath, 'prod data\n', 'utf8');
+
+    const env = {
+      NODE_ENV: 'production',
+      ARCHIVER_PATH: customRoot,
+      HOME: fakeHome,
+    };
+
+    run(['config', 'update-check', 'off'], { cwd: projectDir, env });
+    run(['put', filePath], { cwd: projectDir, env });
+
+    const archivedObjectPath = path.join(customRoot, 'vaults', '0', '1', 'prod-file.txt');
+    const devRoot = path.join(projectDir, '.archiver');
+    const homeRoot = path.join(fakeHome, '.archiver');
+
+    expect(fs.existsSync(archivedObjectPath)).toBe(true);
+    expect(fs.existsSync(devRoot)).toBe(false);
+    expect(fs.existsSync(homeRoot)).toBe(false);
+
+    const cdOutput = run(['cd', '1', '--print'], { cwd: projectDir, env });
+    expect(cdOutput.trim()).toBe(path.join(customRoot, 'vaults', '0', '1'));
+  });
+
+  it('prints names only for list in non-interactive mode', () => {
+    const projectDir = mkTempDir('archiver-e2e-list-');
+    const defaultFilePath = path.join(projectDir, 'list-file.txt');
+    const vaultFilePath = path.join(projectDir, 'list-file-in-work.txt');
+    fs.writeFileSync(defaultFilePath, 'list data\n', 'utf8');
+    fs.writeFileSync(vaultFilePath, 'list data in work\n', 'utf8');
+
+    const env = {
+      NODE_ENV: 'development',
+    };
+
+    run(['config', 'update-check', 'off'], { cwd: projectDir, env });
+    run(['put', defaultFilePath], { cwd: projectDir, env });
+    run(['vault', 'create', 'work'], { cwd: projectDir, env });
+    run(['put', '--vault', 'work', vaultFilePath], { cwd: projectDir, env });
+
+    const output = run(['list'], { cwd: projectDir, env });
+    expect(output).toContain('list-file.txt');
+    expect(output).toContain('work(1)::list-file-in-work.txt');
+    expect(output).not.toContain('@(0)');
+  });
+
+  it('emits cd marker instead of opening subshell for cd', () => {
+    const projectDir = mkTempDir('archiver-e2e-cd-marker-');
+    const filePath = path.join(projectDir, 'cd-file.txt');
+    fs.writeFileSync(filePath, 'cd data\n', 'utf8');
+
+    const env = {
+      NODE_ENV: 'development',
+    };
+
+    run(['config', 'update-check', 'off'], { cwd: projectDir, env });
+    run(['put', filePath], { cwd: projectDir, env });
+    const output = run(['cd', '1'], { cwd: projectDir, env });
+
+    expect(output.trim()).toBe(`__ARCHIVER_CD__:${path.join(projectDir, '.archiver', 'vaults', '0', '1')}`);
+  });
+
+});

package/tests/e2e/mock-cli.ts

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+
+const createdDirs: string[] = [];
+
+export function cleanDirs() {
+  for (const dir of createdDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+export function mkTempDir(prefix: string): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+  createdDirs.push(dir);
+  return dir;
+}
+function shellQuote(value: string): string {
+  return `'${value.replaceAll("'", "'\\''")}'`;
+}
+
+const entry = path.join(import.meta.dirname, '..', '..', 'src', 'index.ts');
+export function run(
+  args: string[],
+  options: {
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+  },
+): string {
+  const command = ['tsx', entry, ...args].join(' ');
+  return execSync(command, {
+    cwd: options.cwd,
+    env: {
+      ...process.env,
+      ...options.env,
+    },
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+    maxBuffer: 1024 * 1024,
+  });
+}

package/tests/services/archive-workflow.test.ts

@@ -0,0 +1,176 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ArchiveStatus, CheckIssueLevel, Paths } from '../../src/consts/index.js';
+import { ArchiverContext } from '../../src/core/context.js';
+import { ArchiveService } from '../../src/services/archive.js';
+import { AuditLogger } from '../../src/services/audit-logger.js';
+import { CheckService } from '../../src/services/check.js';
+import { ConfigService } from '../../src/services/config.js';
+import { VaultService } from '../../src/services/vault.js';
+
+type PathsSnapshot = {
+  dir: Record<keyof typeof Paths.Dir, string>;
+  file: Record<keyof typeof Paths.File, string>;
+};
+
+let snapshot: PathsSnapshot;
+let sandboxRoot: string;
+let workspaceDir: string;
+
+function applyPaths(rootDir: string): void {
+  Object.assign(Paths.Dir, {
+    root: rootDir,
+    vaults: path.join(rootDir, 'vaults'),
+  });
+
+  Object.assign(Paths.File, {
+    config: path.join(rootDir, 'config.jsonc'),
+    autoIncr: path.join(rootDir, 'auto-incr.json'),
+    list: path.join(rootDir, 'list.json'),
+    vaults: path.join(rootDir, 'vaults.json'),
+    log: path.join(rootDir, 'log.jsonl'),
+  });
+}
+
+async function pathExists(targetPath: string): Promise<boolean> {
+  try {
+    await fs.access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function createRuntime(): Promise<{
+  context: ArchiverContext;
+  archiveService: ArchiveService;
+  vaultService: VaultService;
+  checkService: CheckService;
+}> {
+  const context = new ArchiverContext();
+  await context.init();
+
+  const configService = new ConfigService(context);
+  const logger = new AuditLogger(context);
+
+  return {
+    context,
+    archiveService: new ArchiveService(context, configService, logger),
+    vaultService: new VaultService(context, configService),
+    checkService: new CheckService(context),
+  };
+}
+
+beforeEach(async () => {
+  snapshot = {
+    dir: { ...Paths.Dir },
+    file: { ...Paths.File },
+  };
+
+  sandboxRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'archiver-ts-test-'));
+  workspaceDir = path.join(sandboxRoot, 'workspace');
+  await fs.mkdir(workspaceDir, { recursive: true });
+
+  applyPaths(path.join(sandboxRoot, '.archiver'));
+});
+
+afterEach(async () => {
+  Object.assign(Paths.Dir, snapshot.dir);
+  Object.assign(Paths.File, snapshot.file);
+
+  if (sandboxRoot) {
+    await fs.rm(sandboxRoot, { recursive: true, force: true });
+  }
+});
+
+describe('archive workflow', () => {
+  it('archives into <vault>/<id>/<originalName> and restores back', async () => {
+    const runtime = await createRuntime();
+    const sourceFile = path.join(workspaceDir, 'note.txt');
+    await fs.writeFile(sourceFile, 'hello archiver\n', 'utf8');
+
+    const putResult = await runtime.archiveService.put([sourceFile], {
+      message: 'save for later',
+    });
+
+    expect(putResult.failed).toHaveLength(0);
+    expect(putResult.ok).toHaveLength(1);
+    expect(putResult.ok[0]?.id).toBe(1);
+
+    const slotPath = runtime.context.archivePath(0, 1);
+    const archivedObjectPath = runtime.context.archiveObjectPath(0, 1, 'note.txt');
+    expect(await pathExists(sourceFile)).toBe(false);
+    expect(await pathExists(slotPath)).toBe(true);
+    expect(await pathExists(archivedObjectPath)).toBe(true);
+    expect(await pathExists(Paths.File.log)).toBe(true);
+    expect(await pathExists(path.join(Paths.Dir.root, 'logs'))).toBe(false);
+
+    const entriesAfterPut = await runtime.context.loadListEntries(true);
+    expect(entriesAfterPut).toHaveLength(1);
+    expect(entriesAfterPut[0]?.status).toBe(ArchiveStatus.Archived);
+    expect(entriesAfterPut[0]?.item).toBe('note.txt');
+
+    const restoreResult = await runtime.archiveService.restore([1]);
+    expect(restoreResult.failed).toHaveLength(0);
+    expect(restoreResult.ok).toHaveLength(1);
+    expect(await fs.readFile(sourceFile, 'utf8')).toBe('hello archiver\n');
+    expect(await pathExists(slotPath)).toBe(false);
+
+    const entriesAfterRestore = await runtime.context.loadListEntries(true);
+    expect(entriesAfterRestore[0]?.status).toBe(ArchiveStatus.Restored);
+  });
+
+  it('moves archive slots between vaults and resolves cd targets', async () => {
+    const runtime = await createRuntime();
+    const sourceFile = path.join(workspaceDir, 'move-me.txt');
+    await fs.writeFile(sourceFile, 'move me\n', 'utf8');
+
+    await runtime.archiveService.put([sourceFile], {});
+    const createdVault = await runtime.vaultService.createVault({ name: 'work' });
+    const targetVault = createdVault.vault;
+
+    const moveResult = await runtime.archiveService.move([1], 'work');
+    expect(moveResult.failed).toHaveLength(0);
+    expect(moveResult.ok).toHaveLength(1);
+
+    const oldSlotPath = runtime.context.archivePath(0, 1);
+    const newSlotPath = runtime.context.archivePath(targetVault.id, 1);
+    const movedObjectPath = runtime.context.archiveObjectPath(targetVault.id, 1, 'move-me.txt');
+
+    expect(await pathExists(oldSlotPath)).toBe(false);
+    expect(await pathExists(newSlotPath)).toBe(true);
+    expect(await pathExists(movedObjectPath)).toBe(true);
+
+    const byId = await runtime.archiveService.resolveCdTarget('1');
+    expect(byId.slotPath).toBe(newSlotPath);
+    expect(byId.vault.id).toBe(targetVault.id);
+
+    const byVaultAndId = await runtime.archiveService.resolveCdTarget(`work/1`);
+    expect(byVaultAndId.slotPath).toBe(newSlotPath);
+
+    await expect(runtime.archiveService.resolveCdTarget(`@/1`)).rejects.toThrow(
+      `Archive id 1 is in vault ${targetVault.id}, not 0.`,
+    );
+  });
+
+  it('check service reports non-directory numeric archive slots as errors', async () => {
+    const runtime = await createRuntime();
+    const sourceFile = path.join(workspaceDir, 'invalid-slot.txt');
+    await fs.writeFile(sourceFile, 'slot validation\n', 'utf8');
+    await runtime.archiveService.put([sourceFile], {});
+
+    const slotPath = runtime.context.archivePath(0, 1);
+    await fs.rm(slotPath, { recursive: true, force: true });
+    await fs.writeFile(slotPath, 'I should be a directory', 'utf8');
+
+    const report = await runtime.checkService.run();
+    const issueCodes = report.issues.map((issue) => issue.code);
+    expect(issueCodes).toContain('MISSING_ARCHIVE_OBJECT');
+    expect(issueCodes).toContain('INVALID_ARCHIVE_SLOT');
+
+    const invalidSlotIssue = report.issues.find((issue) => issue.code === 'INVALID_ARCHIVE_SLOT');
+    expect(invalidSlotIssue?.level).toBe(CheckIssueLevel.Error);
+  });
+});

package/tests/utils/parse.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, it } from 'vitest';
+import { parseIdList, parseLogRange, parseVaultReference } from '../../src/utils/parse.js';
+
+describe('parseIdList', () => {
+  it('parses numeric ids and preserves order', () => {
+    expect(parseIdList(['12', '2', '99'])).toEqual([12, 2, 99]);
+  });
+
+  it('rejects duplicate ids', () => {
+    expect(() => parseIdList(['1', '1'])).toThrow('Duplicated ids are not allowed.');
+  });
+
+  it('rejects non-numeric ids', () => {
+    expect(() => parseIdList(['1', 'abc'])).toThrow('Invalid id: abc');
+  });
+});
+
+describe('parseLogRange', () => {
+  it('parses default and all ranges', () => {
+    expect(parseLogRange()).toEqual({ mode: 'tail' });
+    expect(parseLogRange('all')).toEqual({ mode: 'all' });
+    expect(parseLogRange('*')).toEqual({ mode: 'all' });
+  });
+
+  it('parses month ranges', () => {
+    expect(parseLogRange('202601')).toEqual({ mode: 'month', from: '202601', to: '202601' });
+    expect(parseLogRange('202501-202512')).toEqual({ mode: 'month', from: '202501', to: '202512' });
+  });
+
+  it('rejects invalid month format or order', () => {
+    expect(() => parseLogRange('202613')).toThrow('Invalid month range: 202613');
+    expect(() => parseLogRange('202512-202501')).toThrow('Invalid range order: 202512-202501');
+  });
+});
+
+describe('parseVaultReference', () => {
+  it('returns id for numeric reference', () => {
+    expect(parseVaultReference('10')).toEqual({ id: 10 });
+  });
+
+  it('returns name for non-numeric reference', () => {
+    expect(parseVaultReference('work')).toEqual({ name: 'work' });
+  });
+});

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "noEmit": false,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "strict": true,
+    "noImplicitOverride": true,
+    "noUncheckedIndexedAccess": false,
+    "exactOptionalPropertyTypes": false,
+    "forceConsistentCasingInFileNames": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "sourceMap": true,
+
+    "outDir": "dist",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  "include": ["src/**/*.ts", "tests/**/*.ts"]
+}

package/vitest.config.ts

@@ -0,0 +1,16 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    fileParallelism: false,
+    clearMocks: true,
+    testTimeout: 30_000,
+  },
+  resolve: {
+    alias: {
+      '@': 'src',
+    },
+  },
+});