docorbit 0.1.0 → 0.1.1

package/dist/packages/workspace/src/ecosystems/cargo.js

@@ -0,0 +1,69 @@
+import { join } from 'node:path';
+export class CargoStrategy {
+    ecosystem = 'cargo';
+    manifestNames = ['cargo.toml'];
+    lockfileNames = ['cargo.lock'];
+    parseManifest(_fileName, content, relPath, packageDir) {
+        const deps = [];
+        let currentSection = '';
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                currentSection = trimmed.slice(1, -1).trim();
+                continue;
+            }
+            const isDep = currentSection === 'dependencies' ||
+                currentSection === 'dev-dependencies' ||
+                currentSection === 'build-dependencies';
+            if (isDep && trimmed && !trimmed.startsWith('#') && trimmed.includes('=')) {
+                const eqIdx = trimmed.indexOf('=');
+                const name = trimmed.slice(0, eqIdx).trim();
+                const val = trimmed.slice(eqIdx + 1).trim();
+                let version = '*';
+                if (val.startsWith('"')) {
+                    version = val.replace(/^"|"$/g, '');
+                }
+                else if (val.startsWith('{')) {
+                    const vMatch = val.match(/version\s*=\s*"([^"]+)"/);
+                    if (vMatch)
+                        version = vMatch[1];
+                }
+                deps.push({
+                    name,
+                    ecosystem: 'cargo',
+                    requestedVersion: version,
+                    sourceFile: relPath,
+                    packagePath: packageDir,
+                    isDev: currentSection === 'dev-dependencies',
+                });
+            }
+        }
+        return deps;
+    }
+    parseLockfile(_fileName, content) {
+        const resolved = new Map();
+        const blocks = content.split('[[package]]');
+        for (const block of blocks) {
+            const nameMatch = block.match(/name\s*=\s*"([^"]+)"/);
+            const verMatch = block.match(/version\s*=\s*"([^"]+)"/);
+            if (nameMatch && verMatch) {
+                resolved.set(nameMatch[1], verMatch[1]);
+            }
+        }
+        return resolved;
+    }
+    resolveVersions(deps, pkgDir, lockfileCache) {
+        const lockMap = lockfileCache.get('Cargo.lock') ||
+            lockfileCache.get('cargo.lock') ||
+            lockfileCache.get(join(pkgDir, 'Cargo.lock')) ||
+            lockfileCache.get(join(pkgDir, 'cargo.lock'));
+        if (lockMap) {
+            for (const dep of deps) {
+                const resolved = lockMap.get(dep.name);
+                if (resolved)
+                    dep.resolvedVersion = resolved;
+            }
+        }
+    }
+}

package/dist/packages/workspace/src/ecosystems/composer.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectDependency } from '../../../shared/src/index.ts';
+import type { EcosystemStrategy } from './types.ts';
+export declare class ComposerStrategy implements EcosystemStrategy {
+    readonly ecosystem = "composer";
+    readonly manifestNames: string[];
+    parseManifest(_fileName: string, content: string, relPath: string, packageDir: string): ProjectDependency[];
+}

package/dist/packages/workspace/src/ecosystems/composer.js

@@ -0,0 +1,40 @@
+export class ComposerStrategy {
+    ecosystem = 'composer';
+    manifestNames = ['composer.json'];
+    parseManifest(_fileName, content, relPath, packageDir) {
+        const deps = [];
+        try {
+            const composer = JSON.parse(content);
+            if (composer.require && typeof composer.require === 'object') {
+                for (const [name, ver] of Object.entries(composer.require)) {
+                    if (name === 'php')
+                        continue;
+                    deps.push({
+                        name,
+                        ecosystem: 'composer',
+                        requestedVersion: String(ver),
+                        sourceFile: relPath,
+                        packagePath: packageDir,
+                        isDev: false,
+                    });
+                }
+            }
+            if (composer['require-dev'] && typeof composer['require-dev'] === 'object') {
+                for (const [name, ver] of Object.entries(composer['require-dev'])) {
+                    deps.push({
+                        name,
+                        ecosystem: 'composer',
+                        requestedVersion: String(ver),
+                        sourceFile: relPath,
+                        packagePath: packageDir,
+                        isDev: true,
+                    });
+                }
+            }
+        }
+        catch {
+            // Ignore malformed JSON
+        }
+        return deps;
+    }
+}

package/dist/packages/workspace/src/ecosystems/go.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectDependency } from '../../../shared/src/index.ts';
+import type { EcosystemStrategy } from './types.ts';
+export declare class GoStrategy implements EcosystemStrategy {
+    readonly ecosystem = "go";
+    readonly manifestNames: string[];
+    parseManifest(_fileName: string, content: string, relPath: string, packageDir: string): ProjectDependency[];
+}

package/dist/packages/workspace/src/ecosystems/go.js

@@ -0,0 +1,49 @@
+export class GoStrategy {
+    ecosystem = 'go';
+    manifestNames = ['go.mod'];
+    parseManifest(_fileName, content, relPath, packageDir) {
+        const deps = [];
+        const lines = content.split('\n');
+        let inRequireBlock = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('require (')) {
+                inRequireBlock = true;
+                continue;
+            }
+            if (inRequireBlock && trimmed === ')') {
+                inRequireBlock = false;
+                continue;
+            }
+            if (inRequireBlock && trimmed && !trimmed.startsWith('//')) {
+                const parts = trimmed.split(/\s+/);
+                if (parts.length >= 2) {
+                    deps.push({
+                        name: parts[0],
+                        ecosystem: 'go',
+                        requestedVersion: parts[1],
+                        resolvedVersion: parts[1].replace(/^\+incompatible$/, ''),
+                        sourceFile: relPath,
+                        packagePath: packageDir,
+                        isDev: false,
+                    });
+                }
+            }
+            else if (trimmed.startsWith('require ') && !trimmed.includes('(')) {
+                const parts = trimmed.slice('require '.length).trim().split(/\s+/);
+                if (parts.length >= 2) {
+                    deps.push({
+                        name: parts[0],
+                        ecosystem: 'go',
+                        requestedVersion: parts[1],
+                        resolvedVersion: parts[1].replace(/^\+incompatible$/, ''),
+                        sourceFile: relPath,
+                        packagePath: packageDir,
+                        isDev: false,
+                    });
+                }
+            }
+        }
+        return deps;
+    }
+}

package/{packages/workspace/src/ecosystems/index.ts → dist/packages/workspace/src/ecosystems/index.d.ts}

@@ -7,28 +7,6 @@ import { ComposerStrategy } from './composer.ts';
 import { RubyGemsStrategy } from './rubygems.ts';
 import { PubStrategy } from './pub.ts';
 import { MavenStrategy } from './maven.ts';
-
 export type { EcosystemStrategy } from './types.ts';
-export {
-  NpmStrategy,
-  CargoStrategy,
-  GoStrategy,
-  PyPiStrategy,
-  ComposerStrategy,
-  RubyGemsStrategy,
-  PubStrategy,
-  MavenStrategy,
-};
-
-export function getDefaultStrategies(): EcosystemStrategy[] {
-  return [
-    new NpmStrategy(),
-    new CargoStrategy(),
-    new GoStrategy(),
-    new PyPiStrategy(),
-    new ComposerStrategy(),
-    new RubyGemsStrategy(),
-    new PubStrategy(),
-    new MavenStrategy(),
-  ];
-}
+export { NpmStrategy, CargoStrategy, GoStrategy, PyPiStrategy, ComposerStrategy, RubyGemsStrategy, PubStrategy, MavenStrategy, };
+export declare function getDefaultStrategies(): EcosystemStrategy[];

package/dist/packages/workspace/src/ecosystems/index.js

@@ -0,0 +1,21 @@
+import { NpmStrategy } from "./npm.js";
+import { CargoStrategy } from "./cargo.js";
+import { GoStrategy } from "./go.js";
+import { PyPiStrategy } from "./pypi.js";
+import { ComposerStrategy } from "./composer.js";
+import { RubyGemsStrategy } from "./rubygems.js";
+import { PubStrategy } from "./pub.js";
+import { MavenStrategy } from "./maven.js";
+export { NpmStrategy, CargoStrategy, GoStrategy, PyPiStrategy, ComposerStrategy, RubyGemsStrategy, PubStrategy, MavenStrategy, };
+export function getDefaultStrategies() {
+    return [
+        new NpmStrategy(),
+        new CargoStrategy(),
+        new GoStrategy(),
+        new PyPiStrategy(),
+        new ComposerStrategy(),
+        new RubyGemsStrategy(),
+        new PubStrategy(),
+        new MavenStrategy(),
+    ];
+}

package/dist/packages/workspace/src/ecosystems/maven.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectDependency } from '../../../shared/src/index.ts';
+import type { EcosystemStrategy } from './types.ts';
+export declare class MavenStrategy implements EcosystemStrategy {
+    readonly ecosystem = "maven";
+    readonly manifestNames: string[];
+    parseManifest(_fileName: string, content: string, relPath: string, packageDir: string): ProjectDependency[];
+}

package/dist/packages/workspace/src/ecosystems/maven.js

@@ -0,0 +1,28 @@
+export class MavenStrategy {
+    ecosystem = 'maven';
+    manifestNames = ['pom.xml'];
+    parseManifest(_fileName, content, relPath, packageDir) {
+        const deps = [];
+        const depRegex = /<dependency>([\s\S]*?)<\/dependency>/g;
+        let match;
+        while ((match = depRegex.exec(content)) !== null) {
+            const block = match[1];
+            const groupMatch = block.match(/<groupId>([^<]+)<\/groupId>/);
+            const artifactMatch = block.match(/<artifactId>([^<]+)<\/artifactId>/);
+            const verMatch = block.match(/<version>([^<]+)<\/version>/);
+            if (artifactMatch) {
+                const name = groupMatch ? `${groupMatch[1]}:${artifactMatch[1]}` : artifactMatch[1];
+                deps.push({
+                    name,
+                    ecosystem: 'maven',
+                    requestedVersion: verMatch ? verMatch[1].trim() : '*',
+                    resolvedVersion: verMatch ? verMatch[1].trim() : undefined,
+                    sourceFile: relPath,
+                    packagePath: packageDir,
+                    isDev: block.includes('<scope>test</scope>'),
+                });
+            }
+        }
+        return deps;
+    }
+}

package/dist/packages/workspace/src/ecosystems/npm.d.ts

@@ -0,0 +1,10 @@
+import type { ProjectDependency } from '../../../shared/src/index.ts';
+import type { EcosystemStrategy } from './types.ts';
+export declare class NpmStrategy implements EcosystemStrategy {
+    readonly ecosystem = "npm";
+    readonly manifestNames: string[];
+    readonly lockfileNames: string[];
+    parseManifest(_fileName: string, content: string, relPath: string, packageDir: string): ProjectDependency[];
+    parseLockfile(_fileName: string, content: string): Map<string, string>;
+    resolveVersions(deps: ProjectDependency[], pkgDir: string, lockfileCache: Map<string, Map<string, string>>): void;
+}

package/dist/packages/workspace/src/ecosystems/npm.js

@@ -0,0 +1,73 @@
+import { join } from 'node:path';
+export class NpmStrategy {
+    ecosystem = 'npm';
+    manifestNames = ['package.json'];
+    lockfileNames = ['package-lock.json'];
+    parseManifest(_fileName, content, relPath, packageDir) {
+        const deps = [];
+        try {
+            const pkg = JSON.parse(content);
+            const addSection = (section, isDev) => {
+                if (!section)
+                    return;
+                for (const [name, version] of Object.entries(section)) {
+                    deps.push({
+                        name,
+                        ecosystem: 'npm',
+                        requestedVersion: String(version),
+                        sourceFile: relPath,
+                        packagePath: packageDir,
+                        isDev,
+                    });
+                }
+            };
+            addSection(pkg.dependencies, false);
+            addSection(pkg.devDependencies, true);
+            addSection(pkg.peerDependencies, false);
+        }
+        catch {
+            // Malformed JSON
+        }
+        return deps;
+    }
+    parseLockfile(_fileName, content) {
+        const resolved = new Map();
+        try {
+            const lock = JSON.parse(content);
+            // npm v2/v3 lockfile format
+            if (lock.packages && typeof lock.packages === 'object') {
+                for (const [key, val] of Object.entries(lock.packages)) {
+                    if (val && typeof val === 'object' && val.version) {
+                        const pkgName = key.replace(/^node_modules\//, '');
+                        if (pkgName && !pkgName.includes('node_modules')) {
+                            resolved.set(pkgName, String(val.version));
+                        }
+                    }
+                }
+            }
+            // npm v1 lockfile format fallback
+            if (lock.dependencies && typeof lock.dependencies === 'object') {
+                for (const [name, val] of Object.entries(lock.dependencies)) {
+                    if (val && typeof val === 'object' && val.version) {
+                        resolved.set(name, String(val.version));
+                    }
+                }
+            }
+        }
+        catch {
+            // Malformed lockfile
+        }
+        return resolved;
+    }
+    resolveVersions(deps, pkgDir, lockfileCache) {
+        const lockMap = lockfileCache.get('package-lock.json') ||
+            lockfileCache.get(join(pkgDir, 'package-lock.json'));
+        if (lockMap) {
+            for (const dep of deps) {
+                const resolved = lockMap.get(dep.name);
+                if (resolved)
+                    dep.resolvedVersion = resolved;
+            }
+        }
+    }
+}

package/dist/packages/workspace/src/ecosystems/pub.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectDependency } from '../../../shared/src/index.ts';
+import type { EcosystemStrategy } from './types.ts';
+export declare class PubStrategy implements EcosystemStrategy {
+    readonly ecosystem = "pub";
+    readonly manifestNames: string[];
+    parseManifest(_fileName: string, content: string, relPath: string, packageDir: string): ProjectDependency[];
+}

package/dist/packages/workspace/src/ecosystems/pub.js

@@ -0,0 +1,34 @@
+export class PubStrategy {
+    ecosystem = 'pub';
+    manifestNames = ['pubspec.yaml'];
+    parseManifest(_fileName, content, relPath, packageDir) {
+        const deps = [];
+        const lines = content.split('\n');
+        let inDependencies = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed === 'dependencies:' || trimmed === 'dev_dependencies:') {
+                inDependencies = true;
+                continue;
+            }
+            if (inDependencies && /^[a-zA-Z0-9_]+:/.test(line) && !line.startsWith(' ')) {
+                inDependencies = false;
+                continue;
+            }
+            if (inDependencies && trimmed && !trimmed.startsWith('#')) {
+                const match = trimmed.match(/^([a-zA-Z0-9_]+)\s*:\s*(.+)$/);
+                if (match && match[1] !== 'sdk' && match[1] !== 'flutter') {
+                    deps.push({
+                        name: match[1],
+                        ecosystem: 'pub',
+                        requestedVersion: match[2]?.trim() || '*',
+                        sourceFile: relPath,
+                        packagePath: packageDir,
+                        isDev: false,
+                    });
+                }
+            }
+        }
+        return deps;
+    }
+}

package/dist/packages/workspace/src/ecosystems/pypi.d.ts

@@ -0,0 +1,9 @@
+import type { ProjectDependency } from '../../../shared/src/index.ts';
+import type { EcosystemStrategy } from './types.ts';
+export declare class PyPiStrategy implements EcosystemStrategy {
+    readonly ecosystem = "pypi";
+    readonly manifestNames: string[];
+    parseManifest(fileName: string, content: string, relPath: string, packageDir: string): ProjectDependency[];
+    private parseRequirementsTxt;
+    private parsePyprojectToml;
+}

package/dist/packages/workspace/src/ecosystems/pypi.js

@@ -0,0 +1,94 @@
+export class PyPiStrategy {
+    ecosystem = 'pypi';
+    manifestNames = ['requirements.txt', 'pyproject.toml'];
+    parseManifest(fileName, content, relPath, packageDir) {
+        const lower = fileName.toLowerCase();
+        if (lower === 'requirements.txt') {
+            return this.parseRequirementsTxt(content, relPath, packageDir);
+        }
+        if (lower === 'pyproject.toml') {
+            return this.parsePyprojectToml(content, relPath, packageDir);
+        }
+        return [];
+    }
+    parseRequirementsTxt(content, relPath, packageDir) {
+        const deps = [];
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('-'))
+                continue;
+            // Match name and version specifier (e.g. requests==2.31.0, flask>=3.0.0, numpy)
+            const match = trimmed.match(/^([a-zA-Z0-9_.-]+)\s*([=><~^!].*)?$/);
+            if (match) {
+                const name = match[1];
+                const spec = match[2]?.trim() || '*';
+                const exactMatch = spec.match(/^==\s*([a-zA-Z0-9_.-]+)$/);
+                deps.push({
+                    name,
+                    ecosystem: 'pypi',
+                    requestedVersion: spec,
+                    resolvedVersion: exactMatch ? exactMatch[1] : undefined,
+                    sourceFile: relPath,
+                    packagePath: packageDir,
+                    isDev: false,
+                });
+            }
+        }
+        return deps;
+    }
+    parsePyprojectToml(content, relPath, packageDir) {
+        const deps = [];
+        const lines = content.split('\n');
+        let inDependencies = false;
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                const sec = trimmed.slice(1, -1).trim();
+                inDependencies =
+                    sec === 'project.dependencies' ||
+                        sec === 'tool.poetry.dependencies' ||
+                        sec === 'project.optional-dependencies';
+                continue;
+            }
+            if (inDependencies && trimmed && !trimmed.startsWith('#')) {
+                // Poetry format: name = "^1.2.3" or name = { version = "1.2.3" }
+                const eqIdx = trimmed.indexOf('=');
+                if (eqIdx !== -1) {
+                    const name = trimmed.slice(0, eqIdx).trim();
+                    if (name.toLowerCase() === 'python')
+                        continue;
+                    const val = trimmed.slice(eqIdx + 1).trim();
+                    let ver = '*';
+                    const vMatch = val.match(/"([^"]+)"/);
+                    if (vMatch)
+                        ver = vMatch[1];
+                    deps.push({
+                        name,
+                        ecosystem: 'pypi',
+                        requestedVersion: ver,
+                        sourceFile: relPath,
+                        packagePath: packageDir,
+                        isDev: false,
+                    });
+                }
+                else if (trimmed.startsWith('"') || trimmed.startsWith("'")) {
+                    // Standard PEP 621: "requests>=2.28.0",
+                    const clean = trimmed.replace(/^[",']|[",']$/g, '');
+                    const match = clean.match(/^([a-zA-Z0-9_.-]+)\s*([=><~^!].*)?$/);
+                    if (match) {
+                        deps.push({
+                            name: match[1],
+                            ecosystem: 'pypi',
+                            requestedVersion: match[2]?.trim() || '*',
+                            sourceFile: relPath,
+                            packagePath: packageDir,
+                            isDev: false,
+                        });
+                    }
+                }
+            }
+        }
+        return deps;
+    }
+}

package/dist/packages/workspace/src/ecosystems/rubygems.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectDependency } from '../../../shared/src/index.ts';
+import type { EcosystemStrategy } from './types.ts';
+export declare class RubyGemsStrategy implements EcosystemStrategy {
+    readonly ecosystem = "rubygems";
+    readonly manifestNames: string[];
+    parseManifest(_fileName: string, content: string, relPath: string, packageDir: string): ProjectDependency[];
+}

package/dist/packages/workspace/src/ecosystems/rubygems.js

@@ -0,0 +1,25 @@
+export class RubyGemsStrategy {
+    ecosystem = 'rubygems';
+    manifestNames = ['gemfile'];
+    parseManifest(_fileName, content, relPath, packageDir) {
+        const deps = [];
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('gem ') || trimmed.startsWith("gem\t")) {
+                const match = trimmed.match(/^gem\s+['"]([^'"]+)['"](?:\s*,\s*['"]([^'"]+)['"])?/);
+                if (match) {
+                    deps.push({
+                        name: match[1],
+                        ecosystem: 'rubygems',
+                        requestedVersion: match[2] || '*',
+                        sourceFile: relPath,
+                        packagePath: packageDir,
+                        isDev: false,
+                    });
+                }
+            }
+        }
+        return deps;
+    }
+}

package/dist/packages/workspace/src/ecosystems/types.d.ts

@@ -0,0 +1,9 @@
+import type { Ecosystem, ProjectDependency } from '../../../shared/src/index.ts';
+export interface EcosystemStrategy {
+    readonly ecosystem: Ecosystem;
+    readonly manifestNames: string[];
+    readonly lockfileNames?: string[];
+    parseManifest(fileName: string, content: string, relPath: string, packageDir: string): ProjectDependency[];
+    parseLockfile?(fileName: string, content: string): Map<string, string>;
+    resolveVersions?(deps: ProjectDependency[], pkgDir: string, lockfileCache: Map<string, Map<string, string>>): void;
+}

package/dist/packages/workspace/src/ecosystems/types.js

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

package/dist/packages/workspace/src/index.js

@@ -0,0 +1,5 @@
+export * from "./semver.js";
+export * from "./detector.js";
+export * from "./lockfile.js";
+export * from "./resolver.js";
+export * from "./ecosystems/index.js";

package/dist/packages/workspace/src/lockfile.d.ts

@@ -0,0 +1,21 @@
+import type { DocsLock, WorkspaceScanResult } from '../../shared/src/index.ts';
+import type { DocOrbitRepository } from '../../storage/src/index.ts';
+export declare const DOCS_LOCK_FILENAME = "docs.lock";
+/**
+ * Reads and parses docs.lock from a project directory if present.
+ */
+export declare function readDocsLock(projectDir: string): DocsLock | null;
+/**
+ * Deterministically writes a docs.lock file to project directory.
+ * Sorts dependency keys alphabetically and uses 2-space indentation.
+ */
+export declare function writeDocsLock(projectDir: string, lock: DocsLock): void;
+/**
+ * Generates a DocsLock manifest from workspace scan result and repository state.
+ * Preserves timestamps for unchanged documentation snapshots to prevent lockfile churn.
+ */
+export declare function generateDocsLock(scanResult: WorkspaceScanResult, repo: DocOrbitRepository, existingLock?: DocsLock | null): DocsLock;
+/**
+ * Selectively or globally updates docs.lock for a project.
+ */
+export declare function updateDocsLock(scanResult: WorkspaceScanResult, repo: DocOrbitRepository, existingLock: DocsLock, specificDependency?: string): DocsLock;