@ldsg/cli 0.3.28 → 0.3.30

package/src/commands/resource/list.ts

@@ -0,0 +1,161 @@
+import { ResourceRecord, ResourceRecords } from '@ldsg/types';
+import { ResourceFilter } from '../../types/resource-record';
+
+function filterByKind(records: ResourceRecords, kind?: string): ResourceRecords {
+  if (!kind) return records;
+  return records.filter((r) => r.kind === kind);
+}
+
+function filterByParentId(records: ResourceRecords, parentId?: string): ResourceRecords {
+  if (parentId === undefined || parentId === null) return records;
+  return records.filter((r) => r.parentId === parentId);
+}
+
+function getDescendantIds(allRecords: ResourceRecords, rootId: string): Set<string> {
+  const childMap = new Map<string, string[]>();
+  for (const r of allRecords) {
+    const pid = r.parentId || 'null';
+    if (!childMap.has(pid)) childMap.set(pid, []);
+    childMap.get(pid)!.push(r.id);
+  }
+
+  const result = new Set<string>();
+  const queue = [rootId];
+  while (queue.length > 0) {
+    const id = queue.shift()!;
+    if (result.has(id)) continue;
+    result.add(id);
+    const children = childMap.get(id) || [];
+    for (const childId of children) {
+      queue.push(childId);
+    }
+  }
+  return result;
+}
+
+function filterByRootId(records: ResourceRecords, rootId?: string): ResourceRecords {
+  if (!rootId) return records;
+  const ids = getDescendantIds(records, rootId);
+  return records.filter((r) => ids.has(r.id));
+}
+
+function buildChildMap(records: ResourceRecords): Map<string, ResourceRecord[]> {
+  const map = new Map<string, ResourceRecord[]>();
+  for (const r of records) {
+    const pid = r.parentId || 'null';
+    if (!map.has(pid)) map.set(pid, []);
+    map.get(pid)!.push(r);
+  }
+  return map;
+}
+
+function findRoots(records: ResourceRecords): ResourceRecord[] {
+  const roots = records.filter((r) => r.parentId === null || r.parentId === 'root');
+  if (roots.length > 0) return roots;
+  const allParentIds = new Set(records.map((r) => r.parentId).filter(Boolean));
+  return records.filter((r) => !allParentIds.has(r.id));
+}
+
+function buildTree(
+  records: ResourceRecords,
+  rootId: string
+): { resource: ResourceRecord; children: unknown[] } | null {
+  const root = records.find((r) => r.id === rootId);
+  if (!root) return null;
+
+  const childMap = buildChildMap(records);
+
+  function buildSubTree(nodeId: string): { resource: ResourceRecord; children: unknown[] } {
+    const node = records.find((r) => r.id === nodeId)!;
+    const children = (childMap.get(nodeId) || []).map((child) => buildSubTree(child.id));
+    return { resource: node, children };
+  }
+
+  return buildSubTree(rootId);
+}
+
+export async function listResources(
+  records: ResourceRecords,
+  filter: ResourceFilter
+): Promise<{
+  total: number;
+  resources: ResourceRecords;
+}> {
+  let result = records;
+
+  result = filterByKind(result, filter.kind);
+  result = filterByParentId(result, filter.parentId);
+  result = filterByRootId(result, filter.rootId);
+
+  return {
+    total: result.length,
+    resources: result
+  };
+}
+
+export async function getResource(
+  records: ResourceRecords,
+  id: string,
+  options: { children?: boolean; tree?: boolean }
+): Promise<ResourceRecord | (ResourceRecord & { children?: ResourceRecords; tree?: unknown }) | null> {
+  const record = records.find((r) => r.id === id);
+  if (!record) return null;
+
+  if (options.tree) {
+    const tree = buildTree(records, id);
+    return { ...record, tree: tree ? tree : null };
+  }
+
+  if (options.children) {
+    const children = records.filter((r) => r.parentId === id);
+    return { ...record, children };
+  }
+
+  return record;
+}
+
+export async function getTree(
+  records: ResourceRecords,
+  rootId?: string,
+  showKind?: boolean
+): Promise<{ rootId: string; tree: { resource: ResourceRecord; children: unknown[] } }> {
+  let effectiveRootId = rootId;
+
+  if (!effectiveRootId) {
+    const roots = findRoots(records);
+    if (roots.length === 0) {
+      throw new Error('No root resource found. Specify a root-id.');
+    }
+
+    if (roots.length === 1) {
+      effectiveRootId = roots[0].id;
+    } else {
+      effectiveRootId = '__virtual_root__';
+      const virtualRoot: ResourceRecord = {
+        id: '__virtual_root__',
+        kind: 'virtual',
+        parentId: null,
+        settings: { title: 'Virtual Root' }
+      };
+      const childMap = buildChildMap(records);
+      const children = roots.map((r) => buildTree(records, r.id)!).filter(Boolean);
+
+      return {
+        rootId: effectiveRootId,
+        tree: {
+          resource: virtualRoot,
+          children: showKind ? children : children
+        }
+      };
+    }
+  }
+
+  const tree = buildTree(records, effectiveRootId);
+  if (!tree) {
+    throw new Error(`Resource with id "${effectiveRootId}" not found`);
+  }
+
+  return { rootId: effectiveRootId, tree };
+}
+
+export { filterByKind, filterByParentId, filterByRootId, buildChildMap, findRoots, buildTree };

package/src/commands/resource/tree.ts

@@ -0,0 +1,4 @@
+import { ResourceRecords } from '@ldsg/types';
+import { getTree } from './list';
+
+export { getTree };

package/src/commands/resource/update.ts

@@ -0,0 +1,21 @@
+import { ResourceRecord } from '@ldsg/types';
+import { SourceData } from '../../types/resource-record';
+import { updateRecord } from '../../utils/json-file-mutator';
+
+export interface UpdateOptions {
+  sourceData: SourceData;
+  id: string;
+  settings: Record<string, unknown>;
+  dryRun?: boolean;
+}
+
+export async function updateResource(options: UpdateOptions): Promise<{ record: ResourceRecord }> {
+  const { sourceData, id, settings, dryRun } = options;
+
+  if (!settings || Object.keys(settings).length === 0) {
+    throw new Error('Missing required option: --settings');
+  }
+
+  const result = await updateRecord(sourceData, id, settings, dryRun);
+  return { record: result.record };
+}

package/src/constants.ts

@@ -1 +1,4 @@
 export const DEFAULT_OUTPUT_PATH = '.';
+
+export const DEFAULT_SOURCE_FILE = 'resource-records.json';
+export const DEFAULT_SOURCE_PATH = `./${DEFAULT_SOURCE_FILE}`;

package/src/types/resource-record.ts

@@ -0,0 +1,52 @@
+import { ResourceRecord, ResourceRecords } from '@ldsg/types';
+
+export interface CliError {
+  code: string;
+  message: string;
+}
+
+export interface CliResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: CliError;
+}
+
+export interface ResourceFilter {
+  kind?: string;
+  parentId?: string;
+  rootId?: string;
+}
+
+export interface TreeNode {
+  resource: ResourceRecord;
+  children: TreeNode[];
+}
+
+export interface DiffResultField {
+  path: string;
+  from?: unknown;
+  to?: unknown;
+  value?: unknown;
+}
+
+export interface DiffResult {
+  id: string;
+  kind: string;
+  sourceA: string;
+  sourceB: string;
+  changed: DiffResultField[];
+  added: DiffResultField[];
+  removed: DiffResultField[];
+  sideA: ResourceRecord | null;
+  sideB: ResourceRecord | null;
+}
+
+export type SourceFormat = 'array' | 'object';
+
+export interface SourceData {
+  resourceRecords: ResourceRecords;
+  format: SourceFormat;
+  filePath: string;
+}
+
+export { ResourceRecord, ResourceRecords };

package/src/utils/formatter.ts

@@ -0,0 +1,106 @@
+import { CliResponse, TreeNode, DiffResult } from '../types/resource-record';
+
+export function formatSuccess<T>(data: T): CliResponse<T> {
+  return { success: true, data };
+}
+
+export function formatError(code: string, message: string): CliResponse<never> {
+  return { success: false, error: { code, message } };
+}
+
+export function formatJson(data: unknown): string {
+  return JSON.stringify(data, null, 2);
+}
+
+function formatValue(value: unknown): string {
+  if (value === null || value === undefined) {
+    return 'null';
+  }
+  if (typeof value === 'string') {
+    return value;
+  }
+  if (typeof value === 'object') {
+    return JSON.stringify(value);
+  }
+  return String(value);
+}
+
+export function formatPrettyList(
+  resources: { id: string; kind: string; parentId: string | null; title?: string }[]
+): string {
+  if (resources.length === 0) {
+    return 'No resources found.';
+  }
+
+  const lines: string[] = [];
+  lines.push(`${'ID'.padEnd(30)} ${'KIND'.padEnd(20)} PARENT ID`);
+  lines.push('-'.repeat(70));
+
+  for (const r of resources) {
+    const title = r.title || '';
+    const displayId = title ? `${r.id} (${title})` : r.id;
+    lines.push(`${displayId.padEnd(30)} ${r.kind.padEnd(20)} ${r.parentId || '-'}`);
+  }
+
+  lines.push('');
+  lines.push(`Total: ${resources.length} resource(s)`);
+  return lines.join('\n');
+}
+
+export function formatPrettyTree(node: TreeNode, showKind: boolean, indent = ''): string {
+  const prefix = indent ? indent.slice(0, -4) + (indent.endsWith('└── ') ? '    ' : '│   ') : '';
+  const label = showKind ? `[${node.resource.kind}] ${node.resource.id}` : node.resource.id;
+
+  if (indent === '') {
+    const lines: string[] = [label];
+    for (let i = 0; i < node.children.length; i++) {
+      const child = node.children[i];
+      const connector = i === node.children.length - 1 ? '└── ' : '├── ';
+      lines.push(formatPrettyTree(child, showKind, connector));
+    }
+    return lines.join('\n');
+  }
+
+  const result = `${indent}${label}`;
+  const childLines: string[] = [];
+  for (let i = 0; i < node.children.length; i++) {
+    const child = node.children[i];
+    const connector = i === node.children.length - 1 ? '└── ' : '├── ';
+    childLines.push(formatPrettyTree(child, showKind, `${prefix}${connector}`));
+  }
+  return [result, ...childLines].join('\n');
+}
+
+export function formatPrettyDiff(diff: DiffResult): string {
+  const lines: string[] = [];
+  lines.push(`Resource: ${diff.id} (${diff.kind})`);
+  lines.push(`Source A: ${diff.sourceA}`);
+  lines.push(`Source B: ${diff.sourceB}`);
+  lines.push('');
+
+  if (diff.sideA === null) {
+    lines.push('⚠  Resource only exists in source B (new)');
+    return lines.join('\n');
+  }
+  if (diff.sideB === null) {
+    lines.push('⚠  Resource only exists in source A (removed)');
+    return lines.join('\n');
+  }
+
+  if (diff.changed.length === 0 && diff.added.length === 0 && diff.removed.length === 0) {
+    lines.push('No differences found.');
+    return lines.join('\n');
+  }
+
+  for (const field of diff.changed) {
+    lines.push(`  ${field.path}: "${formatValue(field.from)}" → "${formatValue(field.to)}"`);
+  }
+  for (const field of diff.added) {
+    lines.push(`  ${field.path}: +"${formatValue(field.value)}"`);
+  }
+  for (const field of diff.removed) {
+    lines.push(`  ${field.path}: -"${formatValue(field.from)}"`);
+  }
+
+  return lines.join('\n');
+}

package/src/utils/json-file-mutator.ts

@@ -0,0 +1,137 @@
+import fs from 'fs-extra';
+import { ResourceRecord, ResourceRecords } from '@ldsg/types';
+import { SourceData } from '../types/resource-record';
+
+function buildChildMap(resourceRecords: ResourceRecords): Map<string, ResourceRecord[]> {
+  const childMap = new Map<string, ResourceRecord[]>();
+  for (const record of resourceRecords) {
+    const pid = record.parentId || 'null';
+    const children = childMap.get(pid) || [];
+    children.push(record);
+    childMap.set(pid, children);
+  }
+  return childMap;
+}
+
+function getDescendantIds(resourceRecords: ResourceRecords, id: string): string[] {
+  const childMap = buildChildMap(resourceRecords);
+  const ids: string[] = [];
+  const queue = [id];
+  while (queue.length > 0) {
+    const currentId = queue.shift()!;
+    ids.push(currentId);
+    const children = childMap.get(currentId) || [];
+    for (const child of children) {
+      queue.push(child.id);
+    }
+  }
+  return ids;
+}
+
+function extractSourceData(data: unknown): { records: ResourceRecords; isArray: boolean } {
+  if (Array.isArray(data)) {
+    return { records: data as ResourceRecords, isArray: true };
+  }
+  if (data && typeof data === 'object') {
+    const obj = data as Record<string, unknown>;
+    if (Array.isArray(obj.resourceRecords)) {
+      return { records: obj.resourceRecords as ResourceRecords, isArray: false };
+    }
+  }
+  throw new Error('Invalid resource records format');
+}
+
+function buildOutputData(records: ResourceRecords, isArray: boolean): unknown {
+  if (isArray) {
+    return records;
+  }
+  return { resourceRecords: records };
+}
+
+async function readSourceFile(filePath: string): Promise<{ records: ResourceRecords; isArray: boolean }> {
+  const data = await fs.readJson(filePath);
+  return extractSourceData(data);
+}
+
+async function writeSourceFile(filePath: string, records: ResourceRecords, isArray: boolean): Promise<void> {
+  const output = buildOutputData(records, isArray);
+  await fs.writeJson(filePath, output, { spaces: 2 });
+}
+
+export function generateId(): string {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 8);
+  return `${timestamp}-${random}`;
+}
+
+export async function appendRecord(
+  sourceData: SourceData,
+  record: ResourceRecord,
+  dryRun = false
+): Promise<{ record: ResourceRecord; allRecords: ResourceRecords }> {
+  const { records, isArray } = await readSourceFile(sourceData.filePath);
+
+  const existingIndex = records.findIndex((r) => r.id === record.id);
+  if (existingIndex >= 0) {
+    throw new Error(`Resource with id "${record.id}" already exists`);
+  }
+
+  const allRecords = [...records, record];
+
+  if (!dryRun) {
+    await writeSourceFile(sourceData.filePath, allRecords, isArray);
+  }
+
+  return { record, allRecords };
+}
+
+export async function updateRecord(
+  sourceData: SourceData,
+  id: string,
+  settings: Record<string, unknown>,
+  dryRun = false
+): Promise<{ record: ResourceRecord; allRecords: ResourceRecords }> {
+  const { records, isArray } = await readSourceFile(sourceData.filePath);
+
+  const index = records.findIndex((r) => r.id === id);
+  if (index < 0) {
+    throw new Error(`Resource with id "${id}" not found`);
+  }
+
+  const updatedRecord: ResourceRecord = {
+    ...records[index],
+    settings: { ...records[index].settings, ...settings }
+  };
+
+  const allRecords = [...records];
+  allRecords[index] = updatedRecord;
+
+  if (!dryRun) {
+    await writeSourceFile(sourceData.filePath, allRecords, isArray);
+  }
+
+  return { record: updatedRecord, allRecords };
+}
+
+export async function removeRecord(
+  sourceData: SourceData,
+  id: string,
+  dryRun = false
+): Promise<{ removed: ResourceRecord[]; allRecords: ResourceRecords }> {
+  const { records, isArray } = await readSourceFile(sourceData.filePath);
+
+  const targetIndex = records.findIndex((r) => r.id === id);
+  if (targetIndex < 0) {
+    throw new Error(`Resource with id "${id}" not found`);
+  }
+
+  const idsToRemove = new Set(getDescendantIds(records, id));
+  const removed = records.filter((r) => idsToRemove.has(r.id));
+  const allRecords = records.filter((r) => !idsToRemove.has(r.id));
+
+  if (!dryRun) {
+    await writeSourceFile(sourceData.filePath, allRecords, isArray);
+  }
+
+  return { removed, allRecords };
+}

package/src/utils/source-resolver.ts

@@ -0,0 +1,102 @@
+import fs from 'fs-extra';
+import { ResourceRecords } from '@ldsg/types';
+import { DEFAULT_SOURCE_FILE } from '../constants';
+import { SourceData, SourceFormat } from '../types/resource-record';
+
+async function readJsonFile(filePath: string): Promise<unknown> {
+  if (!(await fs.pathExists(filePath))) {
+    throw new Error(`File not found: ${filePath}`);
+  }
+  return fs.readJson(filePath);
+}
+
+function parseResourceRecords(data: unknown): { resourceRecords: ResourceRecords; format: SourceFormat } {
+  if (Array.isArray(data)) {
+    return { resourceRecords: data as ResourceRecords, format: 'array' };
+  }
+
+  if (data && typeof data === 'object') {
+    const obj = data as Record<string, unknown>;
+    if (Array.isArray(obj.resourceRecords)) {
+      return { resourceRecords: obj.resourceRecords as ResourceRecords, format: 'object' };
+    }
+  }
+
+  throw new Error('Invalid resource records format: expected an array or { resourceRecords: [] }');
+}
+
+async function resolveFile(filePath: string): Promise<SourceData> {
+  const data = await readJsonFile(filePath);
+  const { resourceRecords, format } = parseResourceRecords(data);
+  return { resourceRecords, format, filePath };
+}
+
+async function resolveDirectory(dirPath: string): Promise<SourceData> {
+  const filePath = `${dirPath.replace(/\/$/, '')}/${DEFAULT_SOURCE_FILE}`;
+  return resolveFile(filePath);
+}
+
+async function resolveStdin(): Promise<SourceData> {
+  return new Promise((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    process.stdin.setEncoding('utf-8');
+
+    process.stdin.on('data', (chunk: string | Buffer) => {
+      chunks.push(Buffer.from(chunk));
+    });
+
+    process.stdin.on('end', () => {
+      try {
+        const raw = Buffer.concat(chunks).toString('utf-8');
+        const data = JSON.parse(raw);
+        const { resourceRecords, format } = parseResourceRecords(data);
+        resolve({ resourceRecords, format, filePath: '-stdin-' });
+      } catch (error) {
+        reject(new Error(`Failed to parse stdin as JSON: ${(error as Error).message}`));
+      }
+    });
+
+    process.stdin.on('error', (error) => {
+      reject(new Error(`Failed to read stdin: ${error.message}`));
+    });
+  });
+}
+
+export async function resolveSource(source?: string): Promise<SourceData> {
+  if (!source || source === DEFAULT_SOURCE_FILE) {
+    const defaultPath = `./${DEFAULT_SOURCE_FILE}`;
+    if (await fs.pathExists(defaultPath)) {
+      return resolveFile(defaultPath);
+    }
+    throw new Error(`Default source file not found: ${defaultPath}. Use --source to specify a file.`);
+  }
+
+  if (source === '-') {
+    return resolveStdin();
+  }
+
+  const stats = await fs.stat(source).catch(() => null);
+  if (!stats) {
+    throw new Error(`Source not found: ${source}`);
+  }
+
+  if (stats.isDirectory()) {
+    return resolveDirectory(source);
+  }
+
+  return resolveFile(source);
+}
+
+export function isStdinSource(source?: string): boolean {
+  return source === '-';
+}
+
+export function getSourceDescription(source?: string): string {
+  if (!source || source === DEFAULT_SOURCE_FILE) {
+    return `./${DEFAULT_SOURCE_FILE}`;
+  }
+  if (source === '-') {
+    return 'stdin';
+  }
+  return source;
+}